操作系统------存储器管理实验

实验要求
（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）

a、终端先显示：Start memory management.Producing address flow, wait for while, please.
b、地址流、地址页号流生成后，终端显示：
There are algorithms in the program
1、Optimization algorithm
2、First in first out algorithm
3、Least recently used algorithm
4、Least frequently used algorithmSelect an algorithm number, please.
用户输入适当淘汰算法的号码，并按回车，若是第一次选择，输出相应的地址页号流。然后输出该算法分别计算的用户内存从4k-32k时的命中率，若输入的号码不再1~4中，则显示：there is not the algorithm in the program,并重复b。
c、输出结果后，终端显示 “do you try again with another algorithm(y/n)”。若键入y则重复b,否则结束。（一般四种算法都用过后结束，以便比较）。

直接附代码：

maxpages = 4
# 列表,访问次序
visit = []
# 当前用户空间的页
pages = []

# 1)最佳置换算法
def OPT(i):
    # 寻找应该置换哪个页面
    # 距离
    distance = i
    # 淘汰
    sift = -1
    for j in pages:
        # 找到下次用最远的那个页，就是距离以后访问最远的页
        if (j in visit[i + 1:32]):
            if (visit.index(j, i + 1, 32) > distance):
                distance = visit.index(j, i + 1, 32)
                sift = j
        else:
            return j
    return sift

#2）先进先出算法（FIFO）；
def FIFO():
    #总是把最先进来的那个页淘汰
    return pages[0]

#3)最近最久未使用算法LRU
def LRU(i):
    #页在列表出现的位置
    distance=-1
    #记录pages中页距离上次使用最远的那个页
    sift = -1
    #倒置找下标最大的那个页
    a=list(reversed(visit[0:i]))
    for j in pages:
        # 找到上次用最远的那个页
        if (a.index(j)> distance):
            distance=a.index(j)
            sift = j
    return sift

# 4）最少使用页面淘汰算法(LFU）
def LFU(i):
    # 使用次数
    num = 32
    # 淘汰哪一个
    sift = -1
    a = visit[0:i]
    for j in pages:
        if (a.count(j) < num):
            num = visit[0:i].count(j)
            sift = j
    return sift

def main():
    print("Start memory management.\nProducing address flow, wait for while, please.")
    for i in range(320):
        # 1）在[0，319]的指令地址之间随机选取一起点m；
        m = np.random.randint(0, 320)
        visit.append(m // 10)
        i = i + 1
        print(m // 10, end=' ')
        # 2）顺序执行一条指令，即执行地址为m + 1的指令；
        visit.append((m + 1) // 10)
        i = i + 1
        print((m + 1) // 10, end=" ")
        # 3）在前地址[0，m + 1]中随机选取一条指令并执行，该指令的地址为m’；
        m = np.random.randint(0, m + 2)
        visit.append(m // 10)
        i = i + 1
        print(m // 10, end=' ')
        # 4）顺序执行一条指令，地址为m’ + 1的指令
        visit.append((m + 1) // 10)
        i = i + 1
        print((m + 1) // 10, end=' ')
        # 5）在后地址[m’ + 2，319]中随机选取一条指令并执行；
        m = np.random.randint(min(m + 2, 319), 320)
        visit.append(m // 10)
        i = i + 1
        print(m // 10, end=' ')
        # 6）重复上述步骤1）~5），直到执行320次指令
        print("\n")

    # 缺页个数
    while(True):
        print("There are algorithms in the program\n\
            1、Optimization algorithm\n\
            2、First in first out algorithm\n\
            3、Least recently used algorithm\n\
            4、Least frequently used algorithm\n\
            Select an algorithm number, please.\n")
        n = input()
        if (n not in{'1','2','3','4'}):
            print("there is not the algorithm in the program")
            continue
        miss=0
        n=int(n)
        find=-1
        pages.clear()
        for i in range(320):
            m = visit[i]  # 当前页
            print("当前访问的页表:", m, "\t", end=' ')
            if (m not in pages):
                # 内存未满
                miss = miss + 1
                print("缺页中断",end='\t')
                if (len(pages) < maxpages):
                    find=-1
                    pages.append(visit[i])
                else:
                    # pages.remove(find1(i))
                    if (n==1):
                        #apply()
                        find=OPT(i)
                    elif(n==2):
                        find=FIFO()
                    elif(n==3):
                        find=LRU(i)
                    elif(n==4):
                        find=LFU(i)
                    pages.remove(find)
                    pages.append(m)
            else:
                find=-1
                print("正常访问",end='\t')
            # 输出pages
            print("更新后的内存中的页表:", "%-20s"%pages,end='  ')
            if(find>=0):
                print("\t淘汰的页为：",find)
            else:
                print()
        print("缺页次数", miss)
        print("缺页率", miss / 320)
        print("do you try again with another algorithm(y/n)")
        s=input()
        if(s=='n'):
            return



main()

运行图片：

转载请写明本网址