操作系统内存管理基础实验

最新推荐文章于 2024-08-27 13:33:21 发布
最新推荐文章于 2024-08-27 13:33:21 发布
阅读量530 收藏 3
点赞数
文章标签： 操作系统 内存管理 cache 替换算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Victayria/article/details/110382554
版权

本次实验要模拟三种cache替换算法（FIFO, LRU, OPT)，并且给出相应的缺页率。

首先说明一下符号定义：

int array[100]; // 请求访问的内存地址数组，需要依此访问array[0], array[1], ....
int page[100]; // 请求访问的页面数，规定一个页面大小为100，也就是说，page[0]:0-99, 
			   // page[1]:100-199
// 因此，将第i个请求地址映射到对应的页面号的公式：page[i] = array[i]/100+1
int pageSize = 3, size; // 缓存中一共能够存储3个页面，size为请求访问的地址数目
bool bre; // 终端标志，如果缓存中发生缺页，那么bre=true

每种替换算法，采用函数的方式实现。
主函数如下：

int main()
{
    int i, select;
    bool judge = true;
    cout << "输入地址总数和地址序列:" << endl;
    cin >> size;
    for (int i = 0; i < size; i ++)
    {
        cin >> array[i];
        page[i] = array[i] / 100 + 1;
    }
    while(judge) // 一直循环
    {
        cout << "1:FIFO" << endl;
        cout << "2:LRU" << endl;
        cout << "3:OPT" << endl;
        cin >> select; // 输入你想观察的算法编号
        switch(select) // 调用相应的算法求解
        {
            case 1: FIFO(); break;
            case 2: LRU(); break;
            case 3: OPT(); break;
        }
    }
    return 0;
}

每个算法会定义相应的cache中的缓存页队列que，表示已经缓存的页面编号，并且从队首到队尾表示最先到最近访问的页面。

（1）FIFO

void FIFO()
{
    int queye = 1, i;
    cout << "FIFO" << endl;
    queue<int> que;
    // 加载第一个访问的页面
    que.push(page[0]);
    // 一定会发生冷不命中
    bre = true;
    // 打印函数（打印当前访问的页面以及cache中缓存的页面编号）（见下一个代码段）
    print(que, page[0]);
    // 按照输入的顺序依此访问页面
    for (i = 1; i < size; i ++)
    {
    	// isEqual(queue<int> que, int x)函数，判断que中是否有x （见下下个代码段）
    	// 也就是判断cache中是否已经缓存了页面page[i]，缓存了返回true，否则返回false
        if(!isEqual(que, page[i])) // 缺页
        {
            bre = true; // 终端标志=true
            if(que.size() < 3) // 如果缓存页数小于3
            //（表示刚刚启动，发生的都是冷不命中，只需要将相应页加载进缓存即可）
            {
                que.push(page[i]);
                queye++;
            }
            else{ // 发生的是冲突不命中，需要替换，这里是FIFO（First In First Out)
                que.pop(); // 将最先加载的的弹出
                // 注意**这里是将最先加载的弹出，而LRU是将最早访问的弹出**
                que.push(page[i]); // push进入队列
                queye++;
            }
            print(que, page[i]);
        }
        else // 命中
        {
            bre = false;
            print(que, page[i]);
        }
        
    }
    double queyelv = (double) queye / (double) size; // 计算缺页率
    cout << "缺页率:" << queyelv << endl;
}

void print(queue<int> que, int p)
{
    printf("调用的页面为:%d", p);
    if(bre) cout << "    产生中断: ";
    else cout << "    不产生中断: ";
    while(que.size())
    {
        cout << que.front() << " ";
        que.pop();
    }
    cout << endl;
}


bool isEqual(queue<int> que, int num)
{
    while(que.size())
    {
        if(que.front() == num)
            return true;
        que.pop();
    }
    return false;
}

（2）LRU（Latest Recently Used)

void LRU()
{
    int queye = 1, i;
    cout << "LRU" << endl;
    queue<int> que;
    que.push(page[0]);
    bre = true;
    print(que, page[0]);
    for (i = 1; i < size; i ++)
    {
        if(!isEqual(que, page[i]))
        {
            bre = true;
            if(que.size() < 3)
            {
                que.push(page[i]);
                queye++;
            }
            else
            {
            	// 不命中，将最早访问的弹出
                que.pop();
                que.push(page[i]);
                queye++;
            }
            print(que, page[i]);
        }
        else // 命中，但是需要更新一下队列，将这个访问页面放到队列末尾，表示最近访问
        {
            bre = false;
            que = LRU_update(que, page[i]); // 更新队列函数（见下一个代码段）
            print(que, page[i]);
        }
    }
    double queyelv = (double) queye / (double) size;
    cout << "缺页率:" << queyelv << endl;
}

