當前位置:首頁 » 操作系統 » 頁面置換演算法實現

頁面置換演算法實現

發布時間: 2023-06-30 00:42:42

⑴ 先進先出頁面置換演算法的實現過程

假定系統為某進程分配了三個物理塊,並考慮有以下頁面號引用串:7, 0, 1, 2, 0, 3, 0,4,2,3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1。釆用FIFO演算法進行頁面置換,進程訪問頁面2時,把最早進入內存的頁面7換出。然後訪問頁面3時,再把2, 0, 1中最先進入內存的頁換出。由下圖可以看出,利用FIFO演算法時進行了12次頁面置換。 訪問頁面70120304230321201701物理塊1777222444000777物理塊200033322211100物理塊31110003332221缺頁否√√√√√√√√√√√√√√√

⑵ 頁面置換演算法的實驗

#include <stdio.h>
#define PROCESS_NAME_LEN 32 /*進程名稱的最大長度*/
#define MIN_SLICE 10 /*最小碎片的大小*/
#define DEFAULT_MEM_SIZE 1024 /*默認內存的大小*/
#define DEFAULT_MEM_START 0 /*默認內存的起始位置*/

/* 內存分配演算法 */
#define MA_FF 1
#define MA_BF 2
#define MA_WF 3

int mem_size=DEFAULT_MEM_SIZE; /*內存大小*/
int ma_algorithm = MA_FF; /*當前分配演算法*/
static int pid = 0; /*初始pid*/
int flag = 0; /*設置內存大小標志*/

struct free_block_type
{
int size;
int start_addr;
struct free_block_type *next;
};
struct free_block_type *free_block;

struct allocated_block
{
int pid;
int size;
int start_addr;
char process_name[PROCESS_NAME_LEN];
struct allocated_block *next;
};
struct allocated_block *allocated_block_head;

/*初始化空閑塊,默認為一塊,可以指定大小及起始地址*/
struct free_block_type* init_free_block(int mem_size)
{

struct free_block_type *fb;

fb=(struct free_block_type *)malloc(sizeof(struct free_block_type));
if(fb==NULL)
{
printf("No mem\n");
return NULL;
}
fb->size = mem_size;
fb->start_addr = DEFAULT_MEM_START;
fb->next = NULL;
return fb;
}

void display_menu()
{
printf("\n");
printf("1 - Set memory size (default=%d)\n", DEFAULT_MEM_SIZE);
printf("2 - Select memory allocation algorithm\n");
printf("3 - New process \n");
printf("4 - Terminate a process \n");
printf("5 - Display memory usage \n");
printf("0 - Exit\n");
}

/*設置內存的大小*/
int set_mem_size()
{
int size;
if(flag!=0)
{ /*防止重復設置*/
printf("Cannot set memory size again\n");
return 0;
}
printf("Total memory size =");
scanf("%d", &size);
if(size>0)
{
mem_size = size;
free_block->size = mem_size;
}
flag=1;
return 1;
}
/*Best-fit使用最小的能夠放下將要存放數據的塊,First-first使用第一個能夠放下將要存放數據的塊,Worst-fit使用最大的能夠放下將要存放數據的塊。*/
/* 設置當前的分配演算法 */
/*分區分配演算法(Partitioning Placement Algorithm)
*/
void set_algorithm()
{
int algorithm;
printf("\t1 - First Fit\n");/*首次適應演算法(FF):。 */
printf("\t2 - Best Fit\n");/*最佳適應演算法(BF): */

printf("\t3 - Worst Fit\n");
scanf("%d", &algorithm);
if(algorithm>=1 && algorithm <=3) ma_algorithm=algorithm;
/*按指定演算法重新排列空閑區鏈表*/
rearrange(ma_algorithm);
}

void swap(int* data_1,int* data_2)
{
int temp;
temp=*data_1;
*data_1=*data_2;
*data_2=temp;
}

