虚拟存储管理：C语言实现请求页面置换算法,包括FIFO、LRU (stack and matrix implementation)、Secondchance

最新推荐文章于 2024-01-20 20:34:41 发布
最新推荐文章于 2024-01-20 20:34:41 发布
阅读量3.4k 收藏 39
点赞数 6
分类专栏： 操作系统 文章标签： c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yoyo_hu/article/details/123478879
版权

1 实验内容：虚拟存储管理。

编写一个 C程序模拟实现请求页面置换算法,包括FIFO、LRU (stack and matrix implementation)、Secondchance，并设计输入用例验证结果。

2 程序所涉及到的算法介绍以及相关实现函数

在计算机操作系统使用分页的虚拟内存管理，页面置换算法决定哪些内存页页出，有时也被称为换出，或写入到磁盘上，当一个页面被分配的内存需求。当请求的页面不在内存中（页面错误）并且空闲页面无法用于满足分配时，就会发生页面替换，要么是因为没有页面，要么是因为空闲页面的数量低于某个阈值。

2.1 先进先出(FIFO)算法

2.1.1 介绍：
  1. 将页面内存视为循环缓冲区。
  2. 当缓冲区满时，替换最旧的页面,即先进先出。
2.1.2 程序中该算法的实现思路如下：

使用isNeedReplace来标记是否需要进行置换,使用pointer来指向下一个页表号应该存放的地方，
对于想要访问的每一个页面，首先先判断是否需要进行置换，通过依次遍历内存数组，

  1. 如果该内存数组中存在页面则标记isNeedReplace为0，表示不需要进行置换，并打印该页面命中并跳出循环
  2. 如果该内存数组中不存在该页面且内存数组中存在空位，则将页表插入到空位中，同样标记isNeedReplace为0，表示不需要进行置换，接着打印该页面缺失并跳出循环。

接着通过判断isNeedReplace是否为1来判断是否需要进行页面的替换，为1则表示该页表没有存在于内存中且内存中没有空位使其直接插入，页面替代队列的头结点，即pointer所指向的点，pointer++,因为程序使用的是循环队列，因此当pointer到达最后一个队列位置之后时，需要重新设置其指向队列的第一个位置，接着打印该页面缺失。

2.1.3 相关代码以及详细注释如下：
/*先进先出置换算法FIFO*/
void replaceAlgFIFO(){
    int pointer = 0;//指向下一个页表号应该存放的地方
    int isNeedReplace = 1;//是否需要进行页面置换，如果内存中没有该页表号且内存已满，则需要，为1
    for (int i = 0; i < pageNum; i ++) {
    isNeedReplace = 1;
    //判断是否需要置换，内存已满且该页面不在内存中，则需要
        for (int j = 0; j < phyBlockNum; j ++) {
            if (memList[j] == pageToVisit[i]) {
                isNeedReplace = 0;//该页面在内存中,不需要进行页面置换
                printf("%d hit\n",pageToVisit[i]);//命中
                break;
               }
            if (memList[j] == -1) {//页面不在内存中且内存未满
                memList[j] = pageToVisit[i];
                isNeedReplace = 0;//内存未满,不需要进行页面置换
                printf("%d miss\n",pageToVisit[i]);//缺失
                printList();
                break;
            }
        }
        if (isNeedReplace) {//需要进行页面置换
            //如果pointer指向最后一个之后的区域，则归零
            if (pointer > phyBlockNum-1) pointer = 0;

            memList[pointer] = pageToVisit[i];//按照FIFO的原则替代pointer所指的节点
            pointer ++;

            printf("%d miss\n",pageToVisit[i]);//缺失
            printList();
        }
    }
}

