操作系统模拟实验——虚拟页式存储管理系统（先进先出FIFO、最少使用LRU、时钟置换CLOCK和随机置换）

已于 2025-04-23 20:37:27 修改
阅读量2.4k 收藏 39
点赞数 41
CC 4.0 BY-SA版权
文章标签： c++ 课程设计 经验分享
于 2024-06-26 15:21:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Creater_F/article/details/139989948

目录

一、实验目的

  1. 理解虚拟内存和物理内存之间的关系及转化，在什么情况下会发生缺页中断。

  2. 理解和掌握各种页面置换算法的工作原理，包括先进先出（FIFO）、最近最少使用（LRU）、时钟置换（CLOCK）和随机置换算法，并通过模拟实验观察它们的执行过程。

  3. 通过比较不同页面置换算法下系统的性能，理解不同算法的优缺点以及在何种情况下更适用。

  4. 学习如何评估系统性能。通过实验结果，理解如何通过缺页中断次数、平均访问时间等指标去评估系统性能，并能合理地解释实验结果。

  5. 从实验中体验和理解内存访问的局部性原理，提高自己对操作系统虚拟内存管理的理解。

二、实验要求

  1. 设计并实现一个模拟的简单虚拟页式存储管理系统。在该系统中，应能模拟以下功能：创建进程的页表，为进程页面分配内存块，实现逻辑地址向物理地址的转换。当发生缺页时，通过缺页中断处理调入页面，如果需要，可以进行页面置换。

  2. 制定一套模拟数据，包括要访问的页面、需执行的操作等，并按照虚拟页式存储管理的原则进行处理，展示每一步的执行结果。

  3. 能够模拟出页面置换的情况，例如FIFO、LRU、CLOCK和随机置换等算法，比较并分析每种算法下系统的性能。

三、实验代码

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
#include<queue>
#include<cmath>
#include<functional>
#include<stdlib.h>
#include<time.h>

using namespace std;

const int N = 15;//PCB上限个数
const int PAGE_SIZE = pow(2,12);//4096,页面大小设置为4KB
const int M = pow(2,2);//4,内存页面个数
//const int M = 3;
const int INF = 0x3f3f3f3f;//极大值

//进程操作类型
enum PcbOptionType{
    VISIT,//访问
    MODIFY,//修改
};

//定义进程操作的数据结构，将操作拆分为代表逻辑地址的指令和操作类型
struct PcbOption{
    string instruction;//指令（逻辑地址），长度为22位
    PcbOptionType option;//要执行的操作
};

//定义页表项的数据结构
struct PageTableItem{
    int frameNum = -1;//页帧(也称页框、内存块)号，初始状态为-1
    int status = 0;//状态位，表示该页面是否调入内存，status为1代表已调入，初始状态为0
    int exmemAddress = 0;//外存地址，保存页面在外存中的存放位置
    //访问字段，方便页面置换算法进行操作
    int selectedTime = INF;//页面被放入内存的时间
    int visitedTime = INF;//页面最近一次被访问的时间
    int visit = 0;//访问位，表示页面近期是否被访问，0代表近期未被访问
    int dirty = 0;//修改位，表示页面调入内存后是否被修改过，dirty为1代表已修改，初始状态为0

    //初始化函数
    PageTableItem()
    {
        frameNum = -1;
        status = 0;
        dirty = 0;
        exmemAddress = 0;
    }
};

//定义PCB的数据结构
struct PCB{
    int id;//进程编号
    vector<PcbOption> options;//进程操作序列
    vector<PageTableItem> pageTable;//储存在进程中的页表
}p[N];

//定义内存的数据结构，表示一个内存块
struct Memory{
    int value = 0;//内存块中是否存放数据，0代表内存块为空，1代表内存块存在数据，初始状态为0
    int pageNum = -1;//页号，代表当前内存块被进程的哪一个页面占用，-1代表内存块未被占用
    vector<int> memData;//模拟每个内存块中每个字节存放的数据，0代表没有数据，1代表有数据
}mem[M];

//FIFO算法优先队列比较函数
struct cmp
{
	bool operator()(const int &a, const int &b)//selectTime小的靠近队首
	{
		return p[0].pageTable[a].selectedTime > p[0].pageTable[b].selectedTime;
	}
}; 

int pcb_num = 1;//该系统默认只运行一个进程
function<int()> algorithmOption;//选择使用的替换算法
int missingCount = 0;//统计缺页中断次数
int replaceCount = 0;//统计置换次数
int t = 0;//保存页面加入内存的时间
int clockPoint = 0;//CLOCK算法用到的指针，保存指向的页帧号，初始为0

