精华内容
下载资源
问答
  • 操作系统存储管理实验
    千次阅读
    2020-01-20 09:47:42

    华中农业大学 学生实验报告

    课程名称 计算机操作系统 实验名称 存储管理实验 实验类型 验证 设计
    综合 创新
    【实验目的】
    实验目的:

    1. 通过模拟实现请求页式存储管理的几种基本页面置换算法,了解虚拟存储技术的特点,掌握虚 拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程,并比较它们的效率。
      实验要求:掌握五种存储管理算法
      1)最佳淘汰算法(OPT)
      2)先进先出的算法(FIFO)
      3)最近最久未使用算法(LRU)
      4)最不经常使用算法(LFU)
      5)最近未使用算法(NUR)
    2. 熟悉内存自由空闲队列的分配策略及熟悉内存分区的回收原则及实现过程
      【实验内容】
      设计一个虚拟存储区和内存工作区,并使用下述算法计算访问命中率。
      1)最佳淘汰算法(OPT)
      2)先进先出的算法(FIFO)
      3)最近最久未使用算法(LRU)
      4)最不经常使用算法(LFU)
      5)最近未使用算法(NUR)
      命中率=1-页面失效次数/页地址流长度
      模拟内存的动态分配和回收,并编程实现。
      【实验环境】(含主要设计设备、器材、软件等)
      Pc电脑一台

    【实验步骤、过程】(含原理图、流程图、关键代码,或实验过程中的记录、数据等)
    实验步骤:

    程序说明及实现:
    1.
    先进先出算法:原理是优先淘汰最早进入内存的页面,FIFO 算法是最简单的页面置换算法。FIFO 页面置换算法为每个页面记录了调到内存的时间,即必须置换页面时会选择最旧的页面。“FIFO 算法当进程分配到的页面数增加时,缺页中断的次数可能增加也可能减少”。 FIFO 算法基于队列实现,不是堆栈类算法。注意,并不需要记录调入页面的确切时间,可以创建一个 FIFO 队列,来管理所有的内存页面。置换的是队列的首个页面。当需要调入页面到内存时,就将它加到队列的尾部。FIFO 页面置换算法易于理解和编程。然而,它的性能并不总是十分理想:其一,所置换的页面可以是很久以前使用过但现已不再使用的初始化模块。其二,所置换的页面可以包含一个被大量使用的变量,它早就初始化了,但仍在不断使用。
    2.
    最近最久未被使用算法:即淘汰最近没有使用的页面,选择最近最长时间未访问过的页面予以淘汰,它认为过去一段时间内未访问过的页面,在最近的将来可能也不会被访问。该算法为每个页面设置一个访问字段,来记录页面自上次被访问以来所经历的时间,淘汰页面时选择现有页面中值最大的予以淘汰。
    3.
    最近未使用算法:当某一页首次装入主存时,该帧的使用位设置为1;当该页随后再被访问到时,它的使用位也被置为1。对于页替换算法,用于替换的候选帧集合看做一个循环缓冲区,并且有一个指针与之相关联。当某一页被替换时,该指针被设置成指向缓冲区中的下一帧。当需要替换一页时,操作系统扫描缓冲区,以查找使用位被置为0的一帧。每当遇到一个使用位为1的帧时,操作系统就将该位重新置为0;如果在这个过程开始时,缓冲区中所有帧的使用位均为0,则选择遇到的第一个帧替换;如果所有帧的使用位均为1,则指针在缓冲区中完整地循环一周,把所有使用位都置为0,并且停留在最初的位置上,替换该帧中的页。由于该算法循环地检查各页面的情况,故称为 CLOCK 算法,又称为最近未用( Not Recently Used, NRU )算法。
    4.
    最佳置换算法:当要调入一页而必须淘汰旧页时,应该淘汰以后不再访问的页,或距最长时间后要访问的页面。它所产生的缺页数最少,然而,却需要预测程序的页面引用串,这是无法预知的,不可能对程序的运行过程做出精确的断言,不过此理论算法可用作衡量各种具体算法的标准。
    5.最不经常使用置换算法:最不经常使用(LFU)页面置换算法要求置换具有最小计数的页面。这种选择的原因是,积极使用的页面应当具有大的引用计数。然而,当一个页面在进程的初始阶段大量使用但是随后不再使用时,会出现问题。由于被大量使用,它有一个大的计数,即使不再需要却仍保留在内存中。一种解决方案是,定期地将计数右移 1 位,以形成指数衰减的平均使用计数。

    FF首次适应算法(First Fit):该算法从空闲分区链首开始查找,直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业的大小,从该分区中划出一块内存分配给请求者,余下的空闲分区仍留在空闲分区链中。特点: 该算法倾向于使用内存中低地址部分的空闲区,在高地址部分的空闲区很少被利用,从而保留了高地址部分的大空闲区。显然为以后到达的大作业分配大的内存空间创造了条件。
    最佳适应算法(Best Fit):该算法总是把既能满足要求,又是最小的空闲分区分配给作业。为了加速查找,该算法要求将所有的空闲区按其大小排序后,以递增顺序形成一个空白链。这样每次找到的第一个满足要求的空闲区,必然是最优的。
    最坏适应算法(Worst Fit):最坏适应算法是将输入的作业放置到主存中与它所需大小差距最大的空闲区中。空闲区大小由大到小排序。
    说明:
    本实验的程序设计基本上按照实验内容进行。即首先用 srand( )和 rand( )函数定义和产生指 令序列,然后将指令序列变换成相应的页地址流,并针对不同的算法计算出相应的命中率。
    (1)通过随机数产生一个指令序列,共 320 条指令。指令的地址按下述原则生成:
    A:50%的指令是顺序执行的
    B:25%的指令是均匀分布在前地址部分
    C:25%的指令是均匀分布在后地址部分
    (2)将指令序列变换为页地址流
    设:页面大小为 1K; 用户内存容量 4 页到 32 页; 用户虚存容量为 32K。
    代码截图:
    初始化代码

    结果截图:

    Excel 绘制图像;

    FF,BF,WF代码截图:

    实验结果截图:

    【实验结果或总结】(对实验结果进行相应分析,或总结实验的心得体会,并提出实验的改进意见)

    1. 对代码的理解:FIFO算法是最新进入的页面在尾部,最久进入的在头部,每当发生缺页中断时,就替换掉表头的页面并把新调入的页面加入到链表的末尾(通过改变 busypf_head和 busypf_tail 和 freepf_head实现);LRU 算法是通过比较已经调入内存的页面的时间;选出最早调度内存的算法。(比较time);NUR算法是将页面被访问设置R位,页面被写入M位,比较四种形况,选择出一个情况最容易的进行置换;OPT 算法需要比较已经进入内存的页面哪些最久不会被使用,并将其换出,这是一个理想算法且命中率比较高;最不经常使用的置换算法:算法根据数据的历史访问频率来淘汰数据(比较counter).
    2. 五个算法比较:通过excel表格画图可以看出:显然OPT算法的命中率更高;其他四种算法的命中率较为相似,但从别的参考资料可以看到LRU,NUR 的命中率比其他两个略高。
    3. 首次适应算法(First Fit)特点: 该算法倾向于使用内存中低地址部分的空闲区,在高地址部分的空闲区很少被利用,从而保留了高地址部分的大空闲区。显然为以后到达的大作业分配大的内存空间创造了条件。缺点:低地址部分不断被划分,留下许多难以利用、很小的空闲区,而每次查找又都从低地址部分开始,会增加查找的开销。
      最佳适应算法(Best Fit):孤立地看,该算法似乎是最优的,但事实上并不一定。因为每次分配后剩余的空间一定是最小的,在存储器中将留下许多难以利用的小空闲区。同时每次分配后必须重新排序,这也带来了一定的开销。特点:每次分配给文件的都是最合适该文件大小的分区。缺点:内存中留下许多难以利用的小的空闲区。
      最坏适应算法(Worst Fit)特点:尽可能地利用存储器中大的空闲区。缺点:绝大多数时候都会造成资源的严重浪费甚至是完全无法实现分配。
    4. 通过上述三种适应的算法各有优缺点,在具体的情境中要找到具体的适应算法。
    5. 通过这次的学习懂得了五种页面置换的算法,并作图;有些遗憾的是并没有看到FIFO的抖动现象。懂得了三种动态分区算法,并能够理解各个算法的优缺点。这次的学习过程收获很大。
    更多相关内容
  • 三、实验内容 (1) 通过随机数产生一个指令序列,共320条指令。指令的地址按下述原则生成: 1. 50%的指令是顺序执行的; 2. 25%的指令是均匀分布在前地址部分; 3. 25%的指令是均匀分布在后地址部分; 具体的实施...
  • 操作系统 存储管理实验报告

    万次阅读 多人点赞 2020-06-19 10:05:40
    实验的目的是通过请求页式管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。 二、实验内容 (1) 通过计算不同算法的命中率比较算法的优劣。同时也考虑了用户内存容量对...

    实验要求

    实验目的
    存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。
    本实验的目的是通过请求页式管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。
    二、实验内容
    (1) 通过计算不同算法的命中率比较算法的优劣。同时也考虑了用户内存容量对命中率的影响。
    页面失效次数为每次访问相应指令时,该指令所对应的页不在内存中的次数。
    在本实验中,假定页面大小为1k,用户虚存容量为32k,用户内存容量为4页到32页。
    (2) produce_addstream通过随机数产生一个指令序列,共320条指令。
    A、 指令的地址按下述原则生成:
    1) 50%的指令是顺序执行的
    2) 25%的指令是均匀分布在前地址部分
    3) 25%的指令是均匀分布在后地址部分
    B、 具体的实施方法是:
    1) 在[0,319]的指令地址之间随机选取一起点m;
    2) 顺序执行一条指令,即执行地址为m+1的指令;
    3) 在前地址[0,m+1]中随机选取一条指令并执行,该指令的地址为m’;
    4) 顺序执行一条指令,地址为m’+1的指令
    5) 在后地址[m’+2,319]中随机选取一条指令并执行;
    6) 重复上述步骤1)~5),直到执行320次指令
    C、 将指令序列变换称为页地址流
    在用户虚存中,按每k存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:
    第0条~第9条指令为第0页(对应虚存地址为[0,9]);
    第10条~第19条指令为第1页(对应虚存地址为[10,19]);
    。。。。。。
    第310条~第319条指令为第31页(对应虚存地址为[310,319]);
    按以上方式,用户指令可组成32页。
    (3) 计算并输出下属算法在不同内存容量下的命中率。
    1) 先进先出的算法(FIFO);
    2) 最近最少使用算法(LRU);
    在这里插入图片描述
    四、运行结果
    运行程序:
    a、 终端先显示:
    Start memory management.
    Producing address flow, wait for while, please.
    b、 地址流、地址页号流生成后,终端显示:
    There are algorithms in the program
    1、 Optimization algorithm
    2、 Least recently used algorithm
    3、 First in first out algorithm
    4、 Least frequently used algorithm
    Select an algorithm number, please.
    用户输入适当淘汰算法的号码,并按回车,若是第一次选择,输出相应的地址页号流。然后输出该算法分别计算的用户内存从2k32k时的命中率,若输入的号码不再14中,则显示:
    there is not the algorithm in the program,并重复b。
    c、 输出结果后,终端显示 “do you try again with anther algorithm(y/n)”。若键入y则重复b,否则结束。(一般讲四种算法都用过后结束,以便比较)。
    五、运行结果讨论
    1、 比较各种算法的命中率
    2、 分析当用户内存容量增加是对命中率的影响

    实验报告

    1.实验目的

    存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。

    本实验的目的是通过请求页式管理中页面置换算法模拟设计,了解虚拟存储技术的特点,掌握请求页式存储管理的页面置换算法。

    2.实验内容与要求

    ①实验内容
    (1) 通过计算不同算法的命中率比较算法的优劣。同时也考虑了用户内存容量对命中率的影响。

    页面失效次数为每次访问相应指令时,该指令所对应的页不在内存中的次数。

    在本实验中,假定页面大小为1k,用户虚存容量为32k,用户内存容量为4页到32页。

    (2) produce_addstream通过随机数产生一个指令序列,共320条指令。
    A、 指令的地址按下述原则生成:
    1) 50%的指令是顺序执行的
    2) 25%的指令是均匀分布在前地址部分
    3) 25%的指令是均匀分布在后地址部分

    B、 具体的实施方法是:
    1) 在[0,319]的指令地址之间随机选取一起点m;
    2) 顺序执行一条指令,即执行地址为m+1的指令;
    3) 在前地址[0,m+1]中随机选取一条指令并执行,该指令的地址为m’;
    4) 顺序执行一条指令,地址为m’+1的指令
    5) 在后地址[m’+2,319]中随机选取一条指令并执行;
    6) 重复上述步骤1)~5),直到执行320次指令

    C、 将指令序列变换称为页地址流
    在用户虚存中,按每k存放10条指令排列虚存地址,即320条指令在虚存中的存放方式为:
    第0条~第9条指令为第0页(对应虚存地址为[0,9]);
    第10条~第19条指令为第1页(对应虚存地址为[10,19]);
    。。。。。。
    第310条~第319条指令为第31页(对应虚存地址为[310,319]);
    按以上方式,用户指令可组成32页。

    (3) 计算并输出下属算法在不同内存容量下的命中率。
    1) 先进先出的算法(FIFO);
    2) 最近最少使用算法(LRU);

    ②实验要求
    运行程序:
    a、 终端先显示:
    Start memory management.
    Producing address flow, wait for while, please.

    b、 地址流、地址页号流生成后,终端显示:
    There are algorithms in the program
    1、 Optimization algorithm
    2、 Least recently used algorithm
    3、 First in first out algorithm
    4、 Least frequently used algorithm
    Select an algorithm number, please.
    用户输入适当淘汰算法的号码,并按回车,若是第一次选择,输出相应的地址页号流。然后输出该算法分别计算的用户内存从2k32k时的命中率,若输入的号码不再14中,则显示:
    there is not the algorithm in the program,并重复b。

    c、 输出结果后,终端显示 “do you try again with anther algorithm(y/n)”。若键入y则重复b,否则结束。(一般讲四种算法都用过后结束,以便比较)。法

    3.流程图与模块调用

    在这里插入图片描述

    4.实验分析

    想要完成操作系统算法,首先要弄清楚操作系统相关的专业术语。弄清各个算法的流程和目的要求。才能模拟出相关算法的过程。
    在我的理解中,
    为什么要进行页面置换?

    在请求分页存储管理系统中,由于使用了虚拟存储管理技术,使得所有的进程页面不是一次性地全部调入内存,而是部分页面装入。

    这就有可能出现下面的情况:要访问的页面不在内存,这时系统产生缺页中断。操作系统在处理缺页中断时,要把所需页面从外存调入到内存中。如果这时内存中有空闲块,就可以直接调入该页面;如果这时内存中没有空闲块,就必须先淘汰一个已经在内存中的页面,腾出空间,再把所需的页面装入,即进行页面置换。

    先进先出法(FIFO)
    算法描述:由于认为最早调入内存的页不再被使用的可能性要大于刚调入内存的页,因此,先进先出法总是淘汰在内存中停留时间最长的一页,即先进入内存的页,先被换出。先进先出法把一个进程所有在内存中的页按进入内存的次序排队,淘汰页面总是在队首进行。如果一个页面刚被放入内存,就把它插在队尾。

    最近最少使用置换法(LRU)
    算法描述:最近最少使用置换法(LRU)是选择在最近一段时间里最久没有使用过的页面予以淘汰。借鉴FIFO算法和OPT算法,以“最近的过去”作为“不久将来”的近似。

    5.运行情况

    ①程序正常运行测试:
    在这里插入图片描述
    在这里插入图片描述
    ② 比较各种算法的命中率、分析当用户内存容量增加是对命中率的影响:
    利用如下语句,可以直观对比区别:

    for i in range(2,33):
        print('memory={} FIFO/LRU命中率:{} / {}'.format(i,FIFO(i),LRU(i)))
    

    在这里插入图片描述
    由上图可以直观看出:
    ①当用户内存容量增加对命中率会相应增加;
    ②对于FIFO与LRU两种算法,在内存容量为20左右时,命中率差不多;
    在内存容量小于20时,FIFO算法命中率更高;
    在内存容量大于20时,LRU算法命中率更高;

    6.实验体会

    通过本次实验,我深刻的理解了操作系统中资源的分配方式和存储管理的调度方式。操作系统实验重在理解每一个算法的意图和目的,那么就选择适当的数据结构模拟过程就可以完成相关算法了。

    对于FIFO算法,这个算法原理简单,就是先进先出。对于这个结构最好采用的就算队列了,对于python而言,我用的是list集合,每次添加数据的时候添加到第0位置(list的insert(0,num)),而如果移除的时候移除末尾的页数(list的pop())。在这个过程中,每执行一条指令的时候,如果这个指令对应的地址(指令/10)在list中,那么就命中,否则就是缺页,需要移除尾,在0位置添加元素。

    对于LRU算法,这个算法跟FIFO其实还是挺像的,但是有一点区别,最近最少使用。也就是说在一个正常序列的时候如果命中的话,就会把这个地址的页号移动到首位(或者链表首位)。而如果缺页的时候,要把这个链表的末尾位置移除,因为末尾的元素是最近用的最少的(很久前才有的)。对于数据结构,依然选择list。其实这个是典型的堆栈的数据结构,利用python的list的pop()和append()就可以完美完成。

    本次实验采用python完成,IDE是pycharm,python的列表list的insert()、pop()、append()方法可以把列表很好的模拟成堆栈或者队列,这些在算法的编写过程中否起到了很大的作用。

    【附】实验代码

    import random
    
    num = [0 for i in range(0, 325)]  # 生成随机数会有溢出,所以数组长度设置大一点
    page = [0 for i in range(0, 320)]
    
    
    # 按照题目的算法生成随机数
    def createRandomNum():
        i = 0
        while i < 320:
            m = random.randint(0, 318)
            num[i] = m + 1  # 顺序执行了一条指令
            m1 = random.randint(0, m + 1)
            i += 1
            num[i] = m1  # 在[0,m+1]之间执行了一条指令
            i += 1
            num[i] = m1 + 1  # 顺序执行了一条指令
            if m1 < 317:
                m2 = random.randint(m1 + 2, 319)
                i += 1
                num[i] = m2  # 在[m1+2,319]之间执行了一条指令
    
        print('**********生成320个随机数**********')
        str = ''
        for index, i in enumerate(num):
            if index < 320:
                str += '{}\t'.format(i)
                if (index + 1) % 20 == 0:
                    str += '\n'
        print(str)
    
    
    # 将指令序列变换称为页地址流
    def changeAsPage():
        for index, i in enumerate(num):
            if index < 320:
                page[index] = int(i / 10)
        print('**********转化为320个页码数**********')
        str = ''
        for index, i in enumerate(page):
            str += '{}\t'.format(i)
            if (index + 1) % 20 == 0:
                str += '\n'
        print(str)
    
    # 先进先出法
    def FIFO(msize):
        Q = []  # 定义队列
        queYeTimes = 0  # 缺页次数
        for item in page:
            if len(Q) < msize:
                Q.insert(0, item)  # 压入队列
            elif item in Q:
                Q.remove(item)
            else:
                Q.pop()
                Q.insert(0, item)
                queYeTimes += 1
        return (1-queYeTimes/320)
    
    # 最近最少使用置换法
    def LRU(msize):
        L = []  # 定义堆栈
        queYeTimes = 0  # 缺页次数
        for item in page:
            if item in L:
                [L[0],L[len(L)-1]]=[L[len(L)-1],L[0]]
            elif len(L)<msize:
                L.append(item)
            else:
                L.append(item)
                del L[0]
                queYeTimes+=1
        return (1 - queYeTimes / 320)
    
    
    print('Start memory management.\nProducing address flow, wait for while, please.\n')
    print('There are algorithms in the program\n1、	Optimization algorithm\n2、	Least recently used algorithm\n3、	First in first out algorithm\n4、	Least frequently used algorithm\nSelect an algorithm number, please.')
    key = int(input())
    createRandomNum()
    changeAsPage()
    
    i=2
    while i<33:
        if key==2:
            print('memory={} LRU命中率:{}'.format(i,LRU(i)))
            flag = input('do you try again with anther algorithm(y / n):')
            if flag=='y':
                key = int(input('input the num:'))
                i+=1
            else:
                break
        elif key == 3:
            print('memory={} FIFO命中率:{}'.format(i,FIFO(i)))
            flag = input('do you try again with anther algorithm(y / n):')
            if flag == 'y':
                key = int(input('input the num:'))
                i += 1
            else:
                break
    
    # for i in range(2,33):
    #     print('memory={} FIFO/LRU命中率:{} / {}'.format(i,FIFO(i),LRU(i)))
    
    
    展开全文
  • 操作系统实验报告
  • 操作系统实验报告 实验序号 7 实验项目名称 Linux 存储管理操作实践 学 号 姓 名 专业班 实验地点 指导教师 实验时间 一实验目的及要求 通过本实验的学习使学生掌握 Linux 存储管理相关操作的基本方法 以学生自主...
  • 操作系统内存管理实验(C语言实现)
  • 实验四操作系统存储管理实验报告 一 实验目的 存储管理的主要功能之一是合理地分配空间请求页式管理是一种常用的虚拟存储管 理技术 本实验的目的是通过请求页式管理中页面置换算法模拟设计了解虚拟存储技术的特 点...
  • 这是我自己写的操作系统储存管理算法的实验报告,希望可以帮助到你。。。
  • 操作系统实验五--存储管理

    千次阅读 2021-12-21 17:43:30
    文章目录操作系统实验五--存储管理一、实验目的二、实验内容三、设计原理及相关算法四、结果分析五、源代码 操作系统实验五–存储管理 一、实验目的 1、了解虚拟存储技术的特点,掌握请求页式存储管理的主要页面置换...

    操作系统实验五–存储管理

    一、实验目的

    1、了解虚拟存储技术的特点,掌握请求页式存储管理的主要页面置换算法原理。

    2、掌握请求页式存储管理中页面置换算法的模拟设计方法。

    二、实验内容

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

    ①先进先出的算法(FIFO);

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

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

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

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

    (其中③④为选择内容)

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

    三、设计原理及相关算法

    1、通过随机数产生一个指令序列,共320条指令。指令的地址按下述原则生成:

    ​ ①50%的指令是顺序执行的;

    ​ ②25%的指令是均匀分布在前地址部分;

    ​ ③25%的指令是均匀分布在后地址部分。

    ​ 具体的实施方法是:

    ​ ①在[1,319]指令地址之间随机选取一起点m;

    ​ ②顺序执行一条指令,即执行地址为m十1的指令;

    ​ ③在前地址[0,m十1]中随机选取一条指令并执行,该指令的地址为 m’;

    ​ ④顺序执行一条指令,其地址为m‘+1;

    ​ ⑤在后地址[m’+2,319]中随机选取一条指令并执行;

    ​ ③重复上述步骤①~⑤,直到执行320次指令。

    2、将指令序列变换成为页地址流

     设:①页面大小为IK;
    

    ​ ②用户内存容量为4页到32页;

    ​ ③用户虚存容量为32K。

     在用户虚存中,按每K存放10条指令排列虚存地址,即320条指令在虚存中的存放方
    

    式为:

    第0条~第9条指令为第0页(对应虚存地址为[0,9]);

    第10条~第19条指令为第1页(对应虚存地址为[10,19]);

    第 310条~第 319条指令为第 31页(对应虚存地址为[310,319])。

    按以上方式,用户指令可组成32页。

    四、结果分析

    image-20211221174054132

    五、源代码

    //1.存储管理。
    #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;      //页号 logic number
    	int pfn;     //页面框架号 physical frame number
    	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;
     
     
    pfc_type pfc[total_vp], *freepf_head, *busypf_head, *busypf_tail;
     
    int diseffect,  a[total_instruction]; /* a[]为指令序列*/
     
    int page[total_instruction],  offset[total_instruction];/*地址信息*/
     
    int  initialize(int);
    int  FIFO(int);
    int  LRU(int);
    int  LFU(int);
    int  NUR(int); //not use recently
    int  OPT(int);
     
    int main( )
    {
    	int s,i,j;
     
    	srand(10*getpid());                    /*由于每次运行时进程号不同,故可用来作为初始化随机数队列的“种子”*/
     
    	s=(float)319*rand( )/32767/32767/2+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/32767/2; /*执行前地址指令m*/
    		a[i+3]=a[i+2]+1;                          /*顺序执行一条指令*/
     
    		s=(float)(318-a[i+2])*rand( )/32767/32767/2+a[i+2]+2;
    		if((a[i+2]>318)||(s>319))
     
    			printf("a[%d+2],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;
    	}
    	for(i=4;i<=32;i++)   /*用户内存工作区从4个页面到32个页面*/
    	{
    		printf("--%2d page frames   ",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,j;
    	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; /*使busy的尾为null*/
    			if(busypf_tail==NULL)
    			{
    				busypf_tail=busypf_head=freepf_head;
    			}
    			else
    			{
    				busypf_tail->next=freepf_head;
    				busypf_tail=freepf_head;
    			}
    			freepf_head=p;
    		}
    	}
    	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;
    }	
    
    
    展开全文
  • 操作系统实验存储管理

    千次阅读 2021-12-16 15:38:32
    操作系统实验存储管理 所有实验源码: gitee:https://gitee.com/infiniteStars/os-project github:https://github.com/helloworldzsq/OSproject 1.实验内容 设计一个虚拟存储区和内存工作区,并使用下述方法...

    操作系统实验—存储管理

    所有实验源码:

    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;
    }
    
    展开全文
  • 实验四 操作系统存储管理实验报告
  • 操作系统存储管理实验报告
  • 输入进程数,创建随机进程,按照从0开始的时间量,根据到达时刻和所需空间,计算工作分区表和空闲分区表,直到所有进程完成为止。
  • 操作系统存储管理实验报告.pdf
  • 随机给出一个页面执行序列,如:1,5,3,4,2,1,3,4,5,7,9,……。要求计算以下几种置换算法的缺页数、缺页率和命中率。  最佳置换算法OPT(Optimal)  先进先出算法FIFO...实验报告(含流程图及运行结果)&源代码
  • 计算机操作系统储存管理实验报告.pdf
  • 操作系统存储管理实验报告重点.pdf
  • 操作系统存储管理实验报告讲学.pdf
  • 学习操作系统存储管理实验报告.pdf
  • 操作系统存储管理实验课程设计报告

    万次阅读 多人点赞 2016-05-24 18:47:07
    操作系统报告 存储管理 姓名: 郑兆涵  专业: 计算机科学与技术(嵌入式方向) 一、设计目的、意义 本次实验针对:(1)存储管理实验,(2)主存储器空间的分配和回收实验,两个实验进行学习。 (1)存储...
  • 操作系统存储管理实验报告知识点.pdf
  • 设计一个可变式分区分配的存储管理方案。并模拟实现分区的分配和回收过程。 对分区的管理法可以是下面三种算法之一: 首次适应算法 循环首次适应算法 最佳适应算法
  • 河南师范大学计算机与信息技术学院实验报告 实验 五 存储 管理实验目的 1 加深对操作系统存储管理的理解 2 能过模似页面调试算法加深理解操作系统对内存的高度管理 二总的设计思想环境语言工具等总的设计思想 1...
  • 河南师范大学计算机与信息技术学院实验报告 实验五 存储管理实验目的 1 加深对操作系统存储管理的理解 2 能过模似页面调试算法加深理解操作系统对内存的高度管理 总的设计思想环境语言工具等总的设计思想 1编写...
  • 熟悉主存的分配与回收 理解在不同的存储管理方式下如何实现主存空间的分配与回收 掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理 方式及其实现过程 实验原理 建立两张表空闲表和已分配表分别将未...
  • 教育精品资料
  • 操作系统实验(进程调度+存储管理+磁盘调度++银行家算法+文件系统设计)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 116,061
精华内容 46,424
热门标签
关键字:

操作系统存储管理实验