2.2 LRU(stack实现）

2.2.1 介绍：
  1. 如果要访问的页面已在内存中，则直接通过移动将该也面放在循环队列或者栈的最后，表示此时最难被替换出去。
  2. 当页面出现替换时，则将队列或者栈顶的头元素弹出，其后的元素依次往前移动，将需要插入的页面插入到数组的最后。
2.2.2 程序中该算法的实现思路如下：

使用isNeedReplace来标记是否需要进行置换,使用count来表示当前在内存中的页面数量，
对于想要访问的每一个页面，首先先判断是否需要进行置换，通过依次遍历内存数组，

  1. 如果该内存数组中存在该页面，则将其后的元素往前推一个单位，然后将该页面放置在栈底（队列的底部），并标记isNeedReplace为0，表示不需要进行置换，最后打印该页面命中并跳出循环
  2. 如果该内存数组中不存在该页面且内存数组中存在空位，则将页表插入到空位中，同样标记isNeedReplace为0，表示不需要进行置换，接着将count+1，表示当前在内存中的页面数量增加一个，最后打印该页面缺失并跳出循环。

接着通过判断isNeedReplace是否为1来判断是否需要进行页面的替换，为1则表示该页表没有存在于内存中且内存中没有空位使其直接插入，将数组整体往前移一位，过程中队列队头（栈头）弹出，在队列的结尾加上该页面作为新节点，接着打印该页面缺失。

2.2.3 相关代码以及详细注释如下：
/*最近最久未使用置换算法LRU-stack实现*/
void replaceAlgStackLRU(){

   int isNeedReplace = 1;//是否需要进行页面置换，如果内存中没有该页表号且内存已满，则需要，为1
   int count = 0;//在内存中的页面数量
   for (int i = 0; i < pageNum; i ++) {
       isNeedReplace = 1;
       //判断是否需要置换，内存已满且该页面不在内存中，则需要
       for (int j = 0; j < phyBlockNum; j ++) {
           if (memList[j] == pageToVisit[i]) {
               //已经存在于内存中，把它换到队列尾部
               int temp = memList[j];
               for (int k = j; k < count-1; k ++) {
                   memList[k] = memList[k+1];
               }
               memList[count-1] = temp;

               isNeedReplace = 0;//该页面在内存中,不需要进行页面置换
               printf("%d hit\n",pageToVisit[i]);//命中
               printList();
               break;
           }

           if (memList[j] == -1) {//页面不在内存中且内存未满
               memList[j] = pageToVisit[i];
               isNeedReplace = 0;//内存未满,不需要进行页面置换
               count ++;
               printf("%d miss\n",pageToVisit[i]);
               printList();
               break;
           }
       }

       if (isNeedReplace) {//需要进行页面置换
           //将数组整体往前移一位
           for (int k = 0; k < phyBlockNum; k ++) {
               memList[k] = memList[k+1];
           }
           //将当前页面加到队尾
           memList[phyBlockNum-1] = pageToVisit[i];
           printf("%d miss\n",pageToVisit[i]);
           printList();
       }
   }
}

2.3 LRU(matrix）

2.3.1 介绍：

用矩阵的方法来实现LRU算法的思想是使用矩阵来记录页面使用的频率和时间。设矩阵是n×n维的,n是相关程序当前驻内存的页面数。矩阵的初值为0,每次访问一个页面,例如第i个虛拟页被访问时,可对矩阵进行如下操作：

  1. 将第i行的值全部置1;
  2. 将第i列的值全部置0;

在每次需要更换页面时,选择矩阵里对应行值最小的页面淘汰
,该页面及时最近最少使用的页面。原理如下：

  • 当一个页面被访问时,该页面所对应的行值将被置1，这样就保证了该页面对应的行值为最大之一,随后将该页面的对应列值置0,以保证该页面对应的行值为唯一最大。每次访问都将某一列置0,长时间没有被访问的页面,所对应的行元素里面被置0的列个数就越多,即它对应的行值就越小。因此,用矩阵的方法可以实现接近理想算法的页面置换。
2.3.2 程序中该算法的实现思路如下：

使用Matrix来记录页面使用的频率和时间，其功能在上述介绍中已经详细介绍，先对其中的全部元素初始化为0，使用isNeedReplace来标记是否需要进行置换,使用count来表示当前在内存中的页面数量，对于想要访问的每一个页面，首先该页面所对应的行值将被置1，这样就保证了该页面对应的行值为最大之一,随后将该页面的对应列值置0,以保证该页面对应的行值为唯一最大。
然后再判断是否需要进行置换，通过依次遍历内存数组，

  1. 如果该内存数组中存在该页面，则标记isNeedReplace为0，表示不需要进行置换，然后打印该页面命中并跳出循环
  2. 如果该内存数组中不存在该页面且内存数组中存在空位，则将页表插入到空位中，同样标记isNeedReplace为0，表示不需要进行置换，接着将count+1，表示当前在内存中的页面数量增加一个，最后打印该页面缺失并跳出循环。

接着通过判断isNeedReplace是否为1来判断是否需要进行页面的替换，为1则表示该页表没有存在于内存中且内存中没有空位使其直接插入，遍历矩阵中在内存快中存在的页面的行，寻找行的零数最多的即为最久未访问的页面所在的内存下标，将下标对应的队列中的节点替换成该页面，接着打印该页面缺失。

2.3.3 相关代码以及详细注释如下：
//最近最久未使用置换算法LRU-矩阵实现
void replaceAlgMatrixLRU(){

    //矩阵，用来记录节点最近最久未被使用的程度大小
    int Matrix[pageNum][pageNum];
    //初始化矩阵
    for(int i=0;i<pageNum;i++){
        for(int j=0;j<pageNum;j++)
            Matrix[i][j]=0;
    }
    int isNeedReplace = 1;//是否需要进行页面置换，如果内存中没有该页表号且内存已满，则需要，为1

    int count = 0;//在内存中的页面数量
    for (int i = 0; i < pageNum; i ++) {
        isNeedReplace = 1;
        
        //pageToVisit[i]行置1，pageToVisit[i]列置0
        for (int p = 0; p < pageNum; p ++) {
            Matrix[pageToVisit[i]][p]=1;
        }
        for (int p = 0; p < pageNum; p ++) {
            Matrix[p][pageToVisit[i]]=0;
        }

        //判断是否需要置换，内存已满且该页面不在内存中，则需要
        for (int j = 0; j < phyBlockNum; j ++) {
            if (memList[j] == pageToVisit[i]) {
                isNeedReplace = 0;//该页面在内存中,不需要进行页面置换
                printf("%d hit\n",pageToVisit[i]);//命中
                break;
            }
            if (memList[j] == -1) {//页面不在内存中且内存未满
                memList[j] = pageToVisit[i];
                count ++;//在内存中的页面数量+1
                isNeedReplace = 0;//内存未满,不需要进行页面置换
                
                printf("%d miss\n",pageToVisit[i]);//缺失
                printList();
                break;
            }
        }

        if (isNeedReplace) {//需要进行页面置换
            //遍历矩阵中在内存快中存在的页面的行，寻找行的零数最多的即为最久未访问的页面所在的内存下标
            int max = 0;//记录内存块中的页面对应到矩阵中的行的零数总和最大的节点
            int sum[phyBlockNum];//记录内存块中的页面对应到矩阵中的行的零数总和
            //找出max节点，即最近最久未使用的页面
            for (int k = 0; k < phyBlockNum; k ++) {
                sum[k]=0;
                for(int p=0;p<pageNum;p++){
                    if(Matrix[memList[k]][p]==0)sum[k]+=1;
                }
                if(sum[k]>sum[max]){
                    max=k;
                }
            }

            memList[max] = pageToVisit[i];//替换掉最近最久未使用的页面

            printf("%d miss\n",pageToVisit[i]);//缺失
            printList();
            
        }
    }
}

2.4 二次机会算法Secondchance

2.4.1 介绍：

该算法仍然使用标准的FIFO队列。
每个帧(frame)有一个second chance位，也叫做引用位。

  • 当一个frame被引用到，它的second chance位设置为1。这表示该frame后面还有可能会被引用到，所以下次置换先跳过这个frame，也就是再给它一次机会留在内存中。这样可以减少frame置换，提高页面操作效率。
  • 当一个新的页面被读到内存中时，它的second chance被设置为0。（页面首先加载到框架中会设置为1）
  • 当需要替换内存中的一个页面时，使用轮询的方式来查找可以被替换的页面：
    如果页面的second chance是1，那么置为0，继续查找；
    如果页面的second chance是0，那么将这个页面置换出去。

如果一个页面被频繁使用以保持其引用
位设置，它永远不会被替换。

2.4.2 程序中该算法的实现思路如下：

使用secondChance数组来记录内存中的页表是否有不被替换出去的机会，其功能在上述介绍中已经详细介绍，先对其中的全部元素初始化为0，使用isNeedReplace来标记是否需要进行置换,使用pointer来指向下一个页表号应该存放的地方，使用count来表示当前在内存中的页面数量。
对于想要访问的每一个页面，首先判断是否需要进行置换，通过依次遍历内存数组，

  1. 如果该内存数组中存在该页面，则标记isNeedReplace为0，表示不需要进行置换，并设置该页表的secondChance为1，表示该页表在下一次将要被替换时，有不被替换出去的机会，然后打印该页面命中并跳出循环
  2. 如果该内存数组中不存在该页面且内存数组中存在空位，则将页表插入到空位中，同样标记isNeedReplace为0，表示不需要进行置换，接着将count+1，表示当前在内存中的页面数量增加一个，最后打印该页面缺失并跳出循环。

接着通过判断isNeedReplace是否为1来判断是否需要进行页面的替换，为1则表示该页表没有存在于内存中且内存中没有空位使其直接插入，先判断当前要替换的页面（pointer指向的页面）是否有不被替换出去的机会，即其对应的secondChange的值是否为一，如果为1则修改其为0并且将point加一，循环这个过程知道找到secondChange不为1的节点，将该节点替换成访问的页面，接着打印该页面缺失。

2.4.3 相关代码以及详细注释如下：
/*二次机会算法SCR*/
void replaceAlgSecondchance(){
    //记录内存中的页表是否有不被替换出去的机会
    int secondChance[phyBlockNum];
    //初始化
    for(int i=0;i<phyBlockNum;i++){
        secondChance[i]=0;
    }

    int isNeedReplace = 0;//是否需要进行页面置换，如果内存中没有该页表号且内存已满，则需要，为1
    int pointer=0;//指向下一个页表号应该存放的地方
    int count = 0;//在内存中的页面数量
    for (int i = 0; i < pageNum; i ++) {
        isNeedReplace = 1;
        //判断是否需要置换，内存已满且该页面不在内存中，则需要
        for (int j = 0; j < phyBlockNum; j ++) {
            if (memList[j] == pageToVisit[i]) {
                isNeedReplace = 0;//该页面在内存中,不需要进行页面置换
                //设置被访问过的内存中的页表有不被替换出去的机会
                secondChance[j] = 1;
                
                printf("%d hit\n",pageToVisit[i]);
                break;
            }
            if (memList[j] == -1) {//页面不在内存中且内存未满
                memList[j] = pageToVisit[i];
                count ++;
				secondChance[j] = 1;//首先被加入的位
                isNeedReplace = 0;//内存未满,不需要进行页面置换
                
                printf("%d miss\n",pageToVisit[i]);
                printList();
                break;
            }
        }
        if (isNeedReplace) {//需要进行页面置换
        //如果point指向的节点在这一轮有不被替换出去的机会，则point++，判断下一个是否需要被替换出去
            while(secondChance[pointer]==1){
                secondChance[pointer]=0;
                pointer++;
                if (pointer > phyBlockNum-1) {
                    pointer = 0;
                }
            }

            if (pointer > phyBlockNum-1) {
                pointer = 0;
            }
            memList[pointer] = pageToVisit[i];
            pointer ++;
            
            printf("%d miss\n",pageToVisit[i]);
            printList();
        }
    }
}

3 主函数介绍：

程序一开始要求输入置换算法类型strategy，物理块数量phyBlockNum,准备访问的页面总数pageNum,然后输入pageNum数量的待访问的页面号，再根据strategy选择进入置换算法函数（在上述有提到）进行依次的置换。

4 运行结果分析。

4.1 测试FIFO算法

按照要求选择FIFO算法，使用课件上的样例，选择3块物理块，输入20次要访问页面的次数，并依次输入每一次要访问的页面编号，如下图所示：

1.png

执行结果如下：

2.png 3.png 4.png

和课本中的结果一致，如下，都满足先进先出的原则：

5.png

4.2 测试LRU（stack) 算法

按照要求选择LRU（stack)算法，使用课件上的样例，选择5块物理块，输入13次要访问页面的次数，并依次输入每一次要访问的页面编号，如下图所示：