//地址转换函数，输入逻辑地址，输出物理地址
int LogicalToPhysical(string instruction, PcbOptionType option)
{
    //将二进制的指令转化为十进制
    int tmp = 0;
    for(int i = 0; i < instruction.size(); i++)
    {
        tmp <<= 1;
        if(instruction[i] == '1')
            tmp += 1;
    }
    //获得页号和页内偏移量
    int pageNum = tmp / PAGE_SIZE;
    int offset = tmp % PAGE_SIZE;
    //cout << "tmp:" << tmp << " " << pageNum << " " << offset << '\n';
    //判断页号是否越界
    if(pageNum >= p[0].pageTable.size())//页号大于等于页表项个数，则发生越界（内中断），输出报错信息
    {
        printf("指令%s发生越界，页号：%d，页表项个数：%d\n", instruction, pageNum, p[0].pageTable.size());
        return -1;
    }
    //查询页表
    if(p[0].pageTable[pageNum].status == 1)//如果该页面已调入内存，无需置换
    {
        printf("%d号页面已调入内存，访问命中\n", pageNum);
        p[0].pageTable[pageNum].visitedTime = t;
        p[0].pageTable[pageNum].visit = 1;
        return p[0].pageTable[pageNum].frameNum * PAGE_SIZE + offset;//返回物理地址
    }
    else//如果该页面未调入内存
    {
        bool flag = 0;//表示是否采用置换算法，0表示未采用
        missingCount++;//增加缺页次数
        //寻找内存中空的内存块
        int mem_id = -1;//内存中空的内存块的编号，-1代表没有空的内存块
        for(int i = 0; i < M; i++)
        {
            if(mem[i].value == 0)
            {
                mem_id = i;
                break;
            }
        }
        //cout << "mem_id_1:" << mem_id << '\n';
        if(mem_id == -1)//如果内存中没有空的内存块，采用置换算法获得内存块
        {
            flag = 1;
            mem_id = algorithmOption();
            replaceCount++;//增加置换次数
        }
        //cout << "mem_id_2:" << mem_id << '\n';
        if(!flag)
            printf("%d号页面未调入内存，发生缺页，将%d号页面放入空内存块%d\n", pageNum, pageNum, mem_id);
        else
            printf("%d号页面未调入内存，发生缺页，采用替换算法将%d号页面放入内存块%d，替换%d号页面\n",
                pageNum, pageNum, mem_id, mem[mem_id].pageNum);

        mem[mem_id].pageNum = pageNum;//更新页框所对应的页号
        mem[mem_id].value = 1;//页框被占用
        p[0].pageTable[pageNum].frameNum = mem_id;//将页表项中的页帧号更新为mem_id
        p[0].pageTable[pageNum].status = 1;//将页表项中的状态位更新为1
        //更新页表项中的访问字段
        p[0].pageTable[pageNum].selectedTime = t;
        p[0].pageTable[pageNum].visitedTime = t;
        p[0].pageTable[pageNum].visit = 1;//
        if(option == MODIFY)
            p[0].pageTable[pageNum].dirty = 1;

        return mem_id * PAGE_SIZE + offset;//返回物理地址
    }
}

//FIFO算法
int FIFO()
{
    priority_queue<int, vector<int>, cmp> q;//；以页面调入内存的先后顺序排成的队列，保存页号
    if(q.empty())//如果队列为空，则按照页面访问顺序查找在内存中的页面
        for(int i = 0; i < p[0].pageTable.size(); i++)
            if(p[0].pageTable[i].status == 1)
                q.push(i);
    int pageNum = q.top();//从队头取出要替换的页帧（最早进入内存的页面）所对应的页号
    q.pop();
    int frameNum = p[0].pageTable[pageNum].frameNum;//获得对应页帧号
    p[0].pageTable[pageNum].status = 0;//原来的页面移除内存
    q.push(pageNum);//再将页号放入队尾
    return frameNum;//返回要替换的页帧号
}

//LRU算法
int LRU()
{
    int minn = INF;
    int frameNum = -1;//要替换的页帧号
    int pageNum = -1;//要替换的页帧所对应的页号
    for(int i = 0; i < M; i++)
    {
        if(p[0].pageTable[mem[i].pageNum].visitedTime < minn)//如果该页面是最近最久未使用的页面，则替换
        {
            minn = p[0].pageTable[mem[i].pageNum].visitedTime;
            pageNum = mem[i].pageNum;//保存要替换的页帧所对应的页号
            frameNum = i;//保存要替换的页帧号
        }
    }
    p[0].pageTable[pageNum].status = 0;//原来的页面移除内存
    return frameNum;//返回要替换的页帧号
}

