操作系統 存儲管理實驗報告

實驗要求

實驗目的
存儲管理的主要功能之一是合理地分配空間。請求頁式管理是一種常用的虛擬存儲管理技術。
本實驗的目的是通過請求頁式管理中頁面置換算法模擬設計，瞭解虛擬存儲技術的特點，掌握請求頁式存儲管理的頁面置換算法。
二、實驗內容
（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.
用戶輸入適當淘汰算法的號碼，並按回車，若是第一次選擇，輸出相應的地址頁號流。然後輸出該算法分別計算的用戶內存從2k_{32k時的命中率，若輸入的號碼不再1}4中，則顯示：
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.
用戶輸入適當淘汰算法的號碼，並按回車，若是第一次選擇，輸出相應的地址頁號流。然後輸出該算法分別計算的用戶內存從2k_{32k時的命中率，若輸入的號碼不再1}4中，則顯示：
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)))