操作系统实验：页面置换算法——FIFO、LRU 代码实现

已于 2022-11-09 21:40:07 修改
阅读量5.8k 收藏 89
点赞数 11
文章标签： 算法 linux 数据结构
于 2022-11-02 22:24:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhashuang/article/details/127659697
版权

FIFO(First-In-First-Out)

        最简单的页面置换算法是FIFO。在分配内存页面数（AP）小于进程页面数（PP）时，最先运行的AP个页面放入内存；当内存分配页面被占满时，如果又需要处理新的页面，则将原来放的内存中的AP个页中最先进入的调出（FIFO），再将新页面放入；所使用的内存页面构成一个队列。

实验要求：

（1）初始化。设置两个数组page[ap]和pagecontrol[pp]分别表示进程页面数和内存分配的页面数，并产生一个随机数序列main[total_instruction]（这个序列由page[ap]的下标随机构成）表示待处理的进程页面顺序，diseffect置0。

（2）看main[]中是否有下一个元素，若有，就由main[]中获取该页面下标，并转（3），如果没有则转（7）。

（3）如果该页已在内存中，就转（2），否则转（4），同时未命中的diseffect加1。

（4）观察pagecontrol是否占满，如果占满则须将使用队列（在第（6）步中建立的）中最先进入的（就是队列的第一个单元）pagecontrol单元“清干净”，同时将page[]单元置为“不在内存中”。

（5） 将该page[]与pagecontrol[]建立对应关系（可以改变pagecontrol[]的标志位，也可以采用指针链接，总之至少要使对应的pagecontrol单元包含两个信息：一是它被使用了，二是哪个page[]单元使用的。page[]单元也包含两个信息：对应的pagecontrol单元号和本page[]单元已在内存中）。

 (6) 将用到的pagecontrol置入使用队列（这里的队列是一种FIFO的数据结构），返回（2）。

(7) 显示计算1-diseffect / total_instruction*100%，完成。

程序框图： 

 

代码实现： 

#include<stdio.h>
#include<stdlib.h> 
#include<time.h>

#define ProcessPageNum 10       //进程页面数
#define MemPageNum 5            //内存页面数
#define totalInstruction 100    //引用次数
int diseffect = 0;              //缺页错误数
/*定义进程页面结构体*/
struct pageNode{
    int pageID;             //进程页面ID
    int flag;               //1表示页面在内存中，0表示不在
    int pagecontrolIndex;   //所在内存页面ID 不在内存中时值为-1
};
/*定义内存页面结点*/
struct pagecontrolNode{
    int pagecontrolID;      //内存页面ID
    int flag;               //1表示被占用，0表示空闲
    int pageIndex;          //所加载进程页面ID
    struct pagecontrolNode *next;
};
/*定义FIFO队列*/
struct pagecontrolQueue{
    struct pagecontrolNode *front;
    struct pagecontrolNode *rear;
};
/*返回队首结点*/
struct pagecontrolNode* getFront(struct pagecontrolQueue *queue){
    return queue->front;
}
/*入队*/
void inQueue(struct pagecontrolQueue *queue,struct pagecontrolNode *p){
    if(queue->front == NULL){
        queue->front = p;
        queue->rear = p;
    }else{
        queue->rear->next = p;
        queue->rear = p;
        queue->rear->next = NULL;
    }
}
/*出队*/
void outQueue(struct pagecontrolQueue *queue){
    if(queue->front == NULL) exit(-1);
    else{
        queue->front = queue->front->next;
        if(queue->front == NULL) queue->rear = NULL;
    }
}
/*判断内存页面是否被占满 1为满*/
int isFull(struct pagecontrolNode *pagecontrol[MemPageNum]){
    int i = 0;
    for (i;i < MemPageNum;i++){
        if(pagecontrol[i]->flag == 0) return 0;
    }
    return 1;
}
/*初始化page数组*/
void initPage(struct pageNode *page[ProcessPageNum]){
    int i = 0;
    for(i;i < ProcessPageNum;i++){
        page[i] = (struct pageNode*)malloc(sizeof(struct pageNode)); 
        page[i]->flag = 0;
        page[i]->pageID = i;
        page[i]->pagecontrolIndex = -1;
    }
}
/*初始化pagecontrol数组*/
void initPagecontrol(struct pagecontrolNode *pagecontrol[MemPageNum]){
    int i = 0;
    for(i;i < MemPageNum;i++){
        pagecontrol[i] = (struct pagecontrolNode*)malloc(sizeof(struct pagecontrolNode)); 
        pagecontrol[i]->pagecontrolID = i;
        pagecontrol[i]->flag = 0;
        pagecontrol[i]->pageIndex = -1;
        pagecontrol[i]->next = NULL;
    }
}

