操作系统课设(页面置换算法C++版)

最新推荐文章于 2024-06-27 13:34:18 发布
最新推荐文章于 2024-06-27 13:34:18 发布
阅读量3.7k 收藏 113
点赞数 3
分类专栏： other 文章标签： 算法 c++ 操作系统 页面置换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46456049/article/details/122522130
版权

运行结果

（1）data.txt文本文件：

请添加图片描述

                             图1 输入文件

将页面引用串输入到名为data.txt的文本文件中，以空格隔开。

（2）各种置换算法的输出结果：
请添加图片描述

                       图2 OPT页面置换算法运行结果

请添加图片描述

                      图3 FIFO页面置换算法运行结果

请添加图片描述

                        图4 LRU页面置换算法运行结果

请添加图片描述

                      图5 Clock页面置换算法运行结果

请添加图片描述

                       图6 LRU页面置换算法运行结果

完整代码

#include <iostream>
#include <vector>
#include <string>
#include <fstream>

#define random(a,b) (rand()%(b-a)+a)

using namespace std;

// 总虚页数
int t;
// 实页数
int size;
// 序列
vector<int> v;

// 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
void print(vector<pair<int, vector<int>>> res, int lackPageNum, int totalNum){

    for (int i = 0; i < size; ++i) {

        // 遍历每一个序列的第i个数
        for (int j = 0; j < res.size(); ++j) {
            printf("|");
            pair<int, vector<int>> cur = res[j];

            int isLack = cur.first;
            vector<int> v = cur.second;
            if(!isLack || v.size() < (i + 1)){
                printf("   ");
            }else{
                printf("%3d", v[i]);
            }
            printf("  ");
        }
        puts("|");
    }

    printf("缺页数为：%d\n", lackPageNum);
    printf("命中数：%d\n", (totalNum - lackPageNum));
    printf("缺页率为：%.3f%%\n", (lackPageNum * 100.0 / totalNum));
    printf("命中率为：%.3f%%\n", ((totalNum - lackPageNum) * 100.0 / totalNum));
}

void FIFO(){

    // 结果<是否缺页,页面>
    vector<pair<int, vector<int>>> res;

    // 上一页
    vector<int> pre;

    // 判断是否缺页的
    bool flag;

    int lackPageNum = 0;

    for(int num: v){

        flag = true; // 是否缺页

        for (int i = 0; i < pre.size(); ++i) {
            if(num == pre[i]){
                flag = false;
            }
        }

        if(!flag){
            res.push_back(make_pair(0, vector<int>(pre.begin(), pre.end())));
            continue;
        }

        lackPageNum++;

        if(pre.size() < size){

            pre.push_back(num);

        }else{

            // 缺页则换出队头
            pre.erase(pre.begin());
            pre.push_back(num);
        }

        res.push_back(make_pair(1, vector<int>(pre.begin(), pre.end())));
    }

    printf("FIFO(先进先出)算法：\n");
    print(res, lackPageNum, t);
    puts("");
    puts("");
}

void LRU(){

    // <是否缺页,页面>
    vector<pair<int, vector<int>>> res;

    // 上一页
    vector<int> pre;

    // 判断是否缺页的
    bool flag;
    // 缺页数
    int lackPageNum = 0;

    // 当前页在队中那个位置
    int idx = 0;

    for(int num: v){

        flag = true; // 是否缺页

        for (int i = 0; i < pre.size(); ++i) {
            if(num == pre[i]){
                flag = false;
                idx = i;
            }
        }

        if(!flag){
            // 换到队头
            pre.erase(pre.begin() + idx);
            pre.insert(pre.begin(), num);
            res.push_back(make_pair(0, vector<int>(pre.begin(), pre.end())));
            continue;
        }

        lackPageNum++;

        if(pre.size() < size){
            pre.insert(pre.begin(), num);
        }else{
            // 缺页则换出队尾
            pre.erase(pre.end()-1);
            pre.insert(pre.begin(), num);
        }

        res.push_back(make_pair(1, vector<int>(pre.begin(), pre.end())));
    }

    printf("LRU(最近最久未使用)算法：\n");
    print(res, lackPageNum, t);
    puts("");
    puts("");
}