//CLOCK算法
int CLOCK()
{
    int frameNum = -1;//要替换的页帧号
    int pageNum = -1;//要替换的页帧所对应的页号
    printf("\n当前循环队列:\n");
    printf("%6s %8s %6s %6s\n", "页帧号", "对应页号", "访问位", "修改位");
    for(int k = 0; k < M; k++)//打印链式结构
    {
        if(k != 0)
        {
            printf("                                 |\n");
            printf("               |                 |\n");
            printf("               v                 |\n");
            printf("                                 |\n");
        }
        if(k == 0)
        {
            printf("%-6d %-8d %-6d %-6d<----\n", k, mem[k].pageNum, 
            p[0].pageTable[mem[k].pageNum].visit, p[0].pageTable[mem[k].pageNum].dirty);
        }
        else if(k == M - 1)
        {
            printf("%-6d %-8d %-6d %-6d-----\n", k, mem[k].pageNum,
            p[0].pageTable[mem[k].pageNum].visit, p[0].pageTable[mem[k].pageNum].dirty);
        }
        else
        {
            printf("%-6d %-8d %-6d %-6d    |\n", k, mem[k].pageNum,
            p[0].pageTable[mem[k].pageNum].visit, p[0].pageTable[mem[k].pageNum].dirty);
        }
    }
    printf("当前替换指针指向的页帧号：%d\n\n", clockPoint);
    for(int i = 1; i <= 4; i++)//从第一轮到第四轮
    {
        if(i == 1)//第一轮，查找第一个访问位和修改位均为0的页面，不修改任何标志位
        {
            for(int k = 0; k < M; k++)
            {
                int j = (clockPoint + k) % M;//扫描到的页帧号
                //如果该页面的访问位和修改位均为0，则替换
                if(p[0].pageTable[mem[j].pageNum].visit == 0 && p[0].pageTable[mem[j].pageNum].dirty == 0)
                {
                    pageNum = mem[j].pageNum;//保存要替换的页帧所对应的页号
                    frameNum = j;//保存要替换的页帧号
                    break;
                }
            }
        }
        else if(i == 2)//第二轮，查找第一个访问位为0，修改位为1的页面，将所有扫描过的帧访问位置为0
        {
            for(int k = 0; k < M; k++)
            {
                int j = (clockPoint + k) % M;//扫描到的页帧号
                //如果该页面的访问位为0，修改位为1，则替换
                if(p[0].pageTable[mem[j].pageNum].visit == 0 && p[0].pageTable[mem[j].pageNum].dirty == 1)
                {
                    pageNum = mem[j].pageNum;//保存要替换的页帧所对应的页号
                    frameNum = j;//保存要替换的页帧号
                    break;
                }
                p[0].pageTable[mem[j].pageNum].visit = 0;//将所有扫描过的帧访问位置为0
            }
        }
        else if(i == 3)//第三轮，查找第一个访问位和修改位均为0的页面，不修改任何标志位
        {
            for(int k = 0; k < M; k++)
            {
                int j = (clockPoint + k) % M;//扫描到的页帧号
                //如果该页面的访问位和修改位均为0，则替换
                if(p[0].pageTable[mem[j].pageNum].visit == 0 && p[0].pageTable[mem[j].pageNum].dirty == 0)
                {
                    pageNum = mem[j].pageNum;//保存要替换的页帧所对应的页号
                    frameNum = j;//保存要替换的页帧号
                    break;
                }
            }
        }
        else//第四轮，查找第一个访问位为0，修改位为1的页面，必然可以找到
        {
            for(int k = 0; k < M; k++)
            {
                int j = (clockPoint + k) % M;//扫描到的页帧号
                //如果该页面的访问位为0，修改位为1，则替换
                if(p[0].pageTable[mem[j].pageNum].visit == 0 && p[0].pageTable[mem[j].pageNum].dirty == 1)
                {
                    pageNum = mem[j].pageNum;//保存要替换的页帧所对应的页号
                    frameNum = j;//保存要替换的页帧号
                    break;
                }
            }
        }
        if(frameNum != -1)//如果找到了要替换的页帧，直接返回
        {
            p[0].pageTable[pageNum].status = 0;//原来的页面移除内存
            clockPoint = (frameNum + 1) % M;//指针指向下一个页帧
            return frameNum;//返回要替换的页帧号
        }
    }
}

//随机置换算法(RRA)
int RRA()
{
    int frameNum = -1;//要替换的页帧号
    int pageNum = -1;//要替换的页帧所对应的页号
    srand(time(NULL));
    frameNum = rand() % M;//页帧号取值区间为0到M-1
    pageNum = mem[frameNum].pageNum;//保存要替换的页帧所对应的页号
    p[0].pageTable[pageNum].status = 0;//原来的页面移除内存
    return frameNum;//返回要替换的页帧号
}

//输入模块
void Input()
{
    //初始化内存，每个内存块有PAGE_SIZE个字节
    for(int i = 0; i < M; i++)
        mem[i].memData.resize(PAGE_SIZE, 0);

    for(int i = 0; i < pcb_num; i++)
    {
        //初始化进程页表
        int pageTableLength;//页表长度
        cout << "请输入页表长度：" << '\n';
        cin >> pageTableLength;
        for(int j = 0; j < pageTableLength; j++)
        {
            PageTableItem pti;//每个页表项初始为默认值
            p[i].pageTable.push_back(pti);//将页表项放入页表
        }
        //初始化进程操作序列
        int optionNum;//操作数量
        cout << "请输入进程操作数量optionNum:" << '\n';
        cin >> optionNum;
        cout << "接下来optionNum行，请分别输入指令和操作类型：" << '\n';
        for(int j = 0; j < optionNum; j++)
        {
            string instruction;//指令
            int opType;//操作类型，0代表访问，1代表修改
            cin >> instruction >> opType;//输入指令和操作类型
            PcbOption po;
            po.instruction = instruction;
            if(opType == 0)
                po.option = VISIT;
            else
                po.option = MODIFY;
            p[i].options.push_back(po);//将该操作放入操作序列
        }
    }
}

//算法选择模块
void ChooseAlgorithm()
{
    cout << "请选择将要使用的页面置换算法：" << '\n';
    cout << "1.先进先出算法（FIFO）" << '\n';
    cout << "2.最近最久未使用算法（LRU）" << '\n';
    cout << "3.时钟置换算法（CLOCK）" << '\n';
    cout << "4.随机置换算法（RRA）" << '\n';
    int op;
    cin >> op;
    switch(op)
    {
        case 1:
            algorithmOption = FIFO;
            break;
        case 2:
            algorithmOption = LRU;
            break;
        case 3:
            algorithmOption = CLOCK;
            break;
        case 4:
            algorithmOption = RRA;
            break;
        default:
            break;
    }
}

//运行测试模块
void RunTest()
{
    cout << "运行过程：" << '\n';
    //逐条执行进程操作序列
    for(int i = 0; i < p[0].options.size(); i++)
    {
        int physicalAddress = LogicalToPhysical(p[0].options[i].instruction, p[0].options[i].option);//逻辑地址转化为物理地址
        cout << "逻辑地址: " << p[0].options[i].instruction << " -> 物理地址: " << physicalAddress << '\n';
        t++;//时间自增
    }
}