int main(){
    struct pageNode *page[ProcessPageNum];
    struct pagecontrolNode *pagecontrol[MemPageNum];
    initPage(page);
    initPagecontrol(pagecontrol);
    /*初始化队列*/
    struct pagecontrolQueue *queue;
    queue = (struct pagecontrolQueue*)malloc(sizeof(struct pagecontrolQueue));
    queue->front = NULL;
    queue->rear = NULL; 
    /*构造随机序列buffer*/
    int buffer[totalInstruction];
    int i = 0;
    srand((unsigned)time(NULL));
    for(i;i < totalInstruction;i++){
        buffer[i] = rand() % ProcessPageNum;
    }
    int j = 0;
    int index = 0;  //当前内存页面下标
    for(j;j < totalInstruction;j++){
        if(page[buffer[j]]->flag == 0){ //若当前页面不在内存中
            diseffect++;                //缺页错误数加1
            page[buffer[j]]->flag = 1;
            if(isFull(pagecontrol)){    //若内存已满，则需要页面置换
                page[queue->front->pageIndex]->flag = 0;    //队首页面被换出
                page[queue->front->pageIndex]->pagecontrolIndex = -1;
                queue->front->pageIndex = page[buffer[j]]->pageID; //存入当前页面
                struct pagecontrolNode *temp;
                temp = getFront(queue);
                outQueue(queue);        //队首页面出队列
                inQueue(queue,temp);    //修改后再加入队列
            }else{                      //如果内存未满，则按照先后顺序存入
                pagecontrol[index]->flag = 1;
                pagecontrol[index]->pageIndex = page[buffer[j]]->pageID;
                page[buffer[j]]->pagecontrolIndex = pagecontrol[index]->pagecontrolID;
                inQueue(queue, pagecontrol[index]);
                index++;
            }
        }
    }
    double rightRate = (1.0 - ((double)diseffect / (double)totalInstruction))*100;
    printf("错误次数%d\n",diseffect);
    printf("正确率%.2f%%\n",rightRate);
}

LRU(Least-Recent-Used algorithm)

        计数器实现法：在最简单的情况下，为每个页表条目关联一个使用时间域，并为CPU添加一个逻辑时钟或计数器。每次内存引用都会递增时钟；且每当进行页面引用时，时钟寄存器的内容会复制到相应页面的页表条目的使用时间域。这样我们总是找到每个页面最后被引用的时间，便可以置换拥有最小使用时间的页面。

实验要求：

(1) 初始化。设置两个数组page[ap]和pagecontrol[pp]分别表示进程页面数和内存分配的页面数，并产生一个随机数序列main[total_instruction]（这个序列由page[ap]的下标随机构成）表示待处理的进程页面顺序，diseffect置0。

(2) 看序列main[]中是否有下一个元素，如果有，就由main[]中获取该页面下标，并转（3），如果没有则转（6）。

(3) 如果该page[]单元在内存中便改变页面属性，使它保留“最近使用”的信息，转（2），否则转（4），同时diseffect加1。

(4) 看是否有空闲页面，如果有，就返回页面指针，并转到（5），否则，在内存页面d将其“清干净”，并返回该页面指针。

(5) 在需处理的page[]与（4）中得到的pagecontrol[]之间建立联系，同时让对应的page[]单元保存“最新使用”的信息，转（2）。

         (6) 如果序列处理完成，就输出计算1-diseffect / total_instruction*100%的结果

程序框图： 

 

 代码实现：

