【操作系统】虚拟存储管理

本代码实现了LRU、FIFO以及OPT算法，不过不知道对不对。。。

因为从结果上来看貌似LRU和FIFO相差不大啊（求指正）

调度命令采用模拟随机生成方式~

#include<iostream>
#include<time.h>
#include<queue>
using namespace std;
const int MAXSIZE = 320;
int options[MAXSIZE] = { 0 };
bool findIfExist(int order, int* sg,int number);
int getNumberOfBlock(int order);
int getMinLoc(int* sg, int size);
int sumUsedNumbers(int block, int start);
int searchForLoc(int* sg, int number, int goal);
void produceOptions()
{
    int cont = 0;
    srand(time(NULL));
    while (cont < 320)
    {
        int m = rand() % 320;
        options[cont] = m + 1;
        cont++;
        if (cont >= 320)break;
        int mm = rand() % (m + 2);
        options[cont] = mm;
        cont++;
        if (cont >= 320)break;
        options[cont] = mm + 1;
        cont++;
        if (cont >= 320)break;
        options[cont] = rand() % (318 - mm) + mm + 2;
        cont++;
    }
    cout << "输出结果啦！！！！！！" << endl;
    for (int i = 0; i < 320; i++)
    {
        cout << options[i] << "\t";
        if ((i + 1) % 5 == 0)
            cout << endl;
    }
    cout << "下面开始调度算法！！！！！！！" << endl;
}
void OPT()
{
    //最佳置换算法，页面为9
    int stacks[9] = { -1,-1,-1,-1,-1,-1,-1,-1,-1 };//0位置存储发生缺页的次数
    int address = 0;//内存开始地址
    int breakupNumber = 0;
    for (int i = 0; i < MAXSIZE; i++)
    {
        int block = getNumberOfBlock(options[i]);//命令所在块号
        if (findIfExist(block, stacks,9))
        {
            //goon
        }
        else
        {
            /*分两种情况
            1.内存已满，需要进行页面置换
            2.内存未满，需要进行页面调入
            */
            breakupNumber++;
            if (address < 9)
            {
                stacks[address] = block;
                address++;
            }
            else
            {
                //核心
                int countUse[9] = { 0 };
                for (int j = 0; j < 9; j++)
                {
                    countUse[j] = sumUsedNumbers(stacks[j], i);
                }
                int taotailoc = getMinLoc(countUse, 9);
                stacks[taotailoc] = block;
            }
        }
    }
    cout << "OPT算法命中率为 " << 1 - (1.0 * breakupNumber / MAXSIZE) << endl;
}
int getMinLoc(int* sg,int size)
{
    int minloc = 0;
    for (int i = 1; i < size; i++)
    {
        if (sg[minloc] > sg[i])
        {
            minloc = i;
        }
    }
    return minloc;
}
int getMaxLoc(int* sg, int size)
{
    int maxloc = 0;
    for (int i = 1; i < size; i++)
    {
        if (sg[maxloc] < sg[i])
        {
            maxloc = i;
        }
    }
    return maxloc;
}
int sumUsedNumbers(int block,int start)//获取指定块号要被调用的次数
{
    int cont = 0;
    for (int i = start + 1; i < 320; i++)
    {
        if (getNumberOfBlock(options[i]) == block)
        {
            cont++;
        }
    }
    return cont;
}
int getNumberOfBlock(int order)//根据命令获得该命令所在块号
{
    return order / 10;
}
bool findIfExist(int order, int* sg,int number)//判断是否存在并返回所在位置
{
    bool flag = false;
    for (int i = 1; i < number; i++)//0是记录位
    {
        if (sg[i] == order)
        {
            flag = true;
            break;
        }
    }
    return flag;
}
void FIFO()
{
    queue<int> queues;//队列最大容量为9
    int tab[9] = { -1,-1,-1,-1,-1,-1,-1,-1,-1 };//参考表，加快查询速度
    int breakupNumber = 0;//中断次数
    int tab_address = 0;//从0开始
    for (int i = 0; i < MAXSIZE; i++)
    {
        int block = getNumberOfBlock(options[i]);
        if (findIfExist(block, tab, 9))
        {
            //goon
        }
        else
        {
            //未满就入队
            breakupNumber++;
            if (queues.size()<9)
            {
                queues.push(block);
                tab[tab_address] = block;
                tab_address++;
            }
            else
            {
                int del_number = queues.front();
                queues.pop();//出队~
                tab[searchForLoc(tab, 9, del_number)] = block;
                queues.push(block);
            }
        }
        
    }
    cout << "FIFO算法命中率为 " << 1 - (1.0 * breakupNumber / MAXSIZE) << endl;
}
int searchForLoc(int* sg, int number, int goal)
{
    int loc = 0;
    for (int i = 0; i < number; i++)
    {
        if (sg[i] == goal)
        {
            loc = i;
            break;
        }
    }
    return loc;
}
void LRU()
{
    int stacks[9] = { -1,-1,-1,-1,-1,-1,-1,-1,-1 };
    int tab[9] = { 0 };//记录下使用次数
    int breakupNumber = 0;
    int address = 0;
    for (int i = 0; i < MAXSIZE; i++)
    {
        int block = getNumberOfBlock(options[i]);
        for (int j = 0; j < address; j++)
        {
            tab[j]++;
        }
        if (findIfExist(block, stacks, 9))
        {
            tab[searchForLoc(stacks, 9, block)]=0;

        }
        else
        {
            breakupNumber++;
            
            if (address < 9)
            {
                stacks[address] = block;
                address++;
            }
            else
            {
                int loc=getMaxLoc(tab, 9);
                stacks[loc] = block;
                tab[loc] = 0;
            }
        }
    }
    cout << "LRU算法命中率为 " <<1- (1.0*breakupNumber/MAXSIZE) <<  endl;
}

int main()
{
    produceOptions();
    OPT();
    FIFO();
    LRU();
    return 0;
}