//统计数据模块
void ShowData()
{
    cout << "内存数据：" << '\n';
    printf("%6s %8s\n", "页帧号", "进程页号");
    for(int i = 0; i < M; i++)
        printf("%-6d %-8d\n", i, mem[i].pageNum);

    cout << "页表数据：" << '\n';
    printf("%4s %6s %6s %6s %6s\n", "页号", "页帧号", "状态位", "访问位", "修改位");
    for(int i = 0; i < p[0].pageTable.size(); i++)
        printf("%-4d %-6d %-6d %-6d %-6d\n", i, 
            p[0].pageTable[i].frameNum, p[0].pageTable[i].status,
            p[0].pageTable[i].visit, p[0].pageTable[i].dirty);
    cout << "访问次数：" << p[0].options.size() << '\n';
    cout << "缺页中断次数：" << missingCount <<'\n';
    cout << "置换次数：" << replaceCount << '\n';
    cout << "缺页中断率：" << (double)missingCount / p[0].options.size() * 100 << "%\n";
}

int main()
{
    Input();//输入进程要执行的操作序列
    ChooseAlgorithm();//选择将要执行的页面置换算法
    RunTest();//运行测试
    ShowData();//显示统计数据
    return 0;
}

四、实验代码解读

4.1前言

  模拟实验代码语言为c++。

4.2数据结构

4.2.1PCB的数据结构

//定义PCB的数据结构
struct PCB{
    int id;//进程编号
    vector<PcbOption> options;//进程操作序列
    vector<PageTableItem> pageTable;//储存在进程中的页表
}p[N];

  PCB主要保存进程编号、进程操作序列和进程中的页表三个属性。该系统中只有一个p[0]进程运行，该进程模拟所有的页面访问。

4.2.2进程操作的数据结构

//定义进程操作的数据结构，将操作拆分为代表逻辑地址的指令和操作类型
struct PcbOption{
    string instruction;//指令（逻辑地址），长度为22位
    PcbOptionType option;//要执行的操作
};

  PcbOption是进程操作的数据结构，将操作拆分为代表逻辑地址的指令和操作类型。逻辑地址表示p[0]进程将要访问的页面。

4.2.3页表项的数据结构

//定义页表项的数据结构
struct PageTableItem{
    int frameNum = -1;//页帧(也称页框、内存块)号，初始状态为-1
    int status = 0;//状态位，表示该页面是否调入内存，status为1代表已调入，初始状态为0
    int exmemAddress = 0;//外存地址，保存页面在外存中的存放位置
    //访问字段，方便页面置换算法进行操作
    int selectedTime = INF;//页面被放入内存的时间
    int visitedTime = INF;//页面最近一次被访问的时间
    int visit = 0;//访问位，表示页面近期是否被访问，0代表近期未被访问
    int dirty = 0;//修改位，表示页面调入内存后是否被修改过，dirty为1代表已修改，初始状态为0

    //初始化函数
    PageTableItem()
    {
        frameNum = -1;
        status = 0;
        dirty = 0;
        exmemAddress = 0;
    }
};

  PageTableItem是页表项的数据结构。PageTableItem保存页帧号frameNum、状态位status和外存地址exmemAddress等基本属性，同时保持selectedTime、visitedTime、visit和dirty等访问字段，方便页面置换算法进行操作。

4.2.4内存的数据结构

//定义内存的数据结构，表示一个内存块
struct Memory{
    int value = 0;//内存块中是否存放数据，0代表内存块为空，1代表内存块存在数据，初始状态为0
    int pageNum = -1;//页号，代表当前内存块被进程的哪一个页面占用，-1代表内存块未被占用
    vector<int> memData;//模拟每个内存块中每个字节存放的数据，0代表没有数据，1代表有数据
}mem[M];

  Memory是内存块的数据结构，内存块大小M=3。一个内存块中保存数据value、页号pageNum等属性。

4.3主要函数

4.3.1地址转换函数