queue<int> LRU_update(queue<int> que, int num)
{
    queue<int> que1;
    while(que.size())
    {
        if(que.front() != num)
        {
            que1.push(que.front());
        }
        que.pop();
    }
    que1.push(num);
    return que1;
}

（3）OPT（optimal）

void OPT()
{
    int queye = 1;
    cout << "OPT" << endl;
    queue<int> que;
    que.push(page[0]);
    bre = true;
    print(que, page[0]);
    for (int i = 1; i < size; i ++)
    {
        if(!isEqual(que, page[i]))
        {
            bre = true;
            if(que.size() >= 3)
            {
                int remove_element = select_most_far(i, que); // 找到最优替换页的函数（见下一个代码段）
                que = OPT_update(que, page[i], remove_element); // 更新队列
                print(que, page[i]);
            }
            else
            {
                que.push(page[i]);
                print(que, page[i]);
            }
            queye++;
        }
        else
        {
            bre = false;
            print(que, page[i]);
        }
    }
    double queyelv = (double) queye / (double) size;
    cout << "缺页率:" << queyelv << endl;
}

// 比对缓存中的三个页面在未来的访问顺序中的距离（距离越大，表示未来越晚访问该页面）
// 找到未来最晚访问的已缓存页面，并return页面编号
// index表示目前正在处理哪一个访问
int select_most_far(int index, queue<int> que)
{
    int a = que.front();
    que.pop();
    int b = que.front();
    que.pop();
    int c = que.front();
    int dis1 = 10000000, dis2 = 10000000, dis3 = 10000000, i, max;
    index ++;
    for (int i = index; i < size; i ++)
    {
        if(page[i] == a){
            dis1 = i - index;
            break;
        }
    }
    for (int i = index; i < size; i ++)
    {
        if(page[i] == b){
            dis2 = i - index;
            break;
        }
    }
    for (int i = index; i < size; i ++)
    {
        if(page[i] == c){
            dis3 = i - index;
            break;
        }
    }
    int result;
    if(dis1 > dis2){
        max = dis1;
        result = a;
    }
    else{
        max = dis2;
        result = b;
    }
    if(max > dis3) return result;
    else return c;
}

queue<int> OPT_update(queue<int> que, int insert_element, int remove_element)
{
    queue<int> que1;
    while(que.size())
    {
        if(que.front() != remove_element)
            que1.push(que.front());
        que.pop();
    }
    que1.push(insert_element);
    return que1;
}

下面是完整程序代码：

#include <iostream>
#include <queue>
#include <cstdio>
using namespace std;

int array[100]; // 请求访问的内存地址数组，需要依此访问array[0], array[1], ....
int page[100]; // 请求访问的页面数，规定一个页面大小为100，也就是说，page[0]:0-99, 
			   // page[1]:100-199
// 因此，将第i个请求地址映射到对应的页面号的公式：page[i] = array[i]/100+1
int pageSize = 3, size; // 缓存中一共能够存储3个页面，size为请求访问的地址数目
bool bre; // 终端标志，如果缓存中发生缺页，那么bre=true

// 在
bool isEqual(queue<int> que, int num)
{
    while(que.size())
    {
        if(que.front() == num)
            return true;
        que.pop();
    }
    return false;
}


void print(queue<int> que, int p)
{
    printf("调用的页面为:%d", p);
    if(bre) cout << "    产生中断: ";
    else cout << "    不产生中断: ";
    while(que.size())
    {
        cout << que.front() << " ";
        que.pop();
    }
    cout << endl;
}

// Least Recently used
// make "num" the last element in queue
queue<int> LRU_update(queue<int> que, int num)
{
    queue<int> que1;
    while(que.size())
    {
        if(que.front() != num)
        {
            que1.push(que.front());
        }
        que.pop();
    }
    que1.push(num);
    return que1;
}

// optimal
// delete remove_element
// and push insert_element into the queue(tail)
queue<int> OPT_update(queue<int> que, int insert_element, int remove_element)
{
    queue<int> que1;
    while(que.size())
    {
        if(que.front() != remove_element)
            que1.push(que.front());
        que.pop();
    }
    que1.push(insert_element);
    return que1;
}