#include<stdio.h>
#include<stdlib.h> 
#include<time.h>
/*实现方法与FIFO算法大同小异，无需定义队列，而是用计数器实现选择牺牲帧*/
#define ProcessPageNum 10       //进程页面数
#define MemPageNum 5            //内存页面数
#define totalInstruction 100    //引用次数
int diseffect = 0;              //缺页错误数
/*定义进程页面结构体*/
struct pageNode{
    int pageID;             //进程页面ID
    int flag;               //1表示页面在内存中，0表示不在
    int pagecontrolIndex;   //所在内存页面ID 不在内存中时值为-1
    int useTime;            //最后被引用时间
};
/*定义内存页面结点*/
struct pagecontrolNode{
    int pagecontrolID;      //内存页面ID
    int flag;               //1表示被占用，0表示空闲
    int pageIndex;          //所加载进程页面ID
};
/*初始化page数组*/
void initPage(struct pageNode *page[ProcessPageNum]){
    int i = 0;
    for(i;i < ProcessPageNum;i++){
        page[i] = (struct pageNode*)malloc(sizeof(struct pageNode)); 
        page[i]->flag = 0;
        page[i]->pageID = i;
        page[i]->pagecontrolIndex = -1;
        page[i]->useTime = 0;
    }
}
/*初始化pagecontrol数组*/
void initPagecontrol(struct pagecontrolNode *pagecontrol[MemPageNum]){
    int i = 0;
    for(i;i < MemPageNum;i++){
        pagecontrol[i] = (struct pagecontrolNode*)malloc(sizeof(struct pagecontrolNode)); 
        pagecontrol[i]->pagecontrolID = i;
        pagecontrol[i]->flag = 0;
        pagecontrol[i]->pageIndex = -1;
    }
}
/*判断内存页面是否被占满 1为满*/
int isFull(struct pagecontrolNode *pagecontrol[MemPageNum]){
    int i = 0;
    for (i;i < MemPageNum;i++){
        if(pagecontrol[i]->flag == 0) return 0;
    }
    return 1;
}
/*找到内存中页面最后引用时间最小的page结点并返回*/
struct pageNode* findMinUseTime(struct pageNode *page[ProcessPageNum]){
    struct pageNode *temp;
    temp = (struct pageNode*)malloc(sizeof(struct pageNode)); 
    temp->useTime = totalInstruction;
    int i = 0;
    for(i;i < ProcessPageNum;i++){
        if(page[i]->useTime < temp->useTime && page[i]->flag == 1){
            temp = page[i];
        }
    }
    return temp;
}
int main(){
    struct pageNode *page[ProcessPageNum];
    struct pagecontrolNode *pagecontrol[MemPageNum];
    initPage(page);
    initPagecontrol(pagecontrol);
    /*构造随机序列buffer*/
    int buffer[totalInstruction];
    int i = 0;
    srand((unsigned)time(NULL));
    for(i;i < totalInstruction;i++){
        buffer[i] = rand() % ProcessPageNum;
    }
    int j = 0;
    int timer = 0;  //设置计数器
    int index = 0;  //当前内存页面下标
    for(j;j < totalInstruction;j++){
        timer++;    //计数器递增
        page[buffer[j]]->useTime = timer;
        if(page[buffer[j]]->flag == 0){ //若当前页面不在内存中
            diseffect++;                //缺页错误数加1
            page[buffer[j]]->flag = 1;
            if(isFull(pagecontrol)){    //若内存已满
                struct pageNode *temp = findMinUseTime(page);   //找到将被置换的页面
                temp->flag = 0;
                temp->useTime = 0;
                pagecontrol[temp->pagecontrolIndex]->pageIndex = page[buffer[j]]->pageID;   //修改pagecontrol数组
                page[buffer[j]]->pagecontrolIndex = pagecontrol[temp->pagecontrolIndex]->pagecontrolID; //修改page数组
                temp->pagecontrolIndex = -1;
            }else{                      //若内存未满，则按顺序存入
                pagecontrol[index]->flag = 1;
                pagecontrol[index]->pageIndex = page[buffer[j]]->pageID;
                page[buffer[j]]->pagecontrolIndex = pagecontrol[index]->pagecontrolID;
                index++;
            }
        }
    }
    double rightRate = (1.0 - ((double)diseffect / (double)totalInstruction))*100;
    printf("错误次数%d\n",diseffect);
    printf("正确率%.2f%%\n",rightRate);
}

参考资料：

《操作系统概念（第九版）》

