操作系统存储器管理实验

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)最佳置换算法(OPT);
2)先进先出算法(FIFO);
3)最近最久未使用页面置换(LRU);
4)最少使用页面淘汰算法(LFU)

3. 流程图与模块调用

在这里插入图片描述

4. 实验分析

(1)创建指令集

def progress():
    set = []
    m = np.random.randint(0, 319)       #生成320条指令
    for i in range(80):                 #2 条是顺序执行,1 条是前地址部分,1 条是后地址部分
        set.append(m+1) 
        n = np.random.randint(0, m+1)
        set.append(n)   
        set.append(n+1) 
        m = np.random.randint(n+2, 319)
        set.append(m)   
    return set

(2)FIFO

def FIFO(n, ins):
    u_set = []
    hit = 0
    for i in ins:
        if i // 10 in u_set:
            hit += 1
        else:
            if len(u_set) == n:     #使用 pop(0) 和 append 来实现移出内存和进入内存的操作
                u_set.pop(0)
            u_set.append(i // 10)

    return hit / len(ins)

(3)OPT

def OPT(n, ins):
    hit = 0
    u_set = []            #使用字典来保存下一个指令的位置
    dic = dict.fromkeys(range(32), [])
        for (ind, i) in enumerate(ins):
               dic[i // 10] = dic[i // 10] + [ind]

    for (ind, i) in enumerate(ins):
        dic[i // 10].pop(0)
        if (i // 10) in u_set:
            hit += 1
        else:
            if len(u_set) == n:
                temp = [321] * n
                for (index, page) in enumerate(u_set):
                    if len(dic[page]) > 0:
                        temp[index] = dic[page][0]
                u_set.pop(np.argmax(temp))
            u_set.append(i // 10)
    return hit / len(ins)

(4)LRU

def LRU(n, ins):
    u_set = []
    hit = 0
    for i in ins:         #当访问内存中已经存在的页面时,将该页面放在最后面
        if i // 10 in u_set:
            hit += 1
            temp = u_set.pop(u_set.index(i//10))
            u_set.append(temp)
        else:
            if len(u_set) == n:
                u_set.pop(0)
            u_set.append(i//10)

    return hit / len(ins)

(5)LFU

def LFU(n, ins):
    u_set = []
    hit = 0          #采用的是访问的早晚来判断一个页面再次被访问的可能
    for (ind, i) in enumerate(ins):
        if i // 10 in u_set:
            hit += 1
        else:
            if len(u_set) == n:
                temp = [0] * n
                for item in ins[max(0, ind - 20):ind]:
                    for k in range(n):
                        if u_set[k] == item // 10:
                            temp[k] += 1
                            break
                u_set.pop(np.argmin(temp))
            u_set.append(i // 10)

    return hit / len(ins)

5. 总代码

import numpy as np
import matplotlib.pyplot as plt
#coding:utf-8

def progress():
    set = []
    m = np.random.randint(0, 319)

    for i in range(80):
        set.append(m+1)
        n = np.random.randint(0, m+1)
        set.append(n)
        set.append(n+1)
        m = np.random.randint(n+2, 319)
        set.append(m)

    return set

def FIFO(n, ins):
    u_set = []
    hit = 0
    for i in ins:
        if i // 10 in u_set:
            hit += 1
        else:
            if len(u_set) == n:
                u_set.pop(0)
            u_set.append(i // 10)

    return hit / len(ins)


def OPT(n, ins):
    hit = 0
    u_set = []
    dic = dict.fromkeys(range(32), [])
    for (ind, i) in enumerate(ins):
        dic[i // 10] = dic[i // 10] + [ind]

    for (ind, i) in enumerate(ins):
        dic[i // 10].pop(0)
        if (i // 10) in u_set:
            hit += 1
        else:
            if len(u_set) == n:
                temp = [321] * n
                for (index, page) in enumerate(u_set):
                    if len(dic[page]) > 0:
                        temp[index] = dic[page][0]
                u_set.pop(np.argmax(temp))
            u_set.append(i // 10)
    return hit / len(ins)

def LRU(n, ins):
    u_set = []
    hit = 0
    for i in ins:
        if i // 10 in u_set:
            hit += 1
            temp = u_set.pop(u_set.index(i//10))
            u_set.append(temp)
        else:
            if len(u_set) == n:
                u_set.pop(0)
            u_set.append(i//10)

    return hit / len(ins)


def LFU(n, ins):
    u_set = []
    hit = 0
    for (ind, i) in enumerate(ins):
        if i // 10 in u_set:
            hit += 1
        else:
            if len(u_set) == n:
                temp = [0] * n
                for item in ins[max(0, ind - 20):ind]:
                    for k in range(n):
                        if u_set[k] == item // 10:
                            temp[k] += 1
                            break
                u_set.pop(np.argmin(temp))
            u_set.append(i // 10)

    return hit / len(ins)

def main():
    print("Start memory management.")
    print("Producing address flow, wait for while, please.")
    ins = progress()

    result = np.zeros([4, 29])
    x = np.arange(4, 33)
    for i in x:
        result[0, i-4] = OPT(i, ins)
        result[1, i-4] = FIFO(i, ins)
        result[2, i-4] = LRU(i, ins)
        result[3, i-4] = LFU(i, ins)

    print("There are algorithms in the program")
    print("\t1、Optimization algorithm")
    print("\t2、First in first out algorithm")
    print("\t3、Least recently used algorithm")
    print("\t4、Least frequently used algorithm")

    Select=True
    plt.figure(figsize=(8, 4))
    while(Select):
        num=int(input("\tSelect an algorithm number, please\n\t<<<"))
        if num==1:
            plt.plot(x, result[0], label="OPT")
            plt.legend()
            plt.show()
        elif num==2:
            plt.plot(x, result[1], label="FIFO")
            plt.legend()
            plt.show()
        elif num==3:
            plt.plot(x, result[2], label="LRU")
            plt.legend()
            plt.show()
        elif num==4:
            plt.plot(x, result[3], label="LFU")
            plt.legend()
            plt.show()
        else:
            print("there is not the algorithm in the program.\n")
        ch=input("do you try again with another algorithm(y/n)\n\t<<<")
        if(ch=='y'):
            Select=True
        else:
            Select==False
            break

    plt.figure(figsize=(8, 4))
    plt.plot(x, result[0], label="OPT")
    plt.plot(x, result[1], label="FIFO")
    plt.plot(x, result[2], label="LRU")
    plt.plot(x, result[3], label="LFU")
    plt.legend()
    plt.show()
    return

if __name__ == '__main__':
    main()

6. 运行情况

(1)操作终端
在这里插入图片描述
(2)OPT
在这里插入图片描述
(3)FIFO
在这里插入图片描述
(4)LRU
在这里插入图片描述
(5)LFU
在这里插入图片描述
(6)对比图
在这里插入图片描述

  • 0
    点赞
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
存储器管理操作系统中的一个重要组成部分,它主要负责管理计算机的内存资源,包括内存分配和回收、内存保护、虚拟内存管理等。下面介绍一下操作系统实验中的存储器管理。 1. 内存分配和回收 内存分配是将一定大小的内存块分配给进程使用,而内存回收则是将进程不再使用的内存块释放出来,以便其他进程使用。在实现内存分配和回收时,可以采用多种算法,比如首次适应算法、最佳适应算法、最坏适应算法等。这些算法的实现过程可以通过链表或位图来完成。 2. 内存保护 内存保护是指防止进程越界访问内存区域,从而导致系统崩溃或数据损坏。在操作系统中,可以通过硬件和软件两种方式来实现内存保护。硬件保护通常通过内存管理单元(MMU)来实现,而软件保护则通过访问权限控制和地址空间隔离来实现。 3. 虚拟内存管理 虚拟内存管理是操作系统中的一个重要功能,它可以将进程的虚拟地址空间映射到物理内存中,从而使得进程可以访问超过实际物理内存大小的数据。在实现虚拟内存管理时,需要采用一些算法来完成页面置换和页面调度等操作,比如最近最少使用算法(LRU)。 总之,存储器管理操作系统中重要的组成部分,对于系统的稳定性和性能有着重要的影响。在操作系统实验中,可以通过实现内存分配和回收、内存保护、虚拟内存管理等功能,来加深对操作系统存储器管理的理解。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

啊噗呲咔

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

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

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

打赏作者

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

抵扣说明:

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

余额充值