void rearrange_FF()
{
struct free_block_type *tmp, *work;
printf("Rearrange free blocks for FF \n");
tmp = free_block;
while(tmp!=NULL)
{
work = tmp->next;
while(work!=NULL)
{
if( work->start_addr < tmp->start_addr)
{ /*地址遞增*/
swap(&work->start_addr, &tmp->start_addr);
swap(&work->size, &tmp->size);
}
else
{
work=work->next;
}
}
tmp=tmp->next;
}
}
/*按BF演算法重新整理內存空閑塊鏈表(未完成)
void rearrange_BF()
{
struct free_block_type *tmp,*work;
printf("Rearrange free blocks for BF\n");
tmp=free_block;
while(tmp!=NULL)
{
work=tmp->next;
while(work!=NULL)
{

}
}

}

*/
/*按WF演算法重新整理內存空閑塊鏈表(未完成)
void rearrange_WF()
{
struct free_block_type *tmp,*work;
printf("Rearrange free blocks for WF \n");
tmp=free_block;
while(tmp!=NULL)
{
work=tmp->next;
while(work!=NULL)
{

}
}
}
*/

/*按指定的演算法整理內存空閑塊鏈表*/
int rearrange(int algorithm)
{
switch(algorithm)
{
case MA_FF: rearrange_FF(); break;
/*case MA_BF: rearrange_BF(); break; */
/*case MA_WF: rearrange_WF(); break; */
}
}

/*創建新的進程,主要是獲取內存的申請數量*/
int new_process()
{
struct allocated_block *ab;
int size;
int ret;
ab=(struct allocated_block *)malloc(sizeof(struct allocated_block));
if(!ab)
exit(-5);
ab->next = NULL;
pid++;
sprintf(ab->process_name, "PROCESS-%02d", pid);
ab->pid = pid;

printf("Memory for %s:", ab->process_name);
scanf("%d", &size);
if(size>0) ab->size=size;
ret = allocate_mem(ab); /* 從空閑區分配內存,ret==1表示分配ok*/
/*如果此時allocated_block_head尚未賦值,則賦值*/
if((ret==1) &&(allocated_block_head == NULL))
{
allocated_block_head=ab;
return 1;
}
/*分配成功,將該已分配塊的描述插入已分配鏈表*/
else if (ret==1)
{
ab->next=allocated_block_head;
allocated_block_head=ab;
return 2;
}
else if(ret==-1)
{ /*分配不成功*/
printf("Allocation fail\n");
free(ab);
return -1;
}
return 3;
}

/*分配內存模塊*/
int allocate_mem(struct allocated_block *ab)
{
struct free_block_type *fbt,*pre,*r;
int request_size=ab->size;
fbt=pre=free_block;
while(fbt!=NULL)
{
if(fbt->size>=request_size)
{
if(fbt->size-request_size>=MIN_SLICE)
{
fbt->size=fbt->size-request_size;
}
/*分配後空閑空間足夠大,則分割*/

else
{
r=fbt;
pre->next=fbt->next;
free(r);
/*分割後空閑區成為小碎片,一起分配*/

return 1;
}
}
pre = fbt;
fbt = fbt->next;
}

return -1;
}

/*將ab所表示的已分配區歸還,並進行可能的合並*/
int free_mem(struct allocated_block *ab)
{
int algorithm = ma_algorithm;
struct free_block_type *fbt, *pre, *work;

fbt=(struct free_block_type*) malloc(sizeof(struct free_block_type));
if(!fbt)
return -1;
fbt->size = ab->size;
fbt->start_addr = ab->start_addr;
/*插入到空閑區鏈表的頭部並將空閑區按地址遞增的次序排列*/
fbt->next = free_block;
free_block=fbt;
rearrange(MA_FF);
fbt=free_block;
while(fbt!=NULL)
{
work = fbt->next;
if(work!=NULL)
{
/*如果當前空閑區與後面的空閑區相連,則合並*/
if(fbt->start_addr+fbt->size == work->start_addr)
{
fbt->size += work->size;
fbt->next = work->next;
free(work);
continue;
}
}
fbt = fbt->next;
}
rearrange(algorithm); /*重新按當前的演算法排列空閑區*/
return 1;
}