6.png

执行结果如下：

7.png 8.png 9.png 10.png

和课本中的结果基本一致（程序将下面作为栈的头部或队列的尾部，而课件中将上面作为栈的头部或队列的尾部），都满足LRU的原则：

11.png

4.3 测试LRU（matrix) 算法

按照要求选择LRU（matrix)算法，使用课件上的样例，选择3块物理块，输入12次要访问页面的次数，并依次输入每一次要访问的页面编号，如下图所示：
12.png

执行结果如下：

13.png 14.png

和课本中的结果一致，都满足LRU的原则：

15.png

4.4 测试secondChance算法

按照要求选择LRU（matrix)算法，使用课件上的样例，选择3块物理块，输入12次要访问页面的次数，并依次输入每一次要访问的页面编号，如下图所示：

16.png

执行结果如下：

17.png 18.png

和课本中的结果基本一致，都满足secondChance的原则：

19.png

Jade Jade Cabbage
关注
  • 6
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
操作系统-请求页式存储管理中常用页面置换算法模拟
he5895的博客
11-06 6240
请求页式存储管理中常用页面置换算法模拟 先进先出调度算法（FIFO）、最近最少调度算法（LRU）、最近最不常用调度算法（LFU）、最优调度算法（OPT）。
编写程序实现虚拟存储管理中OPT,FIFO,LRU页面置换算法
05-25
1、任意给出一组页面访问顺序（如页面走向是1、2、5、7、5、7、1、4、3、5、6、4、3、2、1、5、2）。 2、分配给该作业一定的物理块（如3块、4块等）。 3、利用OPT,FIFO,LRU页面置换算法模拟页面置换过程并计算其缺页率。 4、每访问一个页面均需给出内存中的内容（内存中的页面号），若有淘汰还需给出淘汰的页面号。 5、通过给出特殊的页面访问顺序，分配不同的物理块，利用FIFO算法计算其缺页率，进一步理解Belady现象。 6、（附加）实现CLOCK置换算法，修改位可在确定页面号时直接任意给出。
操作系统之页面置换模拟程序设计_FIFO
StuTan
01-11 1438
介绍 假设分给一作业的内存块数为4，每个页面中可存放10条指令。 用C语言设计一个程序，模拟一作业的执行过程。设该作业共有320条指令，即它的地址空间为32页，目前它的所有页面都还未调入内存。在模拟过程中，如果所访问的指令已经在内存，则显示其物理地址，并转下一条指令。如果所访问的指令尚未装入内存，则发生缺页，此时需记录缺页的次数，并将相应页调入内存。如果4个内存块中均已装入该作业的虚页面，...
LRU页面置换算法（C语言实现）
qq_50829760的博客
11-12 1万+
编写并调试一个页面置换模拟程序，采用LRU（最近最久未使用页面置换）算法。已知系统为一进程分配的物理块数，进程运行过程中引用的页面号，编程使用LRU算法输出置换的页号、缺页中断次数及缺页率。
存储管理页面置换算法模拟实现及比较
qq_44808056的博客
07-03 6039
存储管理页面置换算法模拟实现及比较 1、目的 存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。页式管理中页面置换算法，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 2、学年设计内容 （1）通过随机数产生一个指令序列，共320条指令。 指令的地址按下述原则生成： ①一半的指令是顺序执行的； ②四分之一的指令是均匀分布在前地址部分； ③四分之一的指令是均匀分布在前地址部分。 具体的实施办法是： ① 在[0，319]之间选一起点m； ② 顺序执行一条指令，即m+
《操作系统》LRU和FIFO页面置换算法模拟实战
Zeeland的博客
12-04 2232
本文将介绍如何使用LRU和FIFO实现页面置换的模拟（Python实现），并使用缺页率进行算法的评价。
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
针对一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。要求设计主界面以灵活选择某算法，且以下算法都要实现 (1)最佳淘汰算法（OPT） (2)最近最少访问页面算法（LRU） 2.要有体现...
实验--编程实现请求分页存储管理页面Optimal、FIFO、LRU置换算法.docx
07-08
实验报告的主题是编程实现请求分页存储管理中的三种页面置换算法：Optimal、FIFO（先进先出）和LRU（最近最少使用）。这三种算法是操作系统管理内存、处理缺页异常的关键策略。 请求分页存储管理是现代操作系统中...
操作系统 程实现请求分页存储管理页面Optimal、FIFO、LRU置换算法
12-25
目的：（1）通过编写程序实现请求分页存储管理页面Optimal、FIFO、LRU调度算法，使学生掌握虚拟存储管理中有关缺页处理方法等内容，巩固有关虚拟存储管理的教学内容。 （2）了解Windows2000/XP中内存管理机制，掌握...
操作系统 课程设计 页面置换算法FIFO和 LRU
08-14
操作系统中的页面置换算法是解决虚拟内存管理问题的关键技术之一，特别是在有限的物理内存与较大的虚拟内存需求之间进行协调时。本课程设计项目专注于两种常见的页面置换算法：FIFO（先进先出）和LRU（最近最少使用...
JAVA实现FIFO、LRU、OPT页面置换算法，有界面
06-28
在虚拟存储系统中，由于物理内存有限，当程序需要的内存超过物理内存时，操作系统会采用页面置换策略来决定哪些页应该被换出到磁盘上，以便为新的页面腾出空间。本项目涉及到了三种经典的页面置换算法：FIFO（先进先...
虚拟内存页面置换算法（OPT、FIFO、LRU）模拟与实现
weixin_47700137的博客
07-08 1万+
前言 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标：把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 一、常用的页面置换算法 1）最佳置换算法(OPT)：置换时淘汰“未来不再使用的”或“在离当前最远位置上出现的”页面。 2）先进先出置换算法(FIFO)：置换时淘汰最先进入内存的页面，即选择驻留在内存时间最长的页面被置换。 3）最近最久未用置换算法(LRU)：置换时淘汰最近一段时间最久没有使用的页面，即选择上次使
页面置换模拟程序c语言,LRU页面置换算法模拟
weixin_28947723的博客
05-21 1297
三、设计内容与步骤分页存储管理将一个进程的逻辑地址空间分成若干大小相等的片，称为页面或页。一、调页策略1)何时调入页面如果进程的许多页是存放在外存的一个连续区域中，则一次调入若干个相邻的页，会比一次调入一页的效率更高效一些。但如果调入的一批页面中的大多数都未被访问，则又是低效的。可采用一种以预测为基础的预调页策略，将那些预计在不久之后便会被访问的页面，预先调入内存。如果预测较准确，那么，这种策略显...
编写C语言程序，模拟页面置换算法（LRU），使用gcc编译 页面置换算法模拟演示
xxxjr12385的博客
05-15 239
/ 记录每个页是否在内存中。// 记录每个物理帧下一次使用的时间。// 当前应使用的物理帧的下标。
页面置换算法——C/C++实现 [ OTP, FIFO, LRU, LFU + 开源代码 + 详细解析]
热门推荐
Wang_Dou_Dou_的博客
12-24 2万+
关键字：C/C++实现、页面置换算法、最佳置换算法（OPT）、先进先出算法（FIFO）、最近最久未使用算法（LRU）、最不经常使用算法（LFU）、操作系统
页面置换算法（FIFO，LRU，OPT）c模拟
03-21 4528
/* * memory.c * * Created on: Jun 9, 2010 * Author: WangYun */ #include #define PAGE_NUM 20 #define BLOCK 3 void get_page(int page_seq[]) { int i=PAGE_NUM; printf("Please input %d numb
c语言实现FIFO算法和LRU算法,C语言实现FIFO算法与LRU算法
weixin_30668061的博客
05-25 626
在操作系统中，当程序在运行过程中，若其所要访问的页面不再内存中而需要把他们调入内存，但内存已无空闲空间时，为了保证该进程能正常运行，系统必须从内存调出一页程序或数据送磁盘的兑换区中。但哪一个页面调出，须根据一定的算法确定。通常，把选择换出页面的算法称为页面置换算法(Page-ReplacementAlgorithms).置换算法的好坏将直接影响到系统的性能。1) 先进先出(FIFO)页面置换算法该...
C++程序模拟实现页面替换算法——FIFO算法/LRU算法，附带讲解OPT算法
最新发布
weixin_62760649的博客
01-20 1391
C++程序模拟实现页面替换算法——FIFO算法、LRU算法，附带讲解OPT算法
操作系统——页面置换算法c++的实现（fifo和lru）
chenmoupeng的博客
12-07 5195
1、首先建立本次实验的流程图： 1、 然后建立储存相应页面的物理块： struct Physicalblock{ int name; int nomber;//优先级1，2，3 }pb[10]; 其中name表示页面名，nomber在lru算法中起到标记时间的作用 2、 设置一个指针，在fifo算法中指向最老进程 Physicalblock *p=pb;//指向最老进程的指针 3、...
C语言实现操作系统页面置换算法：FIFO与LRU
"操作系统课程设计页面置换算法C语言.doc" 操作系统是计算机系统中的核心软件，负责管理和控制硬件资源，提供给用户和应用程序一个抽象的、高效的工作环境。在这个课程设计中，学生需要深入理解虚拟存储器的工作...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值