void OPT(){

    // <是否缺页,页面>
    vector<pair<int, vector<int>>> res;

    // 上一页
    vector<int> pre;

    // 判断是否缺页的
    bool flag;
    // 缺页数
    int lackPageNum = 0;

    for(int k = 0; k < v.size(); k++){

        int num = v[k];
        flag = true; // 是否缺页

        for (int i = 0; i < pre.size(); ++i) {
            if(num == pre[i]){
                flag = false;
            }
        }

        if(!flag){
            res.push_back(make_pair(0, vector<int>(pre.begin(), pre.end())));
            continue;
        }

        lackPageNum++;

        if(pre.size() < size){
            pre.push_back(num);
        }else{
            // 最后面的数在v中的位置
            int last = -1;
            // 最后面的数在pre中的位置
            int idx;
            // 当前pre[i] 是否存在与v中
            bool isExit;
            // 缺页则换出pre中在v序列最后面的或者不在后面的序列的
            for (int i = 0; i < pre.size(); ++i) {
                isExit = false;
                for (int j = k + 1; j < v.size(); ++j) {
                    if(pre[i] == v[j]){
                        isExit = true;
                        if(j > last){
                            idx = i;
                            last = j;
                        }
                        break;
                    }
                }
                // 当前pre[i] 根本不在v中,则直接退出循环
                if(!isExit){
                    idx = i;
                    break;
                }
            }

            pre.erase(pre.begin() + idx);
            pre.insert(pre.begin()+ idx, num);
        }

        res.push_back(make_pair(1, vector<int>(pre.begin(), pre.end())));
    }

    printf("OPT(最佳)置换算法：\n");
    print(res, lackPageNum, t);
    puts("");
    puts("");
}

void setToOne(int &num, int idx){
    num = num + (1 << idx);
}

// 统一右移
void rightMove(vector<pair<int, int>> & visNum){

//    puts("");
    for(pair<int, int> &p: visNum){
//        printf("%d ", p.second);
        p.second = p.second >> 1;
    }

//    puts("");
}
// 判断是否在visNum中
bool isExit(vector<pair<int, int>> & visNum, int num){
    for(pair<int, int> &p: visNum){
        if(p.first == num){
            return true;
        }
    }
    return false;
}
// 找到某个数在队列中的索引
int findIdx(vector<pair<int, int>> & visNum, int num){
    for (int i = 0; i < visNum.size(); ++i) {
        pair<int, int> p = visNum[i];
        if(p.first == num){
            return i;
        }
    }
    return -1;
}

// 找到 freq 最小的在 pre 中的位置
int findMinIdx(vector<pair<int, int>> visNum, vector<int> pre){

    int id = -1;
    int min = (1 << 31) - 1;

    for (int i = 0; i < pre.size(); ++i) {
        for (int j = 0; j < visNum.size(); ++j) {
            pair<int, int> p = visNum[j];
            if(pre[i] == p.first && p.second < min){
                id = i;
                min = p.second;
            }
        }
    }
    return id;
}

void LFU(){

    vector<pair<int, vector<int>>> res;
    vector<int> pre;

    // 记录访问频率<数, 频率>
    vector<pair<int, int>> visNum;
    int lackPageNum = 0;

    for (int num: v) {

        bool flag = true;
        rightMove(visNum);

        for (int i = 0; i < pre.size(); ++i) {
            if(pre[i] == num){
                flag = false;
            }
        }

        if(!flag){
            int idx = findIdx(visNum, num);
            setToOne(visNum[idx].second, 30);
            res.push_back(make_pair(0, vector<int>(pre.begin(), pre.end())));
            continue;
        }

        lackPageNum++;

        bool isEx = isExit(visNum, num);

        if(pre.size() < size){
            pre.push_back(num);
            visNum.push_back({num, (1 << 30)});
        }else{

            if(!isEx){
                visNum.push_back({num, (1 << 30)});
            }else{
                int idx = findIdx(visNum, num);
                setToOne(visNum[idx].second, 30);
            }

            int idx = findMinIdx(visNum, pre);

            pre.erase(pre.begin() + idx);
            pre.push_back(num);
        }

        res.push_back(make_pair(1, vector<int>(pre.begin(), pre.end())));
    }

    printf("LFU(最少使用)置换算法：\n");
    print(res, lackPageNum, t);

    puts("");
    puts("");
}