/*?釋放ab數據結構節點*/
int dispose(struct allocated_block *free_ab)
{
struct allocated_block *pre, *ab;

if(free_ab == allocated_block_head)
{ /*如果要釋放第一個節點*/
allocated_block_head = allocated_block_head->next;
free(free_ab);
return 1;
}
pre = allocated_block_head;
ab = allocated_block_head->next;

while(ab!=free_ab)
{
pre = ab;
ab = ab->next;
}
pre->next = ab->next;
free(ab);
return 2;
}
/*查找要刪除的進程*/
struct allocated_block* find_process(int pid)
{
struct allocated_block *temp;
temp=allocated_block_head;
while(temp!=NULL)
{
if(temp->pid==pid)
{
return temp;
}
temp=temp->next;
}
}

/*刪除進程,歸還分配的存儲空間,並刪除描述該進程內存分配的節點*/
void kill_process()
{
struct allocated_block *ab;
int pid;
printf("Kill Process, pid=");
scanf("%d", &pid);
ab=find_process(pid);
if(ab!=NULL)
{
free_mem(ab); /*釋放ab所表示的分配區*/
dispose(ab); /*釋放ab數據結構節點*/

}
}

/* 顯示當前內存的使用情況,包括空閑區的情況和已經分配的情況 */

int display_mem_usage()
{
struct free_block_type *fbt=free_block;
struct allocated_block *ab=allocated_block_head;
if(fbt==NULL) return(-1);
printf("----------------------------------------------------------\n");

/* 顯示空閑區 */
printf("Free Memory:\n");
printf("%20s %20s\n", " start_addr", " size");
while(fbt!=NULL)
{
printf("%20d %20d\n", fbt->start_addr, fbt->size);
fbt=fbt->next;
}
/* 顯示已分配區 */
printf("\nUsed Memory:\n");
printf("%10s %20s %10s %10s\n", "PID", "ProcessName", "start_addr", " size");
while(ab!=NULL)
{
printf("%10d %20s %10d %10d\n", ab->pid, ab->process_name, ab->start_addr, ab->size);
ab=ab->next;
}
printf("----------------------------------------------------------\n");
return 0;
}

**********************************************************************
樓主啊,小女子給你的是殘缺版滴,要是你給我分,我就把剩下滴給你,上次在北京大學貼吧都被人騙了,世道炎涼啊O(∩_∩)O~

