頁面演算法模擬實驗報告

『壹』 操作系統課程設計，用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語言編寫頁面置換演算法

//熬夜弄出來的，記得加分哦
#include<stdio.h>
void Print(int bc[],int blockCount)
{
for(int i=0;i<blockCount;i++)
{
printf("%d ",bc[i]);
}
printf("\n");
}

bool Travel(int bc[],int blockCount,int x)
{
bool is_found=false;
int i;
for(i=0;i<blockCount;i++)
{
if(bc[i]==x)
{
is_found=true;
break;
}
}
return is_found;
}

void FIFO(int pc[],int bc[],int pageCount,int blockCount)
{
printf("0：FIFO置換演算法\n");
int i;
if(pageCount<=blockCount)
{
printf("缺頁次數為0\n");
printf("缺頁率為0\n");
}
else
{
int noPage=0;
int p=0;
for(i=0;i<pageCount;i++)
{

//printf("引用頁：%d\n",pc[i]);
if(!Travel(bc,blockCount,pc[i]))
{
if(i<blockCount)
{
bc[i]=pc[i];
}
else
{
if(p==blockCount)
{
p=0;
}
bc[p]=pc[i];
p++;

}
noPage++;
//printf("物理塊情況：\n");
//Print(bc,blockCount);
}
//printf("\n");
}
printf("FIFO缺頁次數為:%d\n",noPage);
printf("FIFO缺頁率為:%.2f%%\n",(float)noPage/pageCount*100);
}
}

int FoundMaxNum(int a[],int n)
{
int k,j;
k=a[0];
j=0;
for (int i=0;i<n;i++)
{
if(a[i]>=k)
{
k=a[i];
j=i;
}
}
return j;
}

void LRU(int pc[],int bc[],int pageCount,int blockCount)
{
printf("1：LRU置換演算法\n");
if(pageCount<=blockCount)
{
printf("缺頁次數為0\n");
printf("缺頁率為0\n");
}
else
{
int noPage=0;
int i,j,m;
int bc1[100];
for(i=0;i<blockCount;i++)
{
bc1[i]=0;
}
for(i=0;i<pageCount;i++)
{
// printf("引用頁：%d\n",pc[i]);
if(!Travel(bc,blockCount,pc[i]))
{
if(i<blockCount)
{
bc[i]=pc[i];
for(int p=0;p<=i;p++)
{
bc1[p]++;
}
}
else
{
for(j=0;j<blockCount;j++)
{
bc1[j]++;
}
int k=FoundMaxNum(bc1,blockCount);
bc[k]=pc[i];
bc1[k]=1;

}
noPage++;
//printf("物理快情況：\n");
//Print(bc,blockCount);
}
else if(Travel(bc,blockCount,pc[i]))
{
if(i<blockCount)
{
for(j=0;j<=i;j++)
{
bc1[j]++;
}
for(m=0;m<=i;m++)
{
if(bc[m]==pc[i])
{
break;
}
}
bc1[m]=1;
bc[m]=pc[i];

}
else
{
for(j=0;j<blockCount;j++)
{
bc1[j]++;
}
for(m=0;m<blockCount;m++)
{
if(bc[m]==pc[i])
{
break;
}
}
bc1[m]=1;
bc[m]=pc[i];
}
}
//printf("\n");
}
printf("LRU缺頁次數為:%d\n",noPage);
printf("LRU缺頁率為:%.2f%%\n",(float)noPage/pageCount*100);
}
}

void Optiomal(int pc[],int bc[],int pageCount,int blockCount)
{
printf("2：最佳置換演算法\n");
if(pageCount<=blockCount)
{
printf("缺頁次數為0\n");
printf("缺頁率為0\n");
}
else
{
int noPage=0;
int i,j,k;
for(i=0;i<pageCount;i++)
{
// printf("引用頁：%d\n",pc[i]);
if(!Travel(bc,blockCount,pc[i]))
{
if(i<blockCount)
{
bc[i]=pc[i];
}
else
{
int max=0;
int blockIndex;;
for(j=0;j<blockCount;j++)
{
for(k=i;k<pageCount;k++)
{
if(bc[j]==pc[k])
{
break;
}
}
if(k>=max)
{
max=k;
blockIndex=j;
}
}
bc[blockIndex]=pc[i];

}
noPage++;
//printf("物理快情況：\n");
//Print(bc,blockCount);
}
//printf("\n");
}
printf("OPT缺頁次數為:%d\n",noPage);
printf("OPT缺頁率為:%.2f%%\n",(float)noPage/pageCount*100);
}
}

int main()
{
int pageCount,blockCount,i,pc[100];
printf("輸入頁面數\n");
scanf("%d",&pageCount);
printf("輸入頁面走向\n");
for(i=0;i<pageCount;i++)
{
scanf("%d",&pc[i]);
}
blockCount=3;//物理塊數
int bc1[100];
printf("\n");
FIFO(pc,bc1,pageCount,blockCount);
int bc2[100];
printf("\n");
LRU(pc,bc2,pageCount,blockCount);
int bc3[100];
printf("\n");
Optiomal(pc,bc3,pageCount,blockCount);
return 0;
}