_zss_
关注
页面置换算法代码
08-19
操作系统实验中的页面置换算法源代码，用c++编写
操作系统中页面置换算法的代码实现
04-20
实验目的： 1．熟悉FIFO，OPT和LRU算法 2．比较三种算法的性能优劣 实验内容： 写出FIFO，OPT和LRU算法的程序代码，并比较它们的算法性能。
操作系统实验(四)——页面置换算法(附C语言代码)
qq_56699753的博客
08-05 1607
操作系统实验代码 使用Dev-C++运行
页面置换算法（C语言版）FIFO和LRU代码
最新发布
m0_70070803的博客
12-20 1635
void LRU(PageTable pagetable[6],int data[10],int block[3]){//最近最少使用页面置换算法。//首先将数据传输到相应的内存块;
操作系统：实验四 页面置换算法
顾道长生的科研笔记
11-15 3495
一. 实验目的： 1、通过编写和调试存储管理的模拟程序以加深对存储管理方案的理解。熟悉虚存管理的各种页面淘汰算法 2、通过编写和调试地址转换过程的模拟程序以加强对地址转换过程的了解。 二 . 实验指导： 设计一个请求页式存储管理方案。并编写模拟程序实现之。流程图见下图。 产生一个需要访问的指令地址流。它是一系列需要访问的指令的地址。为不失一般性，你可以适当地（用人工指定地方法或用随机数产生器）...
操作系统 | 实验五 页面置换算法
热门推荐
猫天意的博客
05-31 1万+
（1）加深对页面置换算法的理解。 （2）掌握几种页面置换算法的实现方法。 （3）通过实验比较各种置换算法的优劣。
操作系统实验：页面置换算法分析——FIFO与LRU
"本实验是武夷学院针对操作系统课程的一次综合性实验，主要涉及页式存储管理中的页面置换算法，包括FIFO（先进先出）、LRU（最近最久未使用）以及OPT（最佳）三种算法。实验目的是让学生理解虚拟存储技术的特点，...
东南大学操作系统实验——实现LRU算法及其近似算法
06-30
在本实验中，学生将深入理解操作系统的内存管理机制，特别是LRU（Least Recently Used，最近最少使用）页面置换算法。LRU算法是一种常见的虚拟内存管理策略，它根据页面的使用历史来决定替换哪个页面。当内存中的...
操作系统课程设计——页面置换算法模拟实现
02-24
通过对请求页式存储管理中页面置换算法的模拟设计，掌握请求页式存储管理页面置换算法，并进一步理解虚拟存储技术的原理及特点。 设计内容：设计一个虚拟存储及内存工作区，使用先进先出算法（FIFO），理想型淘汰...
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
根据设计要求实现对页面置换算法的模拟以及 进程状态转换的模拟。 1.根据自己输入 物理块数量,访问页面总数,要访问的页面号,  2.然后选择所需的置换算法 OPT,LRU 二选一. 计算过程,并得出 缺页次数,缺页率,...
"操作系统实验报告：页面置换算法模拟——OPT、FIFO和LRU算法
本次操作系统实验报告主要介绍了页面置换算法的模拟，其中包括OPT、FIFO和LRU算法。这三种算法分别代表了最佳置换算法、先进先出算法和最近最久未使用算法。 在本次实验中，我们首先定义了一些基本的数据结构，包括...
操作系统试验(页面置换算法js版)
12-07
操作系统试验(页面置换算法javascript版).用了jquery的简单方法，代码简单易懂。
FIFO页面置换算法
06-06
FIFO操作系统算法的完整代码，可以直接用。
页面置换算法（OPT、FIFO、LRU）实现--C++版本
09-15
该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法，包括先进先出（FIFO）、最佳置换算法（OPT）、最久最近未使用算法（LRU）。 具体实现功能有： 1、建立相应的数据结构 2、在屏幕上显示页面的状况 3、时间的流逝可用下面几种方法模拟：按键盘，每按一次可认为过一个时间单位; 4、将一批页的置换情况存入磁盘文件，以后可以读出并重放; 5、计算页面的缺页次数、缺页后的页面置换次数 6、支持算法：FIFO、LRU、最佳置换算法。
页面置换算法LRU（模拟页面管理）
11-01
页面置换算法LRU（模拟页面管理）  用高级语言编写一个页面置换算法LRU的模拟程序。  设置恰当的数据结构，有效存储数据。   动态输入存储区块数、作业调度序列。  输出分配结果、置换过程以及其它相关的信息。  界面友好，提示清晰。  容错性好。
操作系统实验三：三种页面置换算法（FIFO/OPT/RUL)
weixin_63395068的博客
11-16 2953
基本知识点转载：https://blog.csdn.net/qq_30353463/article/details/124613726 以下为方便阅读直接进行知识点搬运： 最优算法 理论层面上的算法。 它是在整个事情发生之后，也就是我们已经知道访问的页面序列是怎样的，根据页面序列分析算出什么时间点淘汰什么页面能够取得最高的效率性能。 根据不同的实际场景，最优算法肯定能得出不同的解决方案，没有普遍的规律。 在实际访问中往往没办法了解整体的页面序列，比如涉及到分支，那就会根据条件进行判断，我们
操作系统实验：页面置换算法
m0_45294651的博客
07-14 1097
实验项目名称： 页面置换算法 一、实验目的 1、学习最佳置换optimal policy和最近最久未用算法LRU。 2、完成思考、设计与练习。 二、实验内容 输入： 内存物理块frame个数(3个或4个) 页面访问序列 输出： 页面置换过程 缺页次数 三、实验原理 OPT：其所选择的被淘汰页面，将是以后永不使用的，或许是在最长(未来)时间内，不再被访问的页面。采用最佳置换算法，通常可保证获得最低的缺页率。但由于人们目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因
操作系统实验四 页面置换算法（fifo 算法代码------页面置换代码集合）
GoodLuckAC的博客
06-14 6771
实验四 存储器管理 一、     实验目的 1.       理解连续存储管理方式的原理和分类。  2.       理解离散存储管理方式的原理和分类。 3.       理解虚拟存储器的原理和分类。 4.       掌握动态分区分配的常用算法。 5.       掌握页式虚拟管理中常用页面置换算法。  二、     实验设备 1.     安装windows或者linux操作系
页面置换算法的C++代码实现
12-18
页面置换算法的C++实现，比较各种算法的优缺点
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值