//地址转换函数，输入逻辑地址，输出物理地址
int LogicalToPhysical(string instruction, PcbOptionType option)
{
    //将二进制的指令转化为十进制
    int tmp = 0;
    for(int i = 0; i < instruction.size(); i++)
    {
        tmp <<= 1;
        if(instruction[i] == '1')
            tmp += 1;
    }
    //获得页号和页内偏移量
    int pageNum = tmp / PAGE_SIZE;
    int offset = tmp % PAGE_SIZE;
    //cout << "tmp:" << tmp << " " << pageNum << " " << offset << '\n';
    //判断页号是否越界
    if(pageNum >= p[0].pageTable.size())//页号大于等于页表项个数，则发生越界（内中断），输出报错信息
    {
        printf("指令%s发生越界，页号：%d，页表项个数：%d\n", instruction, pageNum, p[0].pageTable.size());
        return -1;
    }
    //查询页表
    if(p[0].pageTable[pageNum].status == 1)//如果该页面已调入内存，无需置换
    {
        printf("%d号页面已调入内存，访问命中\n", pageNum);
        p[0].pageTable[pageNum].visitedTime = t;
        p[0].pageTable[pageNum].visit = 1;
        return p[0].pageTable[pageNum].frameNum * PAGE_SIZE + offset;//返回物理地址
    }
    else//如果该页面未调入内存
    {
        bool flag = 0;//表示是否采用置换算法，0表示未采用
        missingCount++;//增加缺页次数
        //寻找内存中空的内存块
        int mem_id = -1;//内存中空的内存块的编号，-1代表没有空的内存块
        for(int i = 0; i < M; i++)
        {
            if(mem[i].value == 0)
            {
                mem_id = i;
                break;
            }
        }
        //cout << "mem_id_1:" << mem_id << '\n';
        if(mem_id == -1)//如果内存中没有空的内存块，采用置换算法获得内存块
        {
            flag = 1;
            mem_id = algorithmOption();
            replaceCount++;//增加置换次数
        }
        //cout << "mem_id_2:" << mem_id << '\n';
        if(!flag)
            printf("%d号页面未调入内存，发生缺页，将%d号页面放入空内存块%d\n", pageNum, pageNum, mem_id);
        else
            printf("%d号页面未调入内存，发生缺页，采用替换算法将%d号页面放入内存块%d，替换%d号页面\n",
                pageNum, pageNum, mem_id, mem[mem_id].pageNum);

        mem[mem_id].pageNum = pageNum;//更新页框所对应的页号
        mem[mem_id].value = 1;//页框被占用
        p[0].pageTable[pageNum].frameNum = mem_id;//将页表项中的页帧号更新为mem_id
        p[0].pageTable[pageNum].status = 1;//将页表项中的状态位更新为1
        //更新页表项中的访问字段
        p[0].pageTable[pageNum].selectedTime = t;
        p[0].pageTable[pageNum].visitedTime = t;
        p[0].pageTable[pageNum].visit = 1;//
        if(option == MODIFY)
            p[0].pageTable[pageNum].dirty = 1;

        return mem_id * PAGE_SIZE + offset;//返回物理地址
    }
}

  地址转换函数将逻辑地址转换为物理地址。该函数先根据逻辑地址计算出页号和页内偏移量，再判断页号是否越界。如果页号未越界就查询页表，未命中的情况下会在内存中寻找空的内存块或者采用页面置换算法。

4.3.2FIFO算法

//FIFO算法优先队列比较函数
struct cmp
{
	bool operator()(const int &a, const int &b)//selectTime小的靠近队首
	{
		return p[0].pageTable[a].selectedTime > p[0].pageTable[b].selectedTime;
	}
};
//FIFO算法
int FIFO()
{
    priority_queue<int, vector<int>, cmp> q;//；以页面调入内存的先后顺序排成的队列，保存页号
    if(q.empty())//如果队列为空，则按照页面访问顺序查找在内存中的页面
        for(int i = 0; i < p[0].pageTable.size(); i++)
            if(p[0].pageTable[i].status == 1)
                q.push(i);
    int pageNum = q.top();//从队头取出要替换的页帧（最早进入内存的页面）所对应的页号
    q.pop();
    int frameNum = p[0].pageTable[pageNum].frameNum;//获得对应页框号
    p[0].pageTable[pageNum].status = 0;//原来的页面移除内存
    q.push(pageNum);//再将页号放入队尾
    return frameNum;//返回要替换的页帧号
}

  设置一个优先队列，保存调入内存的页面的页号。每次从队头取出最早进入内存的页面的页号。

4.3.3LRU算法

//LRU算法
int LRU()
{
    int minn = INF;
    int frameNum = -1;//要替换的页帧号
    int pageNum = -1;//要替换的页帧所对应的页号
    for(int i = 0; i < M; i++)
    {
        if(p[0].pageTable[mem[i].pageNum].visitedTime < minn)//如果该页面是最近最久未使用的页面，则替换
        {
            minn = p[0].pageTable[mem[i].pageNum].visitedTime;
            pageNum = mem[i].pageNum;//保存要替换的页帧所对应的页号
            frameNum = i;//保存要替换的页帧号
        }
    }
    p[0].pageTable[pageNum].status = 0;//原来的页面移除内存
    return frameNum;//返回要替换的页帧号
}

  LRU算法遍历内存中的页面，通过页面最近一次被访问的时间visitedTime来找出最近最久未使用的页面，替换该页面。

4.3.4CLOCK算法