⑶ 頁面置換演算法

  上文說到,請求分頁管理方式中,當需要調入頁面到內存中,但此時內存已滿,就需要從內存中按照一定的置換演算法決定將哪個頁面取出將內存給調入的頁面。本文將介紹幾種頁面置換算方法。
   本文內容

  演算法思想:每次選擇 淘汰的頁面 將是 以後永不使用 ,或者 在最長時間內不再被訪問的頁面 ,這樣可以保證最低的缺頁率。
  舉例說明,假設系統為進程分配了三個內存塊,並考慮到有以下頁面號引用串(會依次訪問這些頁面):7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1

  ....按照此演算法依次執行,最後的結果如下

  結果圖

  註:缺頁時未必發生頁面置換,若還有可用的空閑內存空間就不用進行頁面置換。
  最佳置換演算法可以保證最低的缺頁率,但是實際上,只有進程執行的過程中才能知道接下來會訪問到的是哪個頁面。操作系統無法提前預判頁面的訪問序列。因此, 最佳置換演算法是無法實現的

  演算法思想:每次選擇 淘汰的頁面是最早進入內存的頁面。
  該演算法很簡單,每次淘汰最在內存中待時間最久的各個,下面分別給出系統為進程分為配三個內存塊和四個內存塊的執行情況圖。訪問序列為3,2,1,0,3,2,4,3,2,1,0,4
  分配三個內存塊的情況:

  分配四個內存塊的情況:

  當為進程分配的物理塊數增大時,缺頁次數不減反增的異常現象稱為 貝萊迪(Belay)異常
   只有FIFO演算法會產生Belay異常。 另外,FIFO演算法雖然實現簡單,但是該演算法與進程實際運行時的規律不適應。因為先進入的頁面也有可能最經常被訪問。因此, 演算法性能差。

  演算法思想: 每次淘汰的頁面是最近最久未使用的頁面。
  實現方法:賦予每個頁面對應的頁表項中,用 訪問欄位記錄該頁面純虧自上次被訪問以來所經歷的時間t。 當需要淘汰一個頁面時,選擇現有頁面中t最大的頁面,即最近最久未使用。

  舉例說明,加入某系統為某進程分配了四個內存塊,並考慮到有以下頁面號引用串:1,8,1,7,8,2,7,2,1,8,3,8,2,1,3,1,7,1,3,7
  這里先直接給出答案

  結果圖

  最佳置換演算法那性能最好,但無法實現。先進先出置換演算法實現簡單,但是演算法性能差。最近最久未使用置換演算法性能好,是最接近OPT演算法性能的,但是實現起來需要專門的硬體支持,演算法開銷大。 時鍾置換演算法 是一種 性能和開銷均春褲配平衡 的演算法。又稱 CLOCK演算法 ,或 最近未用演算法 NRU ,Not Recently Used)
   簡單CLOCK演算法 演算法思想:為每個頁面設置一個 訪問位 ,再將內存中的頁面都通過 鏈接指針鏈接成一個循環隊列 。當某個頁被訪問時,其訪問位置1.當需要淘汰一個頁面時,只需檢查頁的訪問位。如果是0,就選擇該頁換出;如果是1,暫不換出,將訪問位改為0,繼續檢查下一個頁面,若第一輪掃描中所有的頁面都是1,則將這些頁面的訪問位一次置為0後,再進行第二輪掃描(第二輪掃描中一定會有訪問位為0的頁面,因此簡單的CLOCK演算法選擇一個扒指淘汰頁面最多會經過 兩輪掃描 )。

  這個演算法指針在掃描的過程就像時鍾一樣轉圈,才被稱為時鍾置換演算法。

  簡單的時鍾置換演算法僅考慮到了一個頁面最近是否被訪問過。事實上,如果淘汰的頁面沒有被修改過,就不需要執行I/O操作寫回外存。 只有淘汰的頁面被修改過時,才需要寫回外存。
  因此,除了考慮一個頁面最近有沒有被訪問過之外,操作系統還需要考慮頁面有沒有被修改過。
  改進型時鍾置換演算法的 演算法思想 在其他在條件相同時,應該優先淘汰沒有被修改過的頁面, 從而來避免I/O操作。
  為了方便討論,用(訪問位,修改位)的形式表示各頁面的狀態。如(1,1)表示一個頁面近期被訪問過,且被修改過。
   演算法規則 :將所有可能被置換的頁面排成一個循環隊列

  由於第二輪已將所有的頁的訪問位都設為0,因此第三輪、第四輪掃描一定會選中一個頁,因此 改進型CLOCK置換演算法最多會進行四輪掃描。

  假設系統為進程分配了5個內存塊,某時刻,各個頁的狀態如下圖

  如果此時有新的頁要進入內存,開始第一輪掃描就找到了要替換的頁,即最下面的狀態為(0,0)的頁。

  某一時刻頁面狀態如下

  如果此時有新的頁要進入內存,開始第一輪掃描就發現沒有狀態為(0,0)的頁,第一輪掃描後不修改任何標志位。所以各個頁狀態和上圖一樣。
  然後開始第二輪掃描,嘗試找到狀態為(0,1)的頁,並將掃描過後的頁的訪問位設為0,第二輪掃描找到了要替換的頁。

  某一時刻頁面狀態如下

  第一輪掃描沒有找到狀態為(0,0)的頁,且第一輪掃描不修改任何標志位,所以第一輪掃描後狀態和上圖一致。
  然後開始第二輪掃描,嘗試找狀態為(0,1)的頁,也沒有找到,第二輪掃描需要將訪問位設為1,第二輪掃描後,狀態為下圖

  某一時刻頁面狀態如下

  具體的掃描過程和上面相同,這里只給出最後的結果,如下圖

  所以,改進型的CLOCK置換演算法最多需要四輪掃描確定要置換的頁。從上面的分析可以看出,改進型的CLOCK置換演算法
  (1) 第一優先順序淘汰的是 最近沒有訪問且沒有修改 的頁面。
  (2) 第二優先順序淘汰的是 最近沒有訪問但修改 的頁面。
  (3) 第三優先順序淘汰的是 最近訪問但沒有修改 的頁面。
  (4) 第四優先順序淘汰的是 最近訪問且修改 的頁面。