// 1 3 4 2 5 6 3 4 7
void CLK(){

    vector<pair<int, vector<int>>> res;

    vector<int> pre;
    int vis[t + 5];

    int lackPageNum = 0;
    bool flag;

    // 指针
    int idx = 0;

    for (int num: v) {
        flag = true;
        for (int i = 0; i < pre.size(); ++i) {
            if(pre[i] == num){
                vis[i] = 1;
                flag = false;
            }
        }

        if(!flag){
            res.push_back(make_pair(0, vector<int>(pre.begin(), pre.end())));
            continue;
        }

        lackPageNum++;

        if(pre.size() < size){
            pre.push_back(num);
            vis[pre.size()-1] = 1;
        }else{

            while (true){

                if(!vis[idx]){
                    pre.erase(pre.begin() + idx);
                    pre.insert(pre.begin() + idx, num);
                    vis[idx] = 1;
                    idx = (idx + 1) % size;
                    break;
                }

                vis[idx] = 0;
                idx = (idx + 1) % size;
            }
        }

        res.push_back(make_pair(1, vector<int>(pre.begin(), pre.end())));
    }

    printf("NRU(最近未用)置换算法：\n");
    print(res, lackPageNum, t);

    puts("");
    puts("");
}


void init1(){

    printf("可用物理块大小：");
    scanf("%d", &size);
    printf("调入序列长度：");
    scanf("%d", &t);

    int num;

    printf("请输入调入页面序列：");

    printf("");
    for (int i = 0; i < t; ++i) {
        scanf("%d", &num);
        v.push_back(num);
    }
}

void init2(){

    ifstream df("../data.txt");

    if (!df.is_open()){

        cout << "Error opening file";
        exit (1);
    }
    df >> size;
    df >> t;
    int num;
    for (int i = 0; i < t; ++i) {
        df >> num;
        v.push_back(num);
    }

    df.close();
}

void init3(){

    int a = 1, b = 10;
    size = 3;
    t = 20;
    int num;

    for (int i = 0; i < t; ++i) {
        num = random(a, b);
        v.push_back(num);
    }
}

