操作系统课设——页面置换算法的模拟

最新推荐文章于 2023-06-03 10:55:15 发布
最新推荐文章于 2023-06-03 10:55:15 发布
阅读量2.3k 收藏 11
点赞数 1
分类专栏： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34528825/article/details/53863614
版权

本课设主要实现FIFO算法和LRU算法，虽然实现了功能，但是个人感觉代码可以优化，而且采用的主存块数是3，如果主存块数修改了，那么代码也需要修改，这是我课设不足之处，望大神来指教！

下面是我的代码

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

#define PAGE_NUM 3    //主存块数
#define SERIAL_NUM 12    //访问序列的次数

int serial[SERIAL_NUM] = {6,7,6,5,9,6,8,9,7,6,9,6}; //初始化访问序列
int page_num[PAGE_NUM] = {-1,-1,-1};    //初始化主存块中的序列

void FIFO()
{
    int serial_temp[SERIAL_NUM];
    int page_temp[PAGE_NUM];
    int i,j,k,m,a,c;
    int flag = 0;     //记录有多少
    int count = 0;   //记录缺页次数
    /*赋值给新的数组，防止原数据被改动*/
    for(a = 0; a < SERIAL_NUM; a++)
    {
        serial_temp[a] = serial[a];
    }
    for(a = 0; a < PAGE_NUM; a++)
    {
        page_temp[a] = page_num[a];
    }
    /*算法模拟*/
    for(i = 0; i < SERIAL_NUM; i++)
    {
        flag = 0;
        c = 10;
        //判断主存块有多少空
        for(j = 0; j < PAGE_NUM; j++)
        {
            if(page_temp[j] == -1)
            {
                flag++;
            }
        }
        //三个主存块有空
        while(flag != 0)
        {
            for(k = 0; k <= 3 - flag; k++)
            {
                if(page_temp[k] == serial_temp[i])
                {
                    c = k;
                    break;
                } 
            }
            if(page_temp[k] != serial_temp[i])
            {
                c = 10;
                page_temp[3 - flag] = serial_temp[i];
            }
            break;
        }
        //三个主存块都满
        if(flag == 0)
        {
            for(k = 0; k < PAGE_NUM; k++)
            {
                if(page_temp[k] == serial_temp[i])
                {
                    c = 222;
                }
            }
            if(c != 222)
            {
                page_temp[0] = page_temp[1];
                page_temp[1] = page_temp[2];
                page_temp[2] = serial_temp[i];
            }
        }
        
        for(m = 0; m < PAGE_NUM; m++)   //输出
        {
            printf("    %d",page_temp[m]);
        }
        if(c == 222 || c != 10)
        {
            printf("   不缺页！");
        }
        else
        {
            printf("    缺页！");
            count++;
        }
        printf("     缺页次数为%d次!\n",count);
    }
    
}
void LRU()
{
    int serial_temp[SERIAL_NUM];
    int page_temp[PAGE_NUM];
    int a,k,i,c,j,m,cc;
    int flag;
    int count = 0;
    int count_1 = 0;
    /*赋值给新的数组，防止原数据被改动*/
    for(a = 0; a < SERIAL_NUM; a++)
    {
        serial_temp[a] = serial[a];
    }
    for(a = 0; a < PAGE_NUM; a++)
    {
        page_temp[a] = page_num[a];
    }
    /*算法模拟*/
    for(i = 0; i < SERIAL_NUM; i++)
    {
        flag = 0;
        c = 10;
        cc=10;
        for(j = 0; j < PAGE_NUM; j++)
        {
            if(page_temp[j] == -1)
            {
                flag++;
            }
        }
        //主存块有空位
        while(flag != 0)
        {
            for(k = 0; k < 3 - flag; k++)
            {
                if(page_temp[k] == serial_temp[i])
                {
                    c = k;
                }
            }
            count_1= 3 - flag;
                if(10 == c && count_1 == 0)
                {
                    page_temp[0] = serial_temp[i];
                }
                if(10 == c && count_1 == 2)
                {
                    page_temp[2] = page_temp[1];
                    page_temp[1] = page_temp[0];
                    page_temp[0] = serial_temp[i];
                }
                if(10 == c && count_1 ==1)
                {
                    
                    page_temp[1] = page_temp[0];
                    page_temp[0] = serial_temp[i];
                }
                if(c !=10) 
                {
                    if(count_1 == 1)
                    {
                        page_temp[0] = serial_temp[i];
                    }
                    if(count_1 == 2)
                    {
                        if(1 == c)
                        {
                            page_temp[1] = page_temp[0];
                            page_temp[0] = serial_temp[i];
                        }
                    }

                }
                break;
        }
        //满
        if(0 == flag)
        {
            for(k = 0; k < PAGE_NUM; k++)
            {
                if(page_temp[k] == serial_temp[i])
                {
                    c = 222;
                    cc = k;
                    break;
                }
            }
            //无重复
            if(c != 222)
            {
                page_temp[0] = serial_temp[i];
                page_temp[1] = serial_temp[i - 1];
                page_temp[2] = serial_temp[i - 2];
            }
            //第一个重复
            if(0 == cc)
            {
                page_temp[0] = serial_temp[i];
            }
            //第2个重复
            if(1 == cc)
            {
                page_temp[1] = page_temp[0];
                page_temp[0] = serial_temp[i];
            }
            //第三个重复
            if(2 == cc)
            {
                page_temp[2] = page_temp[1];
                page_temp[1] = page_temp[0];
                page_temp[0] = serial_temp[i];
            }
        }
        
        for(m = 0; m < PAGE_NUM; m++)   //输出
        {
            printf("    %d",page_temp[m]);
        }
        if(c == 222 || c != 10 || 1 == c || 2 == c)
        {
            printf("   不缺页！");
        }
        else
        {
            printf("    缺页！");
            count++;
        }
        printf("缺页次数为%d次！\n",count);
    }
}
void interface() //界面函数
{
    system("clear");
    printf("     \n");
    printf("                  ｜－－－－－－页面置换算法模拟－－－－－－｜\n");
    printf("                  ｜－－－－－－－1.选FIFO算法－－－－－－－｜\n");
    printf("                  ｜－－－－－－－2.选 LRU算法－－－－－－－｜\n");
    printf("                  ｜－－－－－－－3. 退出 －－－－－－－－－｜\n");

    while(1)
    {
        int select;
        printf("请输入你想选择的数字！\n");
        scanf("%d",&select);
        getchar();
        switch(select)
        {
            case 1:
            {
                system("clear");
                printf("FIFO算法结果如下：\n");
                FIFO();
                printf("按回车键返回！\n");
                getchar();
                interface();
                break;
            }
            case 2:
            {
                system("clear");
                printf("LRU算法结果如下：\n");
                LRU();
                printf("按回车键返回！\n");
                getchar();
                interface();
                break;
            }
            case 3:
            {
                system("clear");
                printf("谢谢使用！\n");
                exit(1);
                break;
            }
            default:
            {
                printf("请输入正确的数字！\n");
                printf("即将返回主界面！\n");
                sleep(1);
                sleep(1);    //延时
                interface();
                break;
            } 
        }
    }
}
int main()
{
    interface();
    return 0;
}