// find the remotest one in the requring page array
int select_most_far(int index, queue<int> que)
{
    int a = que.front();
    que.pop();
    int b = que.front();
    que.pop();
    int c = que.front();
    int dis1 = 10000000, dis2 = 10000000, dis3 = 10000000, i, max;
    index ++;
    for (int i = index; i < size; i ++)
    {
        if(page[i] == a){
            dis1 = i - index;
            break;
        }
    }
    for (int i = index; i < size; i ++)
    {
        if(page[i] == b){
            dis2 = i - index;
            break;
        }
    }
    for (int i = index; i < size; i ++)
    {
        if(page[i] == c){
            dis3 = i - index;
            break;
        }
    }
    int result;
    if(dis1 > dis2){
        max = dis1;
        result = a;
    }
    else{
        max = dis2;
        result = b;
    }
    if(max > dis3) return result;
    else return c;
}

void FIFO()
{
    int queye = 1, i;
    cout << "FIFO" << endl;
    queue<int> que;
    que.push(page[0]);
    bre = true;
    print(que, page[0]);
    for (i = 1; i < size; i ++)
    {
        if(!isEqual(que, page[i]))
        {
            bre = true;
            if(que.size() < 3)
            {
                que.push(page[i]);
                queye++;
            }
            else{
                que.pop();
                que.push(page[i]);
                queye++;
            }
            print(que, page[i]);
        }
        else
        {
            bre = false;
            print(que, page[i]);
        }
        
    }
    double queyelv = (double) queye / (double) size;
    cout << "缺页率:" << queyelv << endl;
}

void LRU()
{
    int queye = 1, i;
    cout << "LRU" << endl;
    queue<int> que;
    que.push(page[0]);
    bre = true;
    print(que, page[0]);
    for (i = 1; i < size; i ++)
    {
        if(!isEqual(que, page[i]))
        {
            bre = true;
            if(que.size() < 3)
            {
                que.push(page[i]);
                queye++;
            }
            else
            {
                que.pop();
                que.push(page[i]);
                queye++;
            }
            print(que, page[i]);
        }
        else
        {
            bre = false;
            que = LRU_update(que, page[i]);
            print(que, page[i]);
        }
    }
    double queyelv = (double) queye / (double) size;
    cout << "缺页率:" << queyelv << endl;
}

void OPT()
{
    int queye = 1;
    cout << "OPT" << endl;
    queue<int> que;
    que.push(page[0]);
    bre = true;
    print(que, page[0]);
    for (int i = 1; i < size; i ++)
    {
        if(!isEqual(que, page[i]))
        {
            bre = true;
            if(que.size() >= 3)
            {
                int remove_element = select_most_far(i, que);
                que = OPT_update(que, page[i], remove_element);
                print(que, page[i]);
            }
            else
            {
                que.push(page[i]);
                print(que, page[i]);
            }
            queye++;
        }
        else
        {
            bre = false;
            print(que, page[i]);
        }
    }
    double queyelv = (double) queye / (double) size;
    cout << "缺页率:" << queyelv << endl;
}

int main()
{
    int i, select;
    bool judge = true;
    cout << "输入地址总数和地址序列:" << endl;
    cin >> size;
    for (int i = 0; i < size; i ++)
    {
        cin >> array[i];
        page[i] = array[i] / 100 + 1;
    }
    while(judge)
    {
        cout << "1:FIFO" << endl;
        cout << "2:LRU" << endl;
        cout << "3:OPT" << endl;
        cin >> select;
        switch(select)
        {
            case 1: FIFO(); break;
            case 2: LRU(); break;
            case 3: OPT(); break;
        }
    }
    return 0;
}

效果截图：
输入
FIFO
LRU
OPT