int main(){

//    int num = 1;
//    setToOne(num, 4);
//    cout << num;

//    init1();
    init2();
//    init3();

    printf("\n\n\n访问序列：");
    for (int i = 0; i < v.size(); ++i) {
        printf("%d  ", v[i]);
    }

    puts("");

    FIFO();
    LRU();
    OPT();
    LFU();
    CLK();


    // Test
//    vector<pair<int, int>> vp;
//    vp.push_back({3, 8});
//    rightMove(vp);
//    setToOne(vp[0].second, 30);
//    cout << vp[0].second;

    return 0;
}
sweetheart7-7
关注
专栏目录
操作系统课设——FIFO页面置换算法演示
m0_62209604的博客
06-03 3717
通过本课程设计，更好地综合利用所学的操作系统基本原理和方法，增强系统级程序设计能力，进一步加深对操作系统的设计和实现思路的理解，培养系统软件设计能力和动手能力，学会在内核、系统调用及应用程序几个层次上编写程序，提升计算机问题求解的水平，增强系统分析能力。算法需要设置预演的访问序列长度和内存中有的页面数量，在这我使用了宏定义来进行预设： 预演的访问序列长度：#define M 12 内存中含有的页面数量 #define N 3，此处我预设了访问序列长度为12、内存中所含页面数量为3。
操作系统课程设计-页面置换算法C语言
12-19
操作系统课程设计-页面置换算法C语言，有页面置换的各个算法，和实验报告
操作系统—页面置换算法（C++实现）
05-13
页面置换算法: 资源包含三个算法：OPT---最佳置换算法、//FIFO---先进先出、//LRU---最近最久未使用 操作：用户输入物理块数、页面待要访问的个数、每个页面编号，计算出缺页数、置换数、缺页率 语言：C++ 运行环境：Visual Studio 2013/更高版本
操作系统页面置换算法在C++中的实现
shenhaizpg的博客
05-24 2616
操作系统存储管理在C++中的实现 存储管理代码简介 存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。 本代码的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 代码实现 头文件及宏定义 #include<iostream> #include<time.h> #include<string> #include<map> using namespace std; #de
计算机操作系统常考大题: 1页表,页号,物理块号 2页面置换算法(LRU、FIFO和最佳页面置换) 3磁盘调度算法(FCFS,SSTF,SCANF) 4处理机调度(FCFS,SJF)
最新发布
m0_73678713的博客
06-27 1015
1页表,页号,物理块号 2页面置换算法(LRU、FIFO和最佳页面置换) 3磁盘调度算法(FCFS,SSTF,SCANF) 4处理机调度(FCFS,SJF)
操作系统页面置换算法c语言_操作系统——页面置换算法（C++版）
weixin_39906878的博客
12-11 1242
人在美国，刚下飞机！小白第一次写知乎文章，如果有不准确的地方，请各位大神多多指教。本次我要写的文章是操作系统的页面置换算法（OPT、FIFO、LRU、CLOCK）。页面置换算法不是很难，想必搜我这种文章的应该是都懂原理。所以在这里，简单概括算法特点，主要是展示代码。最佳置换算法——OPT（Optimal）置换算法OPT是一种理想的置换算法。当要调入一页面而必须淘汰一个旧页面时，所淘汰的页面应该是以...
C++版页面置换算法
07-01
利用C++语言来实现操作系统中的几种页面置换算法。
页面置换算法的C++代码实现
12-18
页面置换算法的C++实现，比较各种算法的优缺点
操作系统课设-页面置换算法
06-08
操作系统是计算机科学中的核心课程，其中页面置换算法是内存管理的重要组成部分，特别是在现代多任务环境中。本项目聚焦于四种常见的页面置换算法：FIFO（先进先出）、LRU（最近最少使用）、OPT（最佳页面置换）和...
操作系统课程设计---页面置换算法的模拟实现--高分课设---c语言编写
05-15
操作系统课程设计---页面置换算法的模拟实现--高分课设---c语言编写 资源里包含源码和课程设计报告，可供学习。高分课设 页面置换算法的模拟实现 用C或C++语言设计一个虚拟存储区和内存工作区，编程序演示下述算法的...
操作系统课设-LRU算法的实现 (2).docx
09-13
- 要求能够清晰展示算法的执行过程，如页面访问序列、页面置换情况等。 - 需要提供不同算法的对比，例如与FIFO（先进先出）算法的比较，以验证LRU的有效性。 3. **设计内容与主要功能**： - 设计一个数据结构来...
操作系统课程设计页面置换算法
12-07
这是这几天刚刚和我的小组完成的操作系统页面置换算法，完全是手巧，没有复制网上资源，是一个完整的文档，已经通过了老师的验收，付出了心血，加了很多注释。希望您能够帮助到大家，谢谢。
操作系统实验报告 用C++实现页面置换算法，LRU与FCFS
12-02
操作系统实验报告，用C++实现 最近最久未使用LRU,先来先服务页面置换算法FIFO
页面置换算法（OPT、FIFO、LRU）实现--C++版本
09-15
该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法，包括先进先出（FIFO）、最佳置换算法（OPT）、最久最近未使用算法（LRU）。 具体实现功能有： 1、建立相应的数据结构 2、在屏幕上显示页面的状况 3、时间的流逝可用下面几种方法模拟：按键盘，每按一次可认为过一个时间单位; 4、将一批页的置换情况存入磁盘文件，以后可以读出并重放; 5、计算页面的缺页次数、缺页后的页面置换次数 6、支持算法：FIFO、LRU、最佳置换算法。
操作系统3种页面置换算法 C++实现
09-14
操作系统课程FiFO，OPT，LRU三种页面置换算法用C++实现，代码清晰，有少量注释，希望给有上机的孩子们一些参考
页面置换算法（FIFO、LRU、LFU）c++实现
baidu_34785556的博客
08-11 6498
1. FIFO(First in First out) -- 先进先出 先来先服务的策略。如果一个数据最先进入缓存中，则应该最早淘汰掉。也就是说，当缓存满的时候，应当把最先进入缓存的数据给淘汰掉。（这个可以类比队列较好理解） 实现：核心：双向链表实现队列+ hashmap 利用一个双向链表保存数据，当来了新的数据之后便添加到链表末尾，如果Cache存满数据，则把链表头部数据删除，然后把新的数...
【计算机操作系统】页面置换算法 C++
lushixuan12345的博客
11-10 2637
页面置换算法 C++页面置换算法 C++1.代码2.案例 页面置换算法 C++ 1.代码 #include <iostream> #include <cstring> #include <algorithm> //提供了大量基于迭代器的非成员模版函数 #include <queue> //队列 using namespace std; const int MAX_SIZE = 1e3+5;//1e3+5=1005 const int INF =
页面置换算法 c++
12-15
存储管理中页面置换算法性能测试 要求：设系统采用固定分配局部置换的存储分配策略，编写仿真程序对下述页面 置换算法进行性能测试，并对结果进行分析和比较。 (1) 最佳适应(Optimal)页面置换算法； (2) 先进先出(FIFO)页面置换算法； (3) 最近最久未使用(LRU)页面置换算法； (4) 最少使用(LFU)页面置换算法。 要求可适用于键盘输入和自动产生随机页面走向序列两种数据输入方式。
虚拟存储管理：页面置换算法模拟实现与比较
"该文档是关于操作系统课设的页面置换算法模拟实现，旨在通过C语言编程来演示和比较三种不同的页面置换算法：最佳置换算法(OPT)、先进先出算法(FIFO)和最近最久未使用算法(LRU)。设计要求包括创建虚拟存储区和内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值