操作系统实验—存储管理

最新推荐文章于 2024-10-07 20:03:06 发布
最新推荐文章于 2024-10-07 20:03:06 发布
阅读量7.2k 收藏 126
点赞数 17
分类专栏： 操作系统（OS） 文章标签： 操作系统 存储管理 OS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love521314123/article/details/121976239
版权

操作系统实验—存储管理

所有实验源码：

gitee：https://gitee.com/infiniteStars/os-project

github：https://github.com/helloworldzsq/OSproject

1.实验内容

设计一个虚拟存储区和内存工作区，并使用下述方法计算访问命中率。

① 进先出的算法（FIFO）；

②最近最少少使用算法(LRU);

③最佳淘汰算法(OPT):选淘汰最不常用的页地址;

④最少访问页面算法(LFR);

⑤最近最不经常使用算法(NUR)；

⑥简单 Clock 淘汰算法及改进型 Clock 淘汰算法.

（其中④⑤⑥为选择内容）

命中率= 1 - 页面失效次数 / 页地址流长度

2.实验要求

本实验课题功能设计要求如下：

（1）编程设计实现最佳淘汰算法、先进先出淘汰算法、最近最久未使用淘汰算法、最少访问页面算法(LFR)、最近最不经常使用算法(NUR).；

（2）编程设计实现页面访问序列的随机产生机制，包括各页面读写访问方式的设定算法的要求；

（3）在执行进程和访问各页面过程中，每访问一个（或一次）页面应显示输出当时的进程页表内容（包括页号、物理块号、状态位、读/写访问方式等字段）及本次页面访问操作情况（譬如页面已在内存或触发缺页中断）；

（4）基于相同的条件，包括系统均采用固定分配局部置换策略、相同的进程逻辑地址空间大小（暨逻辑页面数，设进程逻辑地址空间的页面总数为 N，则其页号取值区间为[0, N)）、分配给进程同样多的物理块（设进程分配获得 S 个物理块，则相应物理块号分别标记为 PF0 、 PF1、……、PFN-1）、相同的页面访问序列（整数序列，整数取值区间为[0, N)）、均预装入前三个页面，进行有关算法的测试；

（5）变换上述条件实施多次测试，统计分析和比较有关算法的性能（譬如缺页率、淘汰页、查找时间开销）。

3.运行结果

  • 可以看到随着页面数量的不断增多，各种算法的命中率也逐渐增加

image-20211216153644638

4. 实验源码

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#define TRUE 1
#define FALSE 0
#define INVALID -1
#define NULL  0
#define  total_instruction 320     //指令数
#define  total_vp  32               //虚拟页数量
#define  clear_period  50           //清0周期

//页面结构
typedef struct
{
    int pn;      //进程的页号
    int pfn;     //物理内存的块号
    int counter; //一个周期内访问该页面的次数
    int time;    //访问时间
}pl_type;

pl_type pl[total_vp];                      /*页面线性结构---指令序列需要使用地址*/

//页面控制结构
typedef struct pfc_struct
{
    int pn;
    int pfn;
    struct pfc_struct *next;
}pfc_type;

//1.定义用户进程虚页控制结构 result.空页面头指针 3. 忙页面头指针  4. 忙页面尾指针
pfc_type pfc[total_vp], *freepf_head, *busypf_head, *busypf_tail;
//1.页面失效次数  result.a[]  指令序列
int diseffect,  a[total_instruction];
//1. 每条指令所在的页号 result.每页装入10条指令后取模运算页号偏移值
int page[total_instruction],  offset[total_instruction];