操作系统，内存管理实验
01-02
用VC6.0运行的操作系统的内存管理实验。
操作系统内存管理实验
12-10
内有内存管理和请求分页内存管理实验，实验报告加代码。
【操作系统】实验：内存管理
m0_73970214的博客
08-27 1874
1、加深对固定和动态分区分配内存管理方式的理解2、理解动态分区分配算法：首次适应算法，循环首次适应算法，最佳适应算法。
操作系统实验——内存管理
m0_64847413的博客
01-23 2778
随着进程的运行，被引用的映射文件由存储管理程序装入内存，共享映射文件的进程的虚页面指向相同的内存块，而内存块中只保存着磁盘文件的一个页面副本，进程读写虚存内容相当于执行文件读写操作，而不再需要使用文件系统调用来读写数据，既节省空间，又无需执行缓冲到内存的复制操作。在打印f1文件的内容时仅考虑使用系统调用lseek移动开始读取的位置，看到f1中没有多少内容就想当然的以为所有文件的内容都很少，但实际上有些文件的内容时多过一页所能存放的内容的，而下段代码只能打印一页以内的内容。返回所映射到内存中的实际起始地址。
操作系统内存管理实验报告
03-11
在操作系统的研究与教学中，内存管理是一项核心议题，它直接关系到计算机系统的运行效率和稳定性。...通过这个实验，我们可以更好地掌握操作系统内存管理的技巧，为未来解决更复杂的系统问题打下坚实的基础。
操作系统实验LAB2内存管理
最新发布
02-04
完成LAB2实验后，学生将能够深入理解现代操作系统内存管理的核心技术，包括物理内存管理、页表管理以及缺页异常处理等机制的实现。此外，也能够熟练操作QEMU或树莓派等实验平台，为后续更深入的操作系统学习打下坚实...
操作系统实验-内存管理.doc
06-22
操作系统实验中的内存管理是计算机科学中的重要组成部分，它涉及到虚拟存储技术、页面置换算法和内存分配与回收。在这个实验中，学生将深入理解这些概念并实际操作以加深理解。 首先，实验目标是让学生掌握虚拟存储...
计算机操作系统内存分配实验源代码.pdf
10-02
根据提供的文件内容，可以推断出文件可能涉及到计算机操作系统中的内存管理、内存分配算法以及相关的数据结构实现。文件内容包含了C语言的源代码片段，其中涉及到内存分配的两种策略：首次适应算法（First Fit）和...
操作系统内存分配实验
12-28
操作系统内存分配实验是计算机科学教育中的一个重要环节，它让学生深入理解操作系统如何管理和分配内存资源，以便于高效地运行各种程序。在这个实验中，我们将聚焦于内存管理的基本概念，特别是内存分配策略，以及...
操作系统实验之内存管理
01-08
操作系统实验之内存管理，里面已经包含报告，只需要写个人感想即可
操作系统内存管理实验（C语言实现）
02-02
操作系统内存管理实验（C语言实现）
操作系统内存管理模拟实验
09-04
课程设计做的程序
操作系统实验五 内存管理
06-13
包括实验题目，代码及运行结果 实验5 内存管理（2学时） 一、实验目的 通过实验加强对内存管理方法的理解和掌握。 二、实验内容 编写程序实现采用可变分区方法管理内存。 三、实验要求 1、在该实验中，采用可变分区方式完成对存储空间的管理（即存储空间的分配与回收工作）。 2、设计用来记录主存使用情况的数据结构：已分区表和空闲分区表或链表。 3、在设计好的数据结构上设计一个主存分配算法（循环首次适应算法）。 4、在设计好的数据结构上设计一个主存回收算法。其中，若回收的分区有上邻空闲分区和（或）下邻空闲分区，要求合并为一个空闲分区登记在空闲分区表的一个表项里。 5、（附加）若需要可以实现程序的浮动，对内存空间进行紧凑。
操作系统内存管理实验报告及源代码
12-30
随机给出一个页面执行序列，如：1,5,3,4,2,1,3,4,5,7,9,……。要求计算以下几种置换算法的缺页数、缺页率和命中率。  最佳置换算法OPT（Optimal）  先进先出算法FIFO（First In First Out）  最近最少使用算法LRU（Least Recently Used） 实验报告（含流程图及运行结果）&源代码
【操作系统】实验四：内存管理
m0_70098011的博客
03-31 625
设计程序模拟内存的动态分区内存管理方法。内存空闲区使用空闲分区表进行管理，采用最先适应算法从空闲分区表中寻找空闲区进行分配，内存回收时不考虑与相邻空闲区的合并。t1 时刻，为作业A、B、C分配80K、60K、100K、的内存空间；要求编程序分别输出t1、t2、t3、t4、t5时刻内存的空闲区的状态。假定系统的内存共640K，初始状态为操作系统本身占用40K。t3 时刻为作业D分配50K的内存空间；t4 时刻作业C、A完成；实验四：内存管理（8学时）t2 时刻作业B完成；t5 时刻作业D完成。
操作系统模拟首次适应算法
weixin_45035564的博客
12-21 1818
老师程序基础上改动的，也是老师布置的作业。 亮点：实现循环首次适应算法 多一个p空闲块的指针；rearrange_NF()循环首次适应算法；由于要实现这个算法连动着的改了很多地方例如：set_algorithm()选择算法函数，还多弄了个free_mem1()，用于区别于前三个算法。 大佬互喷哈，卑微求赞。 /*宏定义*/ #include<stdio.h> #include<stdlib.h> #include<sys/types.h> #define PROC
操作系统内存管理协同实验报告
资源摘要信息:"本报告聚焦于操作系统中的内存...通过这份报告，学生不仅能够加深对操作系统内存管理理论知识的理解，还能够通过实际操作和实验，掌握内存管理的应用技能，为后续更深入的研究和开发工作打下坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Victayria

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值