//CLOCK算法
int CLOCK()
{
    int frameNum = -1;//要替换的页帧号
    int pageNum = -1;//要替换的页帧所对应的页号
    printf("\n当前循环队列:\n");
    printf("%6s %8s %6s %6s\n", "页帧号", "对应页号", "访问位", "修改位");
    for(int k = 0; k < M; k++)//打印链式结构
    {
        if(k != 0)
        {
            printf("                                 |\n");
            printf("               |                 |\n");
            printf("               v                 |\n");
            printf("                                 |\n");
        }
        if(k == 0)
        {
            printf("%-6d %-8d %-6d %-6d<----\n", k, mem[k].pageNum, 
            p[0].pageTable[mem[k].pageNum].visit, p[0].pageTable[mem[k].pageNum].dirty);
        }
        else if(k == M - 1)
        {
            printf("%-6d %-8d %-6d %-6d-----\n", k, mem[k].pageNum,
            p[0].pageTable[mem[k].pageNum].visit, p[0].pageTable[mem[k].pageNum].dirty);
        }
        else
        {
            printf("%-6d %-8d %-6d %-6d    |\n", k, mem[k].pageNum,
            p[0].pageTable[mem[k].pageNum].visit, p[0].pageTable[mem[k].pageNum].dirty);
        }
    }
    printf("当前替换指针指向的页帧号：%d\n\n", clockPoint);
    for(int i = 1; i <= 4; i++)//从第一轮到第四轮
    {
        if(i == 1)//第一轮，查找第一个访问位和修改位均为0的页面，不修改任何标志位
        {
            for(int k = 0; k < M; k++)
            {
                int j = (clockPoint + k) % M;//扫描到的页帧号
                //如果该页面的访问位和修改位均为0，则替换
                if(p[0].pageTable[mem[j].pageNum].visit == 0 && p[0].pageTable[mem[j].pageNum].dirty == 0)
                {
                    pageNum = mem[j].pageNum;//保存要替换的页帧所对应的页号
                    frameNum = j;//保存要替换的页帧号
                    break;
                }
            }
        }
        else if(i == 2)//第二轮，查找第一个访问位为0，修改位为1的页面，将所有扫描过的帧访问位置为0
        {
            for(int k = 0; k < M; k++)
            {
                int j = (clockPoint + k) % M;//扫描到的页帧号
                //如果该页面的访问位为0，修改位为1，则替换
                if(p[0].pageTable[mem[j].pageNum].visit == 0 && p[0].pageTable[mem[j].pageNum].dirty == 1)
                {
                    pageNum = mem[j].pageNum;//保存要替换的页帧所对应的页号
                    frameNum = j;//保存要替换的页帧号
                    break;
                }
                p[0].pageTable[mem[j].pageNum].visit = 0;//将所有扫描过的帧访问位置为0
            }
        }
        else if(i == 3)//第三轮，查找第一个访问位和修改位均为0的页面，不修改任何标志位
        {
            for(int k = 0; k < M; k++)
            {
                int j = (clockPoint + k) % M;//扫描到的页帧号
                //如果该页面的访问位和修改位均为0，则替换
                if(p[0].pageTable[mem[j].pageNum].visit == 0 && p[0].pageTable[mem[j].pageNum].dirty == 0)
                {
                    pageNum = mem[j].pageNum;//保存要替换的页帧所对应的页号
                    frameNum = j;//保存要替换的页帧号
                    break;
                }
            }
        }
        else//第四轮，查找第一个访问位为0，修改位为1的页面，必然可以找到
        {
            for(int k = 0; k < M; k++)
            {
                int j = (clockPoint + k) % M;//扫描到的页帧号
                //如果该页面的访问位为0，修改位为1，则替换
                if(p[0].pageTable[mem[j].pageNum].visit == 0 && p[0].pageTable[mem[j].pageNum].dirty == 1)
                {
                    pageNum = mem[j].pageNum;//保存要替换的页帧所对应的页号
                    frameNum = j;//保存要替换的页帧号
                    break;
                }
            }
        }
        if(frameNum != -1)//如果找到了要替换的页帧，直接返回
        {
            p[0].pageTable[pageNum].status = 0;//原来的页面移除内存
            clockPoint = (frameNum + 1) % M;//指针指向下一个页帧
            return frameNum;//返回要替换的页帧号
        }
    }
}

  所有可能被置换的页面形成一个循环队列，clockPoint表示替换指针，visit表示访问位，dirty表示修改位。CLOCK最多经过四轮遍历，找出要替换的页面。

4.3.5RRA随机置换算法

//随机置换算法(RRA)
int RRA()
{
    int frameNum = -1;//要替换的页帧号
    int pageNum = -1;//要替换的页帧所对应的页号
    srand(time(NULL));
    frameNum = rand() % M;//页帧号取值区间为0到M-1
    pageNum = mem[frameNum].pageNum;//保存要替换的页帧所对应的页号
    p[0].pageTable[pageNum].status = 0;//原来的页面移除内存
    return frameNum;//返回要替换的页帧号
}

  利用srand函数模拟RRA算法，随机选择一个页面置换。

4.4用户交互

4.4.1输入模块

//输入模块
void Input()
{
    //初始化内存，每个内存块有PAGE_SIZE个字节
    for(int i = 0; i < M; i++)
        mem[i].memData.resize(PAGE_SIZE, 0);

    for(int i = 0; i < pcb_num; i++)
    {
        //初始化进程页表
        int pageTableLength;//页表长度
        cout << "请输入页表长度：" << '\n';
        cin >> pageTableLength;
        for(int j = 0; j < pageTableLength; j++)
        {
            PageTableItem pti;//每个页表项初始为默认值
            p[i].pageTable.push_back(pti);//将页表项放入页表
        }
        //初始化进程操作序列
        int optionNum;//操作数量
        cout << "请输入进程操作数量optionNum:" << '\n';
        cin >> optionNum;
        cout << "接下来optionNum行，请分别输入指令和操作类型：" << '\n';
        for(int j = 0; j < optionNum; j++)
        {
            string instruction;//指令
            int opType;//操作类型，0代表访问，1代表修改
            cin >> instruction >> opType;//输入指令和操作类型
            PcbOption po;
            po.instruction = instruction;
            if(opType == 0)
                po.option = VISIT;
            else
                po.option = MODIFY;
            p[i].options.push_back(po);//将该操作放入操作序列
        }
    }
}

  输入模块要求用户输入页表长度、操作数量和指令序列。

4.4.2算法选择模块

//算法选择模块
void ChooseAlgorithm()
{
    cout << "请选择将要使用的页面置换算法：" << '\n';
    cout << "1.先进先出算法（FIFO）" << '\n';
    cout << "2.最近最久未使用算法（LRU）" << '\n';
    cout << "3.时钟置换算法（CLOCK）" << '\n';
    cout << "4.随机置换算法（RRA）" << '\n';
    int op;
    cin >> op;
    switch(op)
    {
        case 1:
            algorithmOption = FIFO;
            break;
        case 2:
            algorithmOption = LRU;
            break;
        case 3:
            algorithmOption = CLOCK;
            break;
        case 4:
            algorithmOption = RRA;
            break;
        default:
            break;
    }
}

  算法选择模块要求用户选择要执行的页面置换算法。