int  initialize(int);
int  FIFO(int);
int  LRU(int);
int  LFU(int);
int  NUR(int);
int  OPT(int);
int main( )
{
    int s,i;
    srand(10*getpid());                    /*由于每次运行时进程号不同，故可用来作为初始化随机数队列的“种子”*/
    //rand() 返回一个范围在 0 到 RAND_MAX 之间的伪随机数。
    //RAND_MAX 是一个常量，它的默认值在不同的实现中会有所不同，但是值至少是 32767
    s=(float)319*rand()/32767+1;
    for(i=0;i<total_instruction;i+=4)        /*产生指令队列*/
    {
        if(s<0||s>319)
        {
            printf("When i==%d,Error,s==%d\n",i,s);
            exit(0);
        }
        a[i]=s;                                   /*任选一指令访问点m*/
        a[i+1]=a[i]+1;                            /*顺序执行一条指令*/
        a[i+2]=(float)a[i]*rand()/32767;          /*执行前地址指令m*/
        a[i+3]=a[i+2]+1;                          /*顺序执行一条指令*/
        s=(float)(318-a[i+2])*rand( )/32767+a[i+2]+2;
        if((a[i+2]> 318)|| (s>319))
            printf("a[%d+result],a number which is :%d and s==%d\n",i,a[i+2],s);
    }
    //将指令序列转换成页号，偏移值
    for (i=0;i<total_instruction;i++) /*将指令序列变换成页地址流*/
    {
        page[i]=a[i]/10;
        offset[i]=a[i]%10;
    }
    //   从四个页面到32个，查看命中率
    for(i=4;i<=32;i++)
    {
        printf("---%2d page frames---\n",i);
        //先进先出置换算法
        FIFO(i);
        //最近最久未使用算法
        LRU(i);
        //最近不经常使用算法
        LFU(i);
        //最近最不经常使用算法
        NUR(i);
        //最佳置换算法
        OPT(i);
    }
    return 0;
}

/*初始化相关数据结构 total_pf表示内存的块数 */
int initialize(int total_pf)
{
    int i;
    diseffect=0;
    for(i=0;i<total_vp;i++)
    {

        pl[i].pfn=INVALID;       /*置页面控制结构中的页号，页面为空*/
        pl[i].counter=0;         /*页面控制结构中的访问次数为0*/
        pl[i].time=-1;           /*访问的时间*/
    }

    for(i=0;i<total_pf-1;i++)	/*建立pfc[i-1]和pfc[i]之间的链接*/
    {
        pfc[i].next=&pfc[i+1];
        pfc[i].pfn=i;
    }
    pfc[total_pf-1].next=NULL;
    pfc[total_pf-1].pfn=total_pf-1;
    freepf_head=&pfc[0];         /*空页面队列的头指针为pfc[0]*/
    return 0;
}

int FIFO(int total_pf)              /*先进先出算法total_pf:用户进程的内存页面数*/
{
    int i;
    pfc_type *p;					/*中间变量*/
    initialize(total_pf);         /*初始化相关页面控制用数据结构*/
    busypf_head=busypf_tail=NULL; /*忙页面队列头，队列尾链接*/
    for(i=0;i<total_instruction;i++)
    {
        if(pl[page[i]].pfn==INVALID)   /*页面失效*/
        {
            diseffect+=1;                  /*失效次数*/
            if(freepf_head==NULL)         /*无空闲页面*/
            {
                p=busypf_head->next;
                //将第一个忙页面释放
                pl[busypf_head->pn].pfn=INVALID;
                freepf_head=busypf_head;  /*释放忙页面队列的第一个页面*/
                freepf_head->next=NULL;  /*表明还是缺页*/
                busypf_head=p;
            }
            p=freepf_head->next;
            freepf_head->pn=page[i];
            pl[page[i]].pfn=freepf_head->pfn;
            freepf_head->next=NULL;
            if(busypf_tail==NULL)
            {
                busypf_tail = busypf_head = freepf_head;
            }
            else
            {
                busypf_tail->next=freepf_head;
                busypf_tail=freepf_head;
            }
            freepf_head=p;
        }
    }
    //命中率  %6.4含义：总共六位数，四位小数，一个小数点，整数1位
    printf("FIFO : %6.4f " , 1-(float)diseffect/320);
    return 0;
}
int LRU (int total_pf)       /*最近最久未使用算法least recently used*/
{
    int min,minj,i,j,present_time; /*minj为最小值下标*/
    initialize(total_pf);
    present_time=0;
    for(i=0;i<total_instruction;i++)
    {
        if(pl[page[i]].pfn==INVALID)             /*页面失效*/
        {
            diseffect++;
            if(freepf_head==NULL)              /*无空闲页面*/
            {
                min=32767;						/*设置最大值*/
                for(j=0;j<total_vp;j++)            /*找出time的最小值*/
                {
                    if(min>pl[j].time&&pl[j].pfn!=INVALID)
                    {
                        min=pl[j].time;
                        minj=j;
                    }
                }
                freepf_head=&pfc[pl[minj].pfn];   //腾出一个单元
                pl[minj].pfn=INVALID;
                pl[minj].time=0;
                freepf_head->next=NULL;
            }
            pl[page[i]].pfn=freepf_head->pfn;   //有空闲页面,改为有效
            pl[page[i]].time=present_time;
            freepf_head=freepf_head->next;      //减少一个free 页面
        }
        else
        {
            pl[page[i]].time=present_time;        //命中则增加该单元的访问次数
            present_time++;
        }
    }
    printf("LRU:%6.4f ",1-(float)diseffect/320);
    return 0;
}