啊啊啊啊啊啊啊阿
关注
专栏目录
【操作系统】模拟页面置换算法、缺页率计算（C++源码）
敲代码两年半的练习生博客
01-29 3943
一、课题设计的目的 理解页面置换算法。 二、课程设计的问题描述 2.1 问题描述 先进先出（FIFO）页面置换算法程序设计，通过对FIFO算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。 2.2 问题要求 用C++语言编程实现对FIFO算法的模拟。 三、详细设计 3.1 算法流程图 图3-1 算法流程图 3.2 流程描述 3.3.1 数据初始化 数据初始化，主要包含，访问序列以及内存块大小的读取； 主要实现：通过C语言的标准流式输入。 3.3.2 进入模拟FIF
操作系统课程设计（Clock页面置换算法模拟）
09-09
适合学习过操作系统的学生下载学习，用C++语言和MFC写的，可以很好的模拟操作系统的页面置换算法，图形界面，内附实验源码+报告书。
操作系统课程设计页面置换算法
12-07
这是这几天刚刚和我的小组完成的操作系统页面置换算法，完全是手巧，没有复制网上资源，是一个完整的文档，已经通过了老师的验收，付出了心血，加了很多注释。希望您能够帮助到大家，谢谢。
操作系统课设 常用页面置换算法模拟实验
01-05
操作系统课程设计小题--常用页面置换算法模拟实验
页面置换算法的模拟实现及命中率对比
12-13
一、课程设计目的 通过请求页式管理方式中页面置换算法的模拟设计，了解虚拟存储技术的特点，掌握请 求页式存储管理中的页面置换算法。 容 二、课程设计内容 模拟实现 OPT（最佳置换）、FIFO 和 LRU 算法，并计算缺页率。 示 三、要求及提示 本题目必须单人完成。 1、首先用随机数生成函数产生一个“指令将要访问的地址序列”，然后将地址序列变换 成相应的页地址流（即页访问序列），再计算不同算法下的命中率。 2、通过随机数产生一个地址序列，共产生 400 条。其中 50%的地址访问是顺序执行的， 另外 50%就是非顺序执行。且地址在前半部地址空间和后半部地址空间均匀分布。具体产 生方法如下： 1) 在前半部地址空间，即[0，199]中随机选一数 m，记录到地址流数组中（这是 非顺序执行）； 2) 接着“顺序执行一条指令”，即执行地址为 m+1 的指令，把 m+1 记录下来； 3) 在后半部地址空间，[200，399]中随机选一数 m’，作为新指令地址； 4) 顺序执行一条指令，其地址为 m’+1； 5) 重复步骤 1~4，直到产生 400 个指令地址。 3、将指令地址流变换成页地址（页号）流，简化假设为： 1) 页面大小为 1K（这里 K 只是表示一个单位，不必是 1024B）； 2) 用户虚存容量为 40K； 3) 用户内存容量为 4 个页框到 40 个页框； 6 4) 用户虚存中，每 K 存放 10 条指令，所以那 400 条指令访问地址所对应的页地 址（页号）流为：指令访问地址为[0，9]的地址为第 0 页；指令访问地址为[10， 19]的地址为第 1 页；……。按这种方式，把 400 条指令组织进“40 页”，并 将“要访问的页号序列”记录到页地址流数组中。 4、循环运行，使用户内存容量从 4 页框到 40 页框。计算每个内存容量下不同页面置换 算法的命中率。输出结果可以为： 页框数 OPT 缺页率 FIFO 缺页率 LRU 缺页率 [4] OPT：0.5566 FIFO：0.4455 LRU：0.5500 [5] OPT：0.6644 FIFO：0.5544 LRU：0.5588 …… …… …… …… [39] OPT：0.9000 FIFO：0.9000 LRU：0.9000 [40] OPT：1.0000 FIFO：1.0000 LRU：1.0000 注 1：在某一次实验中，可能 FIFO 比 LRU 性能更好，但足够多次的实验表明 LRU 的平均性能比 FIFO 更好。 注 2：计算缺页率时，以页框填满之前和之后的总缺页次数计算。
虚拟内存页面置换算法的模拟实现
11-21
虚拟内存页面置换算法的模拟实现 课程设计
操作系统课设——FIFO页面置换算法演示
m0_62209604的博客
06-03 3717
通过本课程设计，更好地综合利用所学的操作系统基本原理和方法，增强系统级程序设计能力，进一步加深对操作系统的设计和实现思路的理解，培养系统软件设计能力和动手能力，学会在内核、系统调用及应用程序几个层次上编写程序，提升计算机问题求解的水平，增强系统分析能力。算法需要设置预演的访问序列长度和内存中有的页面数量，在这我使用了宏定义来进行预设： 预演的访问序列长度：#define M 12 内存中含有的页面数量 #define N 3，此处我预设了访问序列长度为12、内存中所含页面数量为3。
操作系统课设——存储管理
最新发布
01-03
在操作系统课设中，你可以通过随机数产生一个指令序列，模拟请求页式存储管理中的页面置换算法。你可以使用LRU算法来实现页面置换，并通过链栈来记录页面的使用顺序。具体实现的细节可以参考《操作系统》第四版中...
操作系统课程设计：虚拟内存页面置换算法的模拟与实现
m0_46107238的博客
07-10 1327
虚拟内存页面置换算法的模拟与实现1、实验目的2、实验基本知识及原理3、实验内容4、源代码 1、实验目的 通过对页面、页表、地址转换和页面置换过程的模拟，加深对虚拟页式内存管理系统的页面置换原理和实现过程的理解。 2、实验基本知识及原理 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标： 把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 教材给出的常用的页面置换算法包括： 1）最佳置换算法(OPT)：置换时淘汰“未来
操作系统中虚拟内存中的页面置换算法源代码及课设报告
01-15
能够模拟虚拟内存中的页面置换算法对页面进行置换，该程序具备的基本功能为： （1）能够输入进程的页面访问序列或系统自动生成进程的页面访问能序列和分配的内存块数。 （2）可以选择页面置换算法（先进先出算法、...
页面置换算法的模拟实现
02-16
设计一个虚拟存储区和内存工作区，编程序演示算法的具体实现过程，并计算访问命中率。 需要实现的算法： 先进先出算法 FIFO 最近最久未使用算法 LRU
页面置换算法的模拟（C++实现）
07-12
页面置换算法模拟 cout<<" 1.LRU "<<endl; cout<<" 2.FIFO"<<endl; cout<<" 3.OPT "<<endl; cout<<" 0.exit"<<endl;
页面置换算法的模拟实现.docx
03-03
（1）设计一个虚拟存储区和内存工作区，编程序演示下述算法的具体实现过程，并计算各个算法的缺页率。 （2）用C语言实现，要求设计主界面以灵活选择某算法，且以下算法都要实现： a:最佳置换算法(OPT)：将以后永不使用的或许是在最长(未来)时间内不再被访问的页面换出。 b: 先进先出算法(FIFO)：淘汰最先进入内存的页面，即选择在内存中驻留时间最久的页面予以淘汰。 c：最近最久未使用算法(LRU)：淘汰最近最久未被使用的页面。 （3）程序采用人工的方法选择，依次换策略选择一个可置换的页，并计算它们的缺页率以便比较。
页面置换算法模拟
02-05
在linux环境下用C语言编写程序，模拟进程在执行时内存中的页框置换过程。 读取文件中给定进程访问的逻辑页号序列，其中单号学号同学做workload1~6，双号学号同学做workload7~12。 设置内存页框大小为N（N分别取值为100，500，1000，2000，5000）。 采用3种不同的页面置换算法：FIFO,CLOCK,LRU。 画图比较不同页面置换算法对应的缺页率并分析原因(固定页框大小为1000)。 画图比较不同内存页框大小对应的缺页率并分析原因(固定置换算法为LRU)。 分析不同workload平均缺页率存在差异产生的原因。
页面置换算法的模拟实现 C
ai516001066的博客
09-06 2852
1 #include <stdio.h> 2 #include <stdlib.h> 3 4 /*全局变量*/ 5 int mSIZE; /*物理块数*/ 6 int pSIZE; /*页面号引用串个数*/ 7 static int memery[10]={0}; /*物理块中的页号*/ 8 static i...
页面置换算法模拟实现（C）
Qxxchampion的博客
05-17 2129
页面置换算法模拟实现C语言代码 #include "stdio.h" #include "stdlib.h" typedef struct item { int num; //页号 int time; //等待时间，LRU算法会用到这个属性 }Pro; int pageNum; //系统分配给作业的主存中的页面数 int memoryNum; //可用内存页面数 void print(Pro *page1); //打印当前主存中的页面 int Search(int num1, Pro
页面置换算法模拟实现-操作系统课程设计基于Java
Magnolia_He的博客
11-01 5018
操作系统课程设计--页面置换算法的实现
页面置换算法模拟实现【OPT/FIFO/LRU】
XXXTENTAC1ON的博客
07-08 3461
页面置换算法简单介绍 与C++代码模拟实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值