⑷ 頁式管理的請求頁式管理中的置換演算法

功能:需要調入頁面時,選擇內存中哪個物理頁面被置換。稱為replacement policy。
出發點:把未來不再使用的或短期內較少使用的頁面調出,通常只能在局部性原理指導下依據過去的統計數據進行預測。
頁面鎖定(frame locking):用於描述必須常駐內存的操作系統的關鍵部分或時間關鍵(time-critical)的應用進程。實現方法為在頁表中加上鎖定標志位(lock bit)。 輪轉法(RR,round robin)和先進先出演算法(FIFO,first in first out):輪轉法循回換出內存可用區內一個可以被換出的頁,無論該頁是剛被換進或已換進內存很長時間。FIFO演算法總是選擇在內存駐留時間最長的一員將其淘汰。
FIFO演算法認為先調入內存的頁不再被訪問的可能性要比其它頁大,因而選擇最先調入內存的頁換出。實現FIFO演算法需要把各個已分配頁面按分配時間順序鏈接起來,組成FIFO隊列,並設置一置換指針指向FIFO隊列的隊首頁面。這樣,當要進行置換時,只需把置換指針所指的FIFO隊列前頭的頁順次換出,而把換入的頁鏈接在FIFO隊尾即可。
由實驗和測試發現FIPO演算法和RR演算法的內存利用率不高。這是因為,這兩種演算法都是基於CPU按線性順序訪問地址空間這一假設。事實上,許多時候.CPU不是按線性順序訪問地址空間的。
Belady現象:一般來說,對於任一作業或進程,如果給它分配的內存頁面數越接近於它所要求的頁面數,則發生缺頁的次數會越少。在極限情況下,這個推論是成立的。因為如果給一個進程分配了它所要求的全部頁面,則不會發生缺頁現象。但是,使用FIFO演算法時,在未給進程或作業分配足它所要求的頁面數時,有時會出現分配的頁面數增多,缺頁次數反而增加的奇怪現象。這種現象稱為Belady現象。 最近最久未使用頁面置換演算法(LRU, Least Recently Used):
選擇內存中最久未使用的頁面被置換。這是局部性原理的合理近似,性能接近最佳演算法。但由於需要記錄頁面使用時間的先後關系,硬體開銷太大。硬體機構如:
(1) 一個特殊的棧:把被訪問的頁面移到棧頂,於是棧底的是最久未使用頁面。
(2) 每個頁面設立移位寄存器:被訪問時左邊最高位置1,定期右移並且最高位補0,於是寄存器數值最小的是最久未使用頁面。
比較常用的近似演算法有:
(a) 最不經常使用頁面淘汰演算法(LFU, Least Frequently Used)
(b) 最近沒有使用頁面淘汰(NRU, Not Recently Used) 理想型淘汰演算法(OPT,Optimal Replacement Algorithm)
該演算法淘汰在訪問串中將來再也不出現的或是離當前最遠的位置上出現的頁。它是一種理想化的演算法,性能最好,但在實際上難於實現。

⑸ 幾種頁面置換演算法的基本原理及實現方法