4.4.3统计数据模块

//统计数据模块
void ShowData()
{
    cout << "内存数据：" << '\n';
    printf("%6s %8s\n", "页帧号", "进程页号");
    for(int i = 0; i < M; i++)
        printf("%-6d %-8d\n", i, mem[i].pageNum);

    cout << "页表数据：" << '\n';
    printf("%4s %6s %6s %6s %6s\n", "页号", "页帧号", "状态位", "访问位", "修改位");
    for(int i = 0; i < p[0].pageTable.size(); i++)
        printf("%-4d %-6d %-6d %-6d %-6d\n", i, 
            p[0].pageTable[i].frameNum, p[0].pageTable[i].status,
            p[0].pageTable[i].visit, p[0].pageTable[i].dirty);
    cout << "访问次数：" << p[0].options.size() << '\n';
    cout << "缺页中断次数：" << missingCount <<'\n';
    cout << "置换次数：" << replaceCount << '\n';
    cout << "缺页中断率：" << (double)missingCount / p[0].options.size() * 100 << "%\n";
}

  统计数据模块显示内存数据、页表数据和一些性能指标。

4.4.4主函数

int main()
{
    Input();//输入进程要执行的操作序列
    ChooseAlgorithm();//选择将要执行的页面置换算法
    RunTest();//运行测试
    ShowData();//显示统计数据
    return 0;
}

  主函数依次执行输入模块、算法选择模块、运行测试和统计数据模块。

五、实验结果

5.1FIFO算法测试结果

  如下图所示：
在这里插入图片描述
  FIFO测试数据（页面访问序列3 2 1 0 3 2 4 3 2 1 0 4）：

5
12
011000000000000 0
010000000000000 0
001000000000000 0
000000000000000 0
011000000000000 0
010000000000000 0
100000000000000 0
011000000000000 0
010000000000000 0
001000000000000 0
000000000000000 0
100000000000000 0

5.2LRU算法测试结果

  如下图所示：
在这里插入图片描述
  LRU测试数据：（页面访问序列1 8 1 7 8 2 7 2 1 8 3 8 2 1 3 1 7 1 3 7）：

9
20
0001000000000000 0
1000000000000000 0
0001000000000000 0
0111000000000000 0
1000000000000000 0
0010000000000000 0
0111000000000000 0
0010000000000000 0
0001000000000000 0
1000000000000000 0
0011000000000000 0
1000000000000000 0
0010000000000000 0
0001000000000000 0
0011000000000000 0
0001000000000000 0
0111000000000000 0
0001000000000000 0
0011000000000000 0
0111000000000000 0

5.3CLOCK算法测试结果

  如下图所示：
在这里插入图片描述

在这里插入图片描述
  CLOCK测试数据（两组，对比着用。页面访问序列1 3 4 2 5 6 3 4 7）：

8
9
001000000000000 0
011000000000000 0
100000000000000 0
010000000000000 0
101000000000000 0
110000000000000 0
011000000000000 0
100000000000000 0
111000000000000 0

8
9
001000000000000 0
011000000000000 0
100000000000000 1
010000000000000 0
101000000000000 0
110000000000000 0
011000000000000 0
100000000000000 0
111000000000000 0

5.4随机置换算法测试结果

  这个没什么好说的了，毕竟是随机的对吧。

六、结语

​ 本实验设计思路参考王道考研操作系统，代码均为本人原创。如果有什么错误，欢迎大伙儿在评论区指正ヾ(●´▽‘●)ノ。