『叄』 頁面置換演算法的實驗

#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~

『肆』 請分別給出三種不同的頁面置換演算法,並簡要說明他們的優缺點

[fifo.rar] - 操作系統中內存頁面的先進先出的替換演算法fifo
[先進先出頁面演算法程序.rar] - 分別實現最佳置換演算法(optimal)、先進先出(fifo)頁面置換演算法和最近最久未使用（LRU）置換演算法，並給出各演算法缺頁次數和缺頁率。
[0022.rar] - 模擬分頁式虛擬存儲管理中硬體的地址轉換和缺頁中斷，以及選擇頁面調度演算法處理缺頁中斷
[Change.rar] - 用java實現操作系統的頁面置換 其中包括 最佳置換演算法(Optimal)、先進先出演算法（First-in, First-out） 、最近最久不用的頁面置換演算法（LeastRecently Used Replacement）三種演算法的實現
[M_Management.rar] - 操作系統中內存管理頁面置換演算法的模擬程序，採用的是LRU置換演算法
[detail_of_44b0x_TCPIP.rar] - TCPIP 程序包載入到44b0x 的ADS1.2工程文件的說明書。說名了載入過程的細節和如何處理演示程序和代碼。演示代碼已經上傳，大家可以搜索
[.rar] - java操作系統頁面置換演算法： （1）進先出的演算法（fifo） （2）最近最少使用的演算法（LRU） （3）最佳淘汰演算法(OPT) （4）最少訪問頁面演算法(LFU) （註：由本人改成改進型Clock演算法） （5）最近最不經常使用演算法(NUR)

『伍』 實訓報告

1、通過三天的實習，對銑削加工的特點、加工范圍，對銑床的組成、工作原理和用途都有深刻的了解；已經具備獨自完成對工件測量、平面、溝槽加工，更換、安裝刀具的能力；已達到實習目的。

2、銑床的操作簡單易學，但操作過程中也不可鬆懈，以防止事故的發生。

3、作為金屬切削加工中常用方法之一的銑削加工，由於使用多刃多種類刀具銑刀的主運動又是旋轉運動，故銑削加工效率高，加工范圍廣；另一方面，銑削加工的工件尺寸公差等級一般為IT9-IT7級，表面粗糙度值較低，又適合與大批量生產，成本較低，因此銑削加工成為金屬加工中得到普遍的推廣。

我相信，隨著技術日新月異的發展，銑削加工一定會以其強大的生命力為工業生產開辟出新輝煌時光如流。

半個月時間轉眼即逝，這次實訓給我的體會是：

通過這次實習我們了解了現代機械製造工業的生產方式和工藝過程。熟悉工程材料主要成形方法和主要機械加工方法及其所用主要設備的工作原理和典型結構，工夾量具的使用以及安全操作技術。了解機械製造工藝知識和新工藝、新技術、新設備在機械製造中的應用。

在工程材料主要成形加工方法和主要機械加工方法上，具有初步的獨立操作技能。在了解、熟悉和掌握一定的工程基礎知識和操作技能過程中，培養、提高和加強了我們的工程實踐能力、創新意識和創新能力。

這次實習，讓我們明白做事要認真小心細致，不得有半點馬虎。同時也培養了我們堅強不屈的本質，不到最後一秒決不放棄的毅力！培養和鍛煉了勞動觀點，質量和經濟觀念，強化遵守勞動紀律、遵守安全技術規則和愛護國家財產的自覺性，提高了我們的整體綜合素質。

在整個實習過程中，老師對我們的紀律要求非常嚴格，制訂了學生實習守則，同時加強清理機床場地，遵守各工種的安全操作規程等要求，對學生的綜合工程素質培養起到了較好的促進作用。

『陸』 操作系統課程設計