收藏推薦 在多道程序的正常運行過程中,屬於不同進程的頁面被分散存放在主存頁框中,當正在運行的進程所訪問的頁面不在內存時,系統會發生缺頁中斷,在缺頁中斷服務程序中會將所缺的頁面調入內存,如內存已無空閑頁框,缺頁中斷服務程序就會調用頁面置換演算法,頁面置換演算法的目的就是選出一個被淘汰的頁面.把內存和外存統一管理的真正目的是把那些被訪問概率非常高的頁存放在內存中.因此,置換演算法應該置換那些被訪問概率最低的頁,將它們移出內存.1最佳置換演算法基本原理:淘汰以後不再需要的或最遠的將來才會用到的頁面.這是1966年Belady提出的理想演算法,但無法實現,主要用於評價其他置換演算法.例:分配給某進程的內存頁面數是3頁,頁面地址流如下:7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,其內存動態分配過程如下:7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 17 7 7 2 2 2 2 2 2 2 2 2 2 2 2 2 20 0 0 0 0 0 4 4 4 0 0 0 0 0 0 01 1 1 3 3 3 3 3 3 3 3 1 1 1 12先進先出置換......(本文共計2頁) 如何獲取本文>>

⑹ lru頁面置換演算法是什麼

用雙向鏈表和哈希表來實現。

LRU演算法的提出,是基於這樣一個事實:在前面幾條指令中使用頻繁的頁面很可能在後面的幾條指令中頻繁使用。

反過來說,已經很久沒有使用的頁面很可能在未來較長的一段時間內不會被用到。這個,就是著名的局部性原理——比內存速度還要快的cache,也是基於同樣的原理運行的。因此,只需要在每次調換時,找到最近最少使用的那個頁面調出內存。這就是LRU演算法的全部內容。

一種LRU近似演算法是最近未使用演算法。

它在存儲分塊表的每一表項中增加一個引用位,操作系統定期地將它們置為0。當某一頁被訪問時,由硬體將該位置1。過一段時間後,通過檢查這些位可以確定哪些頁使用過,哪些頁自上次置0後還未使用過。就可把該位是0的頁淘汰出去,因為在之前最近一段時間里它未被訪問過。

以上內容參考:網路-頁面置換演算法

⑺ 操作系統課程設計,用C#實現內存頁面的置換。實現演算法間比較

頁面置換演算法

一.題目要求:

通過實現頁面置換演算法的FIFO和LRU兩種演算法,理解進程運行時系統是怎樣選擇換出頁面的,對於兩種不同的演算法各自的優缺點是哪些。

要求設計主界面以靈活選擇某演算法,且以下演算法都要實現 1) 最佳置換演算法(OPT):將以後永不使用的或許是在最長(未來)時間內不再被訪問的頁面換出。

2) 先進先出演算法(FIFO):淘汰最先進入內存的頁面,即選擇在內存中駐留時間最久的頁面予以淘汰。

3) 最近最久未使用演算法(LRU):淘汰最近最久未被使用的頁面。 4) 最不經常使用演算法(LFU) 二.實驗目的:

1、用C語言編寫OPT、FIFO、LRU,LFU四種置換演算法。 2、熟悉內存分頁管理策略。 3、了解頁面置換的演算法。 4、掌握一般常用的調度演算法。 5、根據方案使演算法得以模擬實現。 6、鍛煉知識的運用能力和實踐能力。 三、設計要求

1、編寫演算法,實現頁面置換演算法FIFO、LRU;

2、針對內存地址引用串,運行頁面置換演算法進行頁面置換; 3、演算法所需的各種參數由輸入產生(手工輸入或者隨機數產生); 4、輸出內存駐留的頁面集合,頁錯誤次數以及頁錯誤率;

四.相關知識:

1.虛擬存儲器的引入:

局部性原理:程序在執行時在一較短時間內僅限於某個部分;相應的,它所訪問的存儲空間也局限於某個區域,它主要表現在以下兩個方面:時間局限性和空間局限性。