晓枫F_
关注
操作系统模拟实验
siper12138的博客
06-23 1796
开门见山，此篇文章向大家分享一个我个人开发的代码，主要实现在线模拟操作系统的几个小实验，可以说是一个在线的模拟平台（项目文件传至资源，可自行下载，私戳我也可以获取） 项目文件https://download.csdn.net/download/siper12138/19785232?spm=1001.2014.3001.5503 平台具有一定的局限性，只能模拟以下四个实验 2处理器调度（20分） 1.1 实验目的 熟悉使用各种单处理器调度的各种算法，加深对于处理机调度机制的理解。练习模拟算法的编程技巧，锻炼
操作系统模拟实验——进程调度实验（时间片轮转调度、短进程优先调度和多级反馈队列调度）
晓枫的博客
06-25 4490
1. 理解在单处理器环境下的进程调度及状态转换的基本原理和关键点。 2. 编程实现时间片轮转调度、短进程优先调度和多级反馈队列调度算法。 3. 分析并比较不同调度算法的效率和公平性。 模拟实验代码语言为c++。本实验设计思路参考王道考研操作系统，90%以上代码为本人原创。如果有什么错误，欢迎大伙儿在评论区指正ヾ(●´▽‘●)ノ。
操作系统 页式虚拟存储
08-22
页式虚拟存储器实现的一个难点是设计页面调度（置换）算法，即将新页面调入内存时，如果内存中所有的物理页都已经分配出去，就要按某种策略来废弃某个页面，将其所占据的物理页释放出来，供新页面使用。本实验的目的是通过编程实现几种常见的页面调度（置换）算法，进一步掌握虚拟存储器的实现，比较各个页面置换算法的优缺点，加深读者对页面思想的理解。
操作系统原理模拟实验（基于C/C++模拟处理机调度、存储管理和文件系统）
热门推荐
为你永远铭记的博客
12-22 1万+
包含完整的源代码可直接编译运行，以及相关核心逻辑方法的详细注解和实验要求 一、处理机调度模拟 二、存储管理模拟：动态分区分配、分页存储地址转换 三、文件系统模拟 如有需要，请前往Gitee进行源码的下载： https://gitee.com/JJJZZZYYY/operating-system-principle Tip：如需转发或引用此博文及相关内容，请附带此原博文链接：https://blog.csdn.net/jzycloud/article/details/110703988
操作系统 C++ 页面置换算法（含实验报告）有opt，LRU，先进先出，时钟算法，改进的时钟算法等所有算法
06-18
先进先出置换算法（FIFO）：选择最先进入内存即在内存驻留时间最久的页面换出到外存。 最近最久未使用置换算法（LRU）: 以“最近的过去”作为“最近的将来”的近似，选择最近一段时间最长时间未被访问的页面淘汰出...
页面置换算法最佳，FIFO，LRU，随机，简单CLOCK,改进CLOCK.zip
02-24
本程序涵盖了五种常见的页面置换算法：最佳置换算法（OPT）、先进先出算法（FIFO）、最近最久未使用算法（LRU）、随机置换算法（RAND）以及两种时钟算法（简单时钟和改进时钟）。下面将对这些算法进行详细介绍，并...
【操作系统不挂科】逐步骤详解——＞四种页面置换算法例题＜LPU最近最久未使用＆OPT最优＆FIFO先进先出＆CLOCK时钟置换算法＞(16)
YYDsis的博客
11-30 1942
逐步骤详解——＞四种页面置换算法例题＜LPU最近最久未使用＆OPT最优＆FIFO先进先出＆CLOCK时钟置换算法＞；每个变换过程都有详细介绍
操作系统课程设计基于C++实现的操作系统仿真虚拟页式存储管理项目源代码
04-12
常见的页面置换算法有先进先出算法(FIFO)、最近最少使用算法(LRU)、时钟算法(Clock)等。项目中的MemoryManager-master模块能够让学生实现和比较这些算法，通过实践来理解它们各自的优缺点及适用场景。 通过操作系统...
【操作系统内存管理】页面置换算法综述：常见算法原理、性能评估及应用建议
最新发布
05-19
文章介绍了几种常见的页面置换算法，包括先进先出算法（FIFO）、最近最少使用算法（LRU）、时钟算法（Clock）和最不经常使用算法（LFU）。FIFO算法简单但未考虑页面使用频率；LRU算法性能较好但实现复杂；Clock算法...
操作系统模拟实验 vc++
11-05
操作系统模拟实验 vc++，很经典的。。。。。。。 操作系统模拟实验 vc++，很经典的。。。。。。。
计算机操作系统实验 模拟文件管理系统源代码
01-30
JAVA 仿造Linux 的文件管理系统，模拟实现操作系统中的文件管理，包括文件储存模块模拟，目录创建、删除、修改，文件创建、删除、修改；操作命令和Linux中的命令相同
模拟分页式虚拟存储管理（操作系统）
07-30
模拟分页式虚拟存储管理（操作系统）
虚拟页式存储管理
weixin_43975684的博客
12-14 2866
计算机并不解决问题，它们只是执行解决方案。 －－Laurent Gasser
页式存储器&虚拟存储系统
xingyuankongjing的博客
10-15 529
虚（实）地址 地址变换过程 引入快表（TLB）——使用SRAM，是一种相联存储器 虚拟存储 页式虚拟存储 段式虚拟存储器 段页式虚拟存储
linux 页式虚拟存储 存储管理,linux虚拟存储管理(管理方式)
weixin_39912580的博客
05-12 634
虚拟存储器1.引入缓冲可以(C)。A．改善用户编程环境 B．提高CPU的处理速度C．提高CPU与设备之间的并行程度D．降低计算机的硬件成本进程的内存分配与释放内存动态分区管理中，最佳适应算法的空白区是按大小递增顺序排列的。段页式管理段页式管理中，地址转换表是每个进程一张段表，每个段一张页表。分页式管理1.下列( C )存储管理方式能使内存碎片尽可能少，避免内存的整理。A.固定分区 B.可变分区 C...
操作系统课程实验1-进程调度模拟实验
qq_46396470的博客
05-23 828
本实验模拟在单处理机环境下的处理机调度，帮助理解进程调度的概念，深入了解进程控制块的功能，以及进程的创建、撤销和进程各个状态间的转换过程。
【操作系统实验一模拟程序运行】
weixin_74839061的博客
11-20 1071
cout
操作系统实训 实验一 实验环境搭建
m0_58258716的博客
10-06 3711
2. 在“虚拟机设置”的“硬件”中，选中“CD/DVD(IDE)”，在右侧窗口，选中“使用ISO镜像文件”，单击“浏览”，找到Centos 7 镜像文件所在的位置，单击“确定”。完成设置后，单击“下一步”。9. 在“网络和主机名”界面，设置Centos 7 虚拟机的“主机名”，可设置为“姓名缩写-班级学号”，完成设置后，单击“应用”，单击“配置”。5. 在“选择客户机操作系统”界面，“客户机操作系统”选择“Linux”，“版本”选择“Centos 7 64位”，然后单击“下一步”。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值