設計題目
1設計題目：CPU調度(CPU調度演算法的模擬實現)
具體內容：編寫演算法，實現CPU調度演算法FCFS、非搶佔SJF、可搶占優先權調度、RR
針對模擬進程，利用CPU調度演算法進行調度
進行演算法評價，計算平均周轉時間和平均等待時間
要求：調度所需的進程參數由輸入產生
手工輸入
隨機數產生
輸出調度結果
輸出雞撣慣趕甙非軌石憨將演算法評價指標
2設計題目：虛擬內存 (頁面置換演算法的模擬實現)
具體內容：編寫演算法，實現頁面置換演算法FIFO、LRU
針對內存地址引用串，運行頁面置換演算法進行頁面置換
要求：演算法所需的引用串參數由輸入產生：可由手工輸入也可基於隨機數產生
輸出內存駐留的頁面集合
1．進程調度演算法模塊
[問題描述]
1、進程調度演算法：採用動態最高優先數優先的調度演算法（即把處理機分配給優先數最高的進程）。
2、每個進程有一個進程式控制制塊（ PCB）表示。進程式控制制塊可以包含如下信息：
進程名---進程標示數 ID
優先數 PRIORITY 優先數越大優先權越高
到達時間---進程的到達時間為進程輸入的時間。、
進程還需要運行時間ALLTIME，進程運行完畢ALLTIME=0，
已用CPU時間----CPUTIME、
進程的阻塞時間STARTBLOCK-表示當進程在運行STARTBLOCK個時間片後，進程將進入阻塞狀態
進程的阻塞時間BLOCKTIME--表示當進程阻塞BLOCKTIME個時間片後，進程將進入就緒狀態
進程狀態—STATE
隊列指針NEXT 用來將PCB排成隊列。
3、調度原則：
進程的優先數及需要的運行時間可以事先人為地指定（也可以由隨機數產生）。進程的到達時間為進程輸入的時間。
進程的運行時間以時間片為單位進行計算。
進程在就緒隊列中待一個時間片，優先數加1
每個進程的狀態可以是就緒 R（READY）、運行R（Run）阻塞B(BLOCK)、或完成F（Finish）四種狀態之一。
就緒進程獲得 CPU後都只能運行一個時間片。用已佔用CPU時間加1來表示。
如果運行一個時間片後，進程的已佔用CPU時間已達到所需要的運行時間，則撤消該進程，如果運行一個時間片後進程的已佔用CPU時間還未達所需要的運行時間，也就是進程還需要繼續運行，此時應將進程的優先數減3，然後把它插入就緒隊列等待CPU。
每進行一次調度程序都列印一次運行進程、就緒隊列、以及各個進程的 PCB，以便進行檢查。
重復以上過程，直到所要進程都完成為止。
求課程設計報告和用c語言編寫的源代碼

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

收藏推薦 在多道程序的正常運行過程中,屬於不同進程的頁面被分散存放在主存頁框中,當正在運行的進程所訪問的頁面不在內存時,系統會發生缺頁中斷,在缺頁中斷服務程序中會將所缺的頁面調入內存,如內存已無空閑頁框,缺頁中斷服務程序就會調用頁面置換演算法,頁面置換演算法的目的就是選出一個被淘汰的頁面.把內存和外存統一管理的真正目的是把那些被訪問概率非常高的頁存放在內存中.因此,置換演算法應該置換那些被訪問概率最低的頁,將它們移出內存.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頁) 如何獲取本文>>

『捌』 頁面調度演算法的實驗內容

（1）設計程序實現以上三種頁面調度演算法，要求：
①.可以選擇頁面調度演算法類型；
②.可以為進程設置分到物理頁的數目，設置進程的頁面引用情況，可以從鍵盤輸入頁面序列，也可從文件中讀取；
③.隨時計算當前的頁面調度次數的缺頁中斷率；
④.使用敲鍵盤或響應WM-TIMER的形式模仿時間的流逝；
⑤.以直觀的的形式將程序的執行情況顯示在計算機屏幕上；
⑥.存檔及讀盤功能，可以隨時將數據存入磁碟文件，供以後重復實驗時使用。
（2）假定進程分配到3個物理塊，對於下面的頁面引用序列：
7-0-1-2-0-3-0-4-2-3-0-3-2-1-2-0-1-7-0-1
請分別用先進和先出調度演算法，最近最少用調度演算法，最近最不常用調度演算法計算缺頁中斷次數，缺頁中斷率和缺頁調度次數、缺頁置換率。
再假定進程分配到4、5個物理塊，重復本實驗。
（3）假定進程分配到3個物理塊，對於下面的頁面引用序列：
4-3-2-1-4-3-5-4-3-2-1-5-0-7-3-8-9-0-2-1-4-7-3-9
請分別用先進先出調度演算法、最近最少用調度演算法，最近最不常用調度演算法計算缺頁中斷次數，缺頁中斷率和缺頁調度次數、缺頁置換率。
再假定進程分配到4、5個物理塊，重復本實驗。
（4）假定進程分配到3個物理塊，使用程序的動態頁面序列生成演算法，生成一個頁面序列，將此序列存入磁碟文件。再從磁碟文件讀入該序列，用程序分別計算三種演算法下的缺頁中斷次數、缺頁中斷率和缺頁調度次數、缺頁置換率。

『玖』 操作系統：請求頁式存儲管理中頁面置換演算法的模擬設計

srand()——獲取運算隨機數（數據類型：double）；
getpid()——獲取當前進程識別碼(long)；
srand(10*getpid())就是產生一個10陪的隨機數。該隨機函數的種子參數是getpid()，少了10意義就不一樣了，所以不行

s=(float)319*rand()/32767/32767/2+1，是一個算術式，rand()函數是產生隨機數的一個隨機函數，float是一種數據類型，為浮點數，S就是一個隨機數乘以319除以32767/32767/2+1的值，32767是2的（16-1）次方，為什麼要減1，因為是從0開始，0到15，2的0次方是1，一直算下去，2的（16-1）次方是32767，把(float)319*rand()/32767/32767/2+1所得的值存儲在S變數里

希望採納

『拾』 分別用FIFO/LRU/OPT頁面置換演算法求頁面置換過程及缺頁率