2.虛擬存儲器的定義:

虛擬存儲器是只具有請求調入功能和置換功能,能從邏輯上對內存容量進行擴充的一種存儲器系統。

3.虛擬存儲器的實現方式:

分頁請求系統,它是在分頁系統的基礎上,增加了請求調頁功能、頁面置換功能所形成的頁面形式虛擬存儲系統。

請求分段系統,它是在分段系統的基礎上,增加了請求調段及分段置換功能後,所形成的段式虛擬存儲系統。

4.頁面分配:

平均分配演算法,是將系統中所有可供分配的物理塊,平均分配給各個進程。 按比例分配演算法,根據進程的大小按比例分配物理塊。

考慮優先的分配演算法,把內存中可供分配的所有物理塊分成兩部分:一部分按比例地分配給各進程;另一部分則根據個進程的優先權,適當的增加其相應份額後,分配給各進程。

5.頁面置換演算法:

常用的頁面置換演算法有OPT、FIFO、LRU、Clock、LFU、PBA等。 五、設計說明

1、採用數組頁面的頁號

2、FIFO演算法,選擇在內存中駐留時間最久的頁面予以淘汰;

分配n個物理塊給進程,運行時先把前n個不同頁面一起裝入內存,然後再從後面逐一比較,輸出頁面及頁錯誤數和頁錯誤率。

3、LRU演算法,根據頁面調入內存後的使用情況進行決策;

同樣分配n個物理塊給進程,前n個不同頁面一起裝入內存,後面步驟與前一演算法類似。

選擇置換演算法,先輸入所有頁面號,為系統分配物理塊,依次進行置換: 六.設計思想:

OPT基本思想:

是用一維數組page[pSIZE]存儲頁面號序列,memery[mSIZE]是存儲裝入物理塊中的頁面。數組next[mSIZE]記錄物理塊中對應頁面的最後訪問時間。每當發生缺頁時,就從物理塊中找出最後訪問時間最大的頁面,調出該頁,換入所缺的頁面。

FIFO基本思想:

是用隊列存儲內存中的頁面,隊列的特點是先進先出,與該演算法是一致的,所以每當發生缺頁時,就從隊頭刪除一頁,而從隊尾加入缺頁。或者藉助輔助數組time[mSIZE]記錄物理塊中對應頁面的進入時間,每次需要置換時換出進入時間最小的頁面。

LRU基本思想:

是用一維數組page[pSIZE]存儲頁面號序列,memery[mSIZE]是存儲裝入物理塊中的頁面。數組flag[10]標記頁面的訪問時間。每當使用頁面時,刷新訪問時間。發生缺頁時,就從物理塊中頁面標記最小的一頁,調出該頁,換入所缺的頁面。 七.流程圖:

如下頁所示

六.運行結果: 1. 按任意鍵進行初始化:

2. 載入數據:

3. 進入置換演算法選擇界面:

4.運算中延遲操作:

5.三種演算法演示結果:

⑻ 用C++語言編寫FIFO頁面置換演算法代碼