int NUR(int  total_pf )                  /*最近未使用算法Not Used recently count表示*/
{
    int i,j,dp,cont_flag,old_dp;
    pfc_type *t;
    initialize(total_pf);
    dp=0;

    for(i=0;i<total_instruction;i++)
    {
        if (pl[page[i]].pfn==INVALID)         /*页面失效*/
        {
            diseffect++;
            if(freepf_head==NULL)               /*无空闲页面*/
            {
                cont_flag=TRUE;
                old_dp=dp;

                while(cont_flag)
                {

                    if(pl[dp].counter==0&&pl[dp].pfn!=INVALID)
                        cont_flag=FALSE;
                    else
                    {
                        dp++;
                        if(dp==total_vp)
                            dp=0;
                        if(dp==old_dp)
                            for(j=0;j<total_vp;j++)
                                pl[j].counter=0;
                    }
                }
                freepf_head=&pfc[pl[dp].pfn];
                pl[dp].pfn=INVALID;
                freepf_head->next=NULL;
            }

            pl[page[i]].pfn=freepf_head->pfn;

            freepf_head->pn=page[i];

            freepf_head=freepf_head->next;
        }
        else
            pl[page[i]].counter=1;
        if(i%clear_period==0)
            for(j=0;j<total_vp;j++)
                pl[j].counter=0;
    }
    printf("NUR:%6.4f ",1-(float)diseffect/320);
    return 0;
}