分別使用FIFO、OPT、LRU三種置換演算法來模擬頁面置換的過程。(Linux、Windows下皆可)
輸入:3//頁幀數
70120304230321201701//待處理的頁
輸出:頁面置換過程中各幀的變化過程和出現頁錯誤的次數
[cpp]
#include<iostream>
usingnamespacestd;
intinput[20]={7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
classpage
{
public:
intnum;
intmark;
page()
{
num=0;
mark=21;
}
};
voidFIFO()
{
cout<<"------FIFO-----------"<<endl;
interror=0;
pageframe[3];//頁幀
for(inti=0;i<3;i++)//處理前三個引用
{
frame[i].num=input[i];
error++;
cout<<frame[i].num<<"|";
for(intj=0;j<=i;j++)
cout<<frame[j].num<<'';
cout<<endl;
}
for(inti=3;i<20;i++)
{
intj;
for(j=0;j<3;j++)
if(input[i]==frame[j].num)
{
cout<<input[i]<<endl;
break;
}
if(j==3)
{
error++;
frame[((error-1)%3)].num=input[i];//換掉最舊的頁
cout<<input[i]<<"|";
for(intk=0;k<3;k++)
cout<<frame[k].num<<'';
cout<<endl;
}
}
cout<<"FrameError:"<<error<<endl<<endl;
}
voidOPT()
{
cout<<"------OPT------------"<<endl;
interror=0;
pageframe[3];
for(inti=0;i<3;i++)//處理前三個引用
{
frame[i].num=input[i];
error++;
cout<<frame[i].num<<"|";
for(intj=0;j<=i;j++)
cout<<frame[j].num<<'';
cout<<endl;
}
for(inti=3;i<20;i++)
{
intj;
for(j=0;j<3;j++)
if(input[i]==frame[j].num)
{
cout<<input[i]<<endl;
break;
}
if(j==3)
{
error++;
for(j=0;j<3;j++)
{
frame[j].mark=21;
for(intk=20;k>=i;k--)//向後遍歷,找到最長時間不用的頁
{
if(frame[j].num==input[k])
frame[j].mark=k;
}
}
if(frame[0].mark>frame[1].mark&&frame[0].mark>frame[2].mark)
frame[0].num=input[i];
elseif(frame[1].mark>frame[0].mark&&frame[1].mark>frame[2].mark)
frame[1].num=input[i];
else
frame[2].num=input[i];
cout<<input[i]<<"|";
for(intk=0;k<3;k++)
cout<<frame[k].num<<'';
cout<<endl;
}
}
cout<<"FrameError:"<<error<<endl<<endl;
}
voidLRU()
{
cout<<"------LRU------------"<<endl;
interror=0;
pageframe[3];
for(inti=0;i<3;i++)//處理前三個引用
{
frame[i].num=input[i];
error++;
cout<<frame[i].num<<"|";
for(intj=0;j<=i;j++)
cout<<frame[j].num<<'';
cout<<endl;
}
for(inti=3;i<20;i++)
{
intj;
for(j=0;j<3;j++)
if(input[i]==frame[j].num)
{
cout<<input[i]<<endl;
break;
}
if(j==3)
{
error++;
for(j=0;j<3;j++)
{
frame[j].mark=0;
for(intk=0;k<=i;k++)//向前遍歷,找到最近最少使用的
{
if(frame[j].num==input[k])
frame[j].mark=k;
}
}
if(frame[0].mark<frame[1].mark&&frame[0].mark<frame[2].mark)
frame[0].num=input[i];
elseif(frame[1].mark<frame[0].mark&&frame[1].mark<frame[2].mark)
frame[1].num=input[i];
else
frame[2].num=input[i];
cout<<input[i]<<"|";
for(intk=0;k<3;k++)
cout<<frame[k].num<<'';
cout<<endl;
}
}
cout<<"FrameError:"<<error<<endl<<endl;
}
intmain()
{
FIFO();
OPT();
LRU();
}

熱點內容
湖南台訪問 發布:2025-03-20 05:10:32 瀏覽:37
腳本和秒搶 發布:2025-03-20 05:06:29 瀏覽:590
b35鎖如何設置密碼 發布:2025-03-20 05:06:27 瀏覽:903
淘寶如何租雲伺服器 發布:2025-03-20 05:05:12 瀏覽:210
編程忌諱 發布:2025-03-20 04:58:35 瀏覽:425
國家知識產權專利資料庫 發布:2025-03-20 04:54:29 瀏覽:414
win7怎麼給文件夾設密碼 發布:2025-03-20 04:52:38 瀏覽:723
安卓手機電影怎麼投屏到ipad上 發布:2025-03-20 04:27:23 瀏覽:677
蘋果安卓基於什麼開發 發布:2025-03-20 04:20:52 瀏覽:520
演算法化是 發布:2025-03-20 03:48:20 瀏覽:771