int OPT(int total_pf)       /*最佳置换算法*/
{
    int i,j, max,maxpage,d,dist[total_vp];
    pfc_type *t;
    initialize(total_pf);
    for(i=0;i<total_instruction;i++)
    {
        if(pl[page[i]].pfn==INVALID)      /*页面失效*/
        {
            diseffect++;
            if(freepf_head==NULL)         /*无空闲页面*/
            {
                for(j=0;j<total_vp;j++)
                {
                    if(pl[j].pfn!=INVALID)
                        dist[j]=32767;
                    else
                        dist[j]=0;
                }
                for(j=0;j<total_vp;j++)
                {
                    if((pl[j].pfn!=INVALID)&&(dist[j]==32767))
                    {
                        dist[j]=j;
                    }
                }
                max=0;
                for(j=0;j<total_vp;j++)
                    if(max<dist[j])
                    {
                        max=dist[j];
                        maxpage=j;
                    }
                freepf_head=&pfc[pl[maxpage].pfn];
                freepf_head->next=NULL;
                pl[maxpage].pfn=INVALID;
            }
            pl[page[i]].pfn=freepf_head->pfn;
            freepf_head=freepf_head->next;
        }
    }
    printf("OPT:%6.4f\n",1-(float)diseffect/320);
    return 0;
}
/*该算法时根据已知的预测未知的，least frequency  Used是最不经常使用置换法*/
int  LFU(int total_pf)
{
    int i,j,min,minpage;
    pfc_type *t;
    initialize(total_pf);
    for(i=0;i<total_instruction;i++)
    {
        if(pl[page[i]].pfn==INVALID)      /*页面失效*/
        {
            diseffect++;
            if(freepf_head==NULL)          /*无空闲页面*/
            {
                min=32767;
                /*获取counter的使用用频率最小的内存*/
                for(j=0;j<total_vp;j++)
                {
                    if(min>pl[j].counter&&pl[j].pfn!=INVALID)
                    {
                        min=pl[j].counter;
                        minpage=j;
                    }
                }
                freepf_head=&pfc[pl[minpage].pfn];
                pl[minpage].pfn=INVALID;
                pl[minpage].counter=0;
                freepf_head->next=NULL;
            }
            pl[page[i]].pfn=freepf_head->pfn;   //有空闲页面,改为有效
            pl[page[i]].counter++;
            freepf_head=freepf_head->next;      //减少一个free 页面
        }
        else
        {
            pl[page[i]].counter;
            pl[page[i]].counter=pl[page[i]].counter+1;
        }
    }
    printf("LFU:%6.4f ",1-(float)diseffect/320);
    return 0;
}
一只不吃老鼠的猫
关注
专栏目录
操作系统课程设计报告书-设计一个虚拟存储区和内存工作区.doc
07-08
操作系统课程设计报告书-设计一个虚拟存储区和内存工作区
操作系统 存储管理实验报告
热门推荐
十一月廿七风雨大作
06-19 3万+
实验要求 实验目的 存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。 本实验的目的是通过请求页式管理中页面置换算法模拟设计，了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。 二、实验内容 （1） 通过计算不同算法的命中率比较算法的优劣。同时也考虑了用户内存容量对命中率的影响。 页面失效次数为每次访问相应指令时，该指令所对应的页不在内存中的次数。 在本实验中，假定页面大小为1k，用户虚存容量为32k，用户内存容量为4页到32页。 （2） produce_adds
操作系统实验之内存管理
最新发布
qq_61012545的博客
10-07 781
通过本次实验，我学习了页面置换算法，包括先进先出（FIFO）和最近最少使用（LRU）两种算法，以及内存管理算法，包括首次适应算法和最佳适应算法。在实践中，我通过代码实现和调试更深刻地理解了这两种算法的工作原理和优缺点。首次适应算法通过从内存起始位置开始搜索，找到第一个满足请求大小的空闲块进行分配。它的优点是简单、快速，适合处理大量临时内存请求。但它可能会导致内存碎片化问题，使得大块的连续内存难以分配。最佳适应算法通过从所有空闲块中选择大小最接近请求大小的块进行分配。
操作系统实验之存储管理
guleilei0的博客
12-08 2895
分析：通过多次运行结果发现，OPT算法淘汰页面最少，命中率始终最高，FIFO算法和LRU算法命中率差不多，但是淘汰页面大有不同。1、了解虚拟存储技术的特点，掌握请求页式存储管理的主要页面置换算法原理。3、通过随机产生页面访问序列开展有关算法的测试及性能比较。2、掌握请求页式存储管理中页面置换算法的模拟设计方法。③最佳淘汰算法(OPT):选淘汰最不常用的页地址;②最近最少少使用算法(LRU);⑤最近最不经常使用算法(NUR).①先进先出的算法（FIFO）；④最少访问页面算法(LFR);2.Lru算法流程图。
操作系统之存储管理
m0_56410967的博客
12-06 1663
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。掌握分页存储管理的基本原理及分页存储管理中的地址变换过程，编制一个模拟地址变换过程的程序并能采用先进先出页面置换算法实现页面置换。
设计一个虚拟存储区和内存工作区，并使用下列算法计算访问命中率：(1)进先出的算法(FIFO)(2)最近最少使用的算法(LRU)(3)最佳淘汰算法(OPT)(4)最少访问页面算法(LFU)
星云
02-12 7526
设计一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程, 并计算访问命中率。设计要求:主界面以灵活选择某算法,且以下算法都要实现 1、先出的算法(FIFO)(2)最近最少使用的算法(LRU)(3)最佳淘汰算法(OPT)(4)最少访问页面算法(LFU)import time import sys import random from multiprocessing import * class Page: ''' 页面。 ''' def __init__(self
JAVA操作系统实验存储管理图形化模拟程序
01-10
在本实验项目“JAVA操作系统实验存储管理图形化模拟程序”中，主要涉及的是操作系统领域的内存管理知识，通过JAVA 16编程语言实现了一个具有图形用户界面（GUI）的应用。这个程序设计的目标是帮助用户理解并可视化...
操作系统实验三：存储管理.doc
10-29
操作系统实验报告
操作系统实验 分页式存储管理
06-20
总之，"操作系统实验 分页式存储管理"是一个深入理解和实践操作系统内存管理的绝佳机会。通过这个实验，我们可以加深对分页技术的理解，掌握页表、缺页中断、页面替换算法等核心概念，并能亲手实现这些机制，从而为...
操作系统实验四存储管理.doc
11-29
操作系统实验四存储管理 本实验报告的主要目的是为了学习和了解操作系统的存储管理机制，特别是 Windows 7 操作系统的存储管理机制。通过本实验，学生可以学习如何观察和调整 Windows 的存性能，加深对操作系统存储...
操作系统存储管理实验报告.doc
11-29
操作系统存储管理实验报告 本实验报告主要讲述操作系统存储管理的实验内容，包括实验目的、实验设计思想、环境语言、工具等。实验的主要目的是加深对操作系统存储管理的理解，并通过模拟页面调试算法来加深理解操作...
【操作系统实验】存储管理（Linux环境下）
xtcc的博客
06-10 6477
【实验目的】 实验目的： 1.通过模拟实现请求页式存储管理的几种基本页面置换算法，了解虚拟存储技术的特点，掌握虚 拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。 实验要求：掌握五种存储管理算法 1）最佳淘汰算法（OPT） 2）先进先出的算法（FIFO） 3）最近最久未使用算法（LRU） 4）最不经常使用算法（LFU） 5）最近未使用算法（NUR） 2.熟悉内存自由空闲队列的分配策略及熟悉内存分区的回收原则及实现过程 【实验内容】 设计一个虚拟存储区和内存工作区，并使用下
虚拟内存页面置换算法（OPT、FIFO、LRU）模拟与实现
weixin_47700137的博客
07-08 1万+
前言 需要调入新页面时，选择内存中哪个物理页面被置换，称为置换策略。页面置换算法的目标：把未来不再使用的或短期内较少使用的页面调出，通常应在局部性原理指导下依据过去的统计数据进行预测，减少缺页次数。 一、常用的页面置换算法 1）最佳置换算法(OPT)：置换时淘汰“未来不再使用的”或“在离当前最远位置上出现的”页面。 2）先进先出置换算法(FIFO)：置换时淘汰最先进入内存的页面，即选择驻留在内存时间最长的页面被置换。 3）最近最久未用置换算法(LRU)：置换时淘汰最近一段时间最久没有使用的页面，即选择上次使
页面置换算法的模拟（FIFO，LRU和OPT）
qq_63165951的博客
06-12 2145
页面置换算法
操作系统 实验五 存储管理
天上下雨地上滑，自己跌倒你自己爬
01-21 4636
一、实验目的 1、了解虚拟存储技术的特点，掌握请求页式存储管理的主要页面置换算法原理。 2、掌握请求页式存储管理中页面置换算法的模拟设计方法。 二、实验内容 设计一个虚拟存储区和内存工作区，并使用下述方法计算访问命中率。 ①先进先出的算法（FIFO）：最先进来的页先出去了啊。该算法是基于最早进入主存器的页未被使用的可能性要大。但如果一页要经常的被访问，它在一定的时间内又会被重新的调入。这会增加磁盘启动的次数。 ②最近最少少使用算法(LRU)：是基于程序使用的局部性原理。我们规定，队首元素为最
操作系统实验三 存储管理
qq_56418536的博客
11-14 3190
操作系统实验 存储管理
操作系统实验五：存储管理设计
定期分享我的发现和想法，感谢你的陪伴和支持
10-20 7167
用户虚存容量32K, 每K中放10条指令, 共320条指令(0～319)。3、使用不同的页面调度算法处理缺页中断，并计算不同实存容量下(4～32K)的命中率。* (3) 最佳淘汰算法(OPT): 先淘汰最不常用的页地址;(5) 向后地址(m’＋2, 319]中执行一条指令g’。(3) 向前地址[0, m－1]中执行一条指令m’；命中率＝1－ -------------(4) 顺序执行一条指令, 即 m’＋1 条;(2) 25％的指令是均匀分布在前地址部分。(3) 25％的指令是均匀分布在后地址部分。
Linux——页面置换算法（OPT、FIFO、LRU的实现与比较）
x20020402的博客
11-01 3779
由于无法预测各页面将来的使用情况，只能利用“最近的过去”做“最近的将来”的近似，因此，LUR置换算法是选择最近最久未使用的页面予以淘汰。（3）缺点：该算法与进程实际运行的规律不相适应，因为在进程中，有些页面经常被访问，比如：含有全局变量、常用函数、例程等的页面，FIFO算法并不能保证这些页面不被淘汰。（3）缺点：人们目前通常还无法预知，一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不再被访问的，因此，该算法是无法实现的，但可以利用该算法去评价其他算法。B：25%的指令是均匀分布在前地址部分。
C语言实现虚拟存储器页面置换算法
独木春的noteBook
06-06 7536
问题描述： 通过编程模拟实现请求页式存储管理的几种常用页面置换算法，了解虚拟页式存储管理的特点，掌握请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并进行比较。 设计一个虚拟存储区和内存工作区，采用固定分配局部置换策略，并使用下述算法计算采用不同页面置换算法的访问命中率。 1）最佳置换算法（OPT） 2）先进先出的算法（FIFO） 3）最近最久未使用算法（LRU） 4）最不经常使用算法...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值