第一篇：1.操作系統實驗內容(進程調度)

一．實驗目的

用高級語言編寫和調實一個進程調度程序，以加深對進程的概念及進程調度算法的理解． 二．實驗要求：設計一個有 N個進程并發執行的進程調度程序。三．算法講解

進程調度算法：采用最高優先數優先的調度算法（即把處理機分配給優先數最高的進程）和先來先服務算法以及時間片輪轉法。

每個進程有一個進程控制塊（PCB）表示。進程控制塊可以包含如下信息：進程名、優先數、到達時間、需要運行時間、已用CPU時間、進程狀態等等。

進程的優先數及需要的運行時間可以事先人為地指定（也可以由隨機數產生）。進程的到達時間為進程輸入的時間。

進程的運行時間以時間片為單位進行計算。每個進程的狀態可以是就緒 W（Wait）、運行R（Run）、或完成F（Finish）三種狀態之一。

就緒進程獲得 CPU后都只能運行一個時間片。用已占用CPU時間加1來表示。

如果運行一個時間片后，進程的已占用 CPU時間已達到所需要的運行時間，則撤消該進程，如果運行一個時間片后進程的已占用CPU時間還未達所需要的運行時間，也就是進程還需要繼續運行，此時應將進程的優先數減1（即降低一級），然后把它插入就緒隊列等待CPU。每進行一次調度程序都打印一次運行進程、就緒隊列、以及各個進程的 PCB，以便進行檢查。重復以上過程，直到所要進程都完成為止。四．實驗報告要求

1．寫出實驗目的： 2。寫出實驗要求：

3。寫出實驗內容：（包括算法描述，程序流程圖及給出部分實驗結果及結果分析）4。實驗心得體會。

附：進程調度源程序如下：

/*jingchendiaodu.c*/ #include “stdio.h” #include #include #define getpch(type)(type*)malloc(sizeof(type))#define NULL 0 struct pcb /* 定義進程控制塊PCB */ { char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;sort()/* 建立對進程進行優先級排列函數*/ {

scanf(“%d”,&p->ntime);printf(“n”);p->rtime=0;p->state='w';p->link=NULL;sort();/* 調用sort函數*/ } } int space(){ int l=0;PCB* pr=ready;while(pr!=NULL){ l++;pr=pr->link;} return(l);} disp(PCB * pr)/*建立進程顯示函數,用于顯示當前進程*/ { printf(“n qname t state t super t ndtime t runtime n”);printf(“|%st”,pr->name);printf(“|%ct”,pr->state);printf(“|%dt”,pr->super);printf(“|%dt”,pr->ntime);printf(“|%dt”,pr->rtime);printf(“n”);} check()/* 建立進程查看函數 */ { PCB* pr;printf(“n **** 當前正在運行的進程是:%s”,p->name);/*顯示當前運行進程*/ disp(p);pr=ready;printf(“n ****當前就緒隊列狀態為:n”);/*顯示就緒隊列狀態*/ while(pr!=NULL){ disp(pr);pr=pr->link;} } destroy()/*建立進程撤消函數(進程運行結束,撤消進程)*/ { printf(“n 進程 [%s] 已完成.n”,p->name);free(p);

第二篇：操作系統進程調度實驗

一.實驗目的及實驗環境 1.實驗目的

通過觀察、分析實驗現象，深入理解進程及進程在調度執行和內存空間等方面的特點，掌握在POSIX 規范中fork和kill系統調用的功能和使用。2.實驗環境

（1）硬件

? CPU：I7-4500U ? 內存：8G DDR3 1600 ? 顯示器：華碩筆記本顯示器 ? 硬盤空間：80G

（2）軟件

? 虛擬機名稱及版本：非虛擬機

? 操作系統名稱及版本：Ubuntu Kylin 16.04 ? 編譯器：gcc 二.實驗內容

1、實驗前準備工作

學習man 命令的用法，通過它查看fork 和kill 系統調用的在線幫助，并閱讀參考資料，學會fork 與kill 的用法，復習C 語言的相關內容。

2、實驗內容

根據下發的Linux進程管理實驗PPT內容，將實驗代碼補充完整。并考慮： 先猜想一下這個程序的運行結果。假如運行“./process 20”，輸出會是什么樣？然后按照注釋里的要求把代碼補充完整，運行程序。可以多運行一會兒，并在此期間啟動、關閉一些其它進程，看process 的輸出結果有什么特點，記錄下這個結果。開另一個終端窗口，運行“ps aux|grep process”命令，看看process 究竟啟動了多少個進程。回到程序執行窗口，按“數字鍵+回車”嘗試殺掉一兩個進程，再到另一個窗口看進程狀況。按q 退出程序再看進程情況。

3、回答問題

編寫、編譯、鏈接、執行實驗內容設計中的代碼，并回答如下問題： 1）你最初認為運行結果會怎么樣？

手動輸入進程數，選擇輸入要殺死的進程編號，按q殺死所有進程。需手動輸入進程數，然后鍵入編號殺死進程，鍵入q殺死父進程即殺死2）實際的結果什么樣？有什么特點？試對產生該現象的原因進行分析。所有進程。

3）proc_number 這個全局變量在各個子進程里的值相同嗎？為什么？ 不相同，proc_number是存儲各個子進程的編號的，所以在各個子進程中

是不同的。

4）kill 命令在程序中使用了幾次？每次的作用是什么？執行后的現象是什么？

使用了2次，第一次是在while循環中的if語句中使用，用來殺死用戶鍵入的指定進程。第二次是殺死父進程，回到程序的開始。

5）使用kill 命令可以在進程的外部殺死進程。進程怎樣能主動退出？這兩種退出方式哪種更好一些？

調用return 函數或exit函數都可以正常退出，而使用kill函數是異常退出，使用正常退出的方法比較好。

6）寫出fork（）和kill（）函數原型，并解釋函數的功能和參數的含義？

原型： #include

功能：

一個現有進程可以調用fork函數創建一個新進程。由fork創建的新進程被稱為子進程。fork函數被調用一次但返回兩次。兩次返回的唯一區別是子進程中返回0值而父進程中返回子進程ID。原型：#include #include

int kill(pid_t pid, int sig);

功能：

向某個進程傳遞一個信號

7）ps aux|grep process命令功能是什么？并解釋結果的含義。

ps命令是最基本進程查看命令.使用該命令可以確定有進程正在運行數量和運行的狀態、進程是否結束、是否有僵尸進程、進程占用的資源。grep命令查看某進程的狀態并打印在屏幕上，ps aux是顯示所有進程和他們的狀態。ps aux輸出格式：

USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND

三．方案設計

每創建一個子進程時，將其pid存儲在數組pid[i]中，i存儲在proc_number中，然后調用死循環函數do_something()，輸出該進程的proc_number，當輸入數字是主進程執行kill(pid[pid-48],SIGTERM)，殺死ch-48進程。當輸入q時循環退出，kill(0,SIGTERM),殺死本組所有進程，程序退出。

#include pid_t fork(void);

四．測試數據及運行結果

注釋：由于我的電腦運行這段代碼報錯，所以我和我組高宏偉同學使用的是同一實驗數據，同一代碼。五．總結

1． 實驗過程中遇到的問題及解決辦法；

實驗中由于代碼中的大部分已經給出，只需填寫重要部分。遇到了不懂fork的返回值，所以if和else語句會同時執行，知道了fork的原理后，fork會返回兩個值一個到子進程，一個到父進程。2． 對設計及調試過程的心得體會。

本次實驗學會了創建進程命令fork和殺死進程命令kill。在開始的時候不理解fork 和kill的原理，有點懵。后來通過看書和上網查詢知道了fork和kill的原理后明白了代碼要填寫的空白。六．附錄：源代碼（電子版）

#include #include #include #include #include #include

#define MAX_CHILD_NUMBER 10 #define SLEEP_INTERVAL 2

int proc_number=0;void do_something();

int main(int argc,char* argv[]){ int child_proc_number=MAX_CHILD_NUMBER;int i,ch;pid_t child_pid;

pid_t pid[10]={0};if(argc>1){

child_proc_number = atoi(argv[1]);

child_proc_number =(child_proc_number>10)?10:child_proc_number;

for(i=0;i

child_pid=fork();

proc_number=i;

if(child_pid==0){do_something();

}else if(child_pid>0){

pid[i]=child_pid;

printf(“A Parent process,the pid is %dn”,getpid());

}

}

printf(“input the number you want to killn”);

while((ch=getchar())!='q')

{

if(isdigit(ch)){

ch=(int)ch-48;

if(kill(pid[ch],SIGKILL)<0){

perror(“kill”);

exit(1);

}else{

printf(“process %d has been killed!nn”,pid[ch]);

}

}else{

printf(“is not digitn”);

}

getchar();

printf(“input the number you want to kill:n”);

}

kill(0,SIGTERM);} return 0;}

void do_something(){ for(;;){

printf(“This is process No.%*dn”,proc_number+3,proc_number);

sleep(SLEEP_INTERVAL);} }

第三篇：操作系統 實驗一 進程調度

實驗一

進程控制與處理機調度綜合實驗

一、實驗目的

通過模擬進程控制方法及單處理機系統的進程調度，了解進程的結構，進程的創建與撤消，進程的組織及進程的狀態及其轉換，掌握進程調度策略。

二、實驗環境

開發工具使用windows平臺下的vc++6.0。

三、實驗內容

本實驗為單機模擬進程調度算法，在程序設計時不需真正地建立線程或者進程。實驗模擬創建若干進程（人為輸入或隨機數產生），選擇一種或幾種單處理機的進程調度算法，如FCFS（先來先服務），SPF（短進程優先），RR（時間片輪轉法），優先級算法等，模擬進行進程調度。每進行一次調度，都打印一次運行進程、就緒隊列、以及各個進程的PCB，并能在進程完成后及時撤消該進程。

四、完成情況

1、進程及進程的運行狀態

進程是現代計算機中的基本要素，是系統分配資源和調度的基本單位。進程與程序不同，進程是系統中動態的實體，有它的創建、運行和撤銷的過程。PCB塊是系統感知進程存在的唯一實體。進程的創建必須首先創建進程的PCB塊，而進程的運行也伴隨著PCB塊的變化，進城撤銷也要同時撤銷它的PCB塊。所以本實驗的任務就是通過模擬調度進程的PCB塊來調度進程。進程的PCB塊包含以下四方面的內容： a)進程標示符 b)處理及狀態信息 c)進程調度信息 d)進程控制信息

進程在運行中存在三種基本狀態，分別是運行狀態、就緒狀態和阻塞狀態。

2、進程調度

一個運行進程的時間片用完或發生阻塞時，系統就會選擇一個就緒進程調度執行。進程的調度算法有很多如FCFS、SPF、優先級調度和時間片輪轉方法。進程調度算法模擬試驗就是通過調度進程的PCB塊來模擬調度進程。在系統中PCB塊就表現為一個結構體，PCB塊之間的連接方式存在兩種，一種是連接方式，一種是索引方式。本試驗中可選擇任意一種連接方式。

3、例程

設計一個有 N個進程共行的進程調度程序。進程調度算法：采用最高優先數優先的調度算法（即把處理機分配給優先數最高的進程）。

每個進程有一個進程控制塊（PCB）表示。進程控制塊可以包含如下信息：進程名、優先數、到達時間、需要運行時間、已用CPU時間、進程狀態等等。進程的優先數及需要的運行時間可以事先人為地指定（也可以由隨機數產生）。進程的到達時間為進程輸入的時間。進程的運行時間以時間片為單位進行計算。每個進程的狀態可以是就緒 W（Wait）、運行R（Run）、或完成F（Finish）三種狀態之一。就緒進程獲得 CPU后都只能運行一個時間片。用已占用CPU時間加1來表示。如果運行一個時間片后，進程的已占用 CPU時間已達到所需要的運行時間，則撤消該進程，如果運行一個時間片后進程的已占用CPU時間還未達所需要的運行時間，也就是進程還需要繼續運行，此時應將進程的優先數減1（即降低一級），然后把它插入就緒隊列等待CPU。每進行一次調度程序都打印一次運行進程、就緒隊列、以及各個進程的 PCB，以便進行檢查。重復以上過程，直到所要進程都完成為止。

調度算法的流程圖如下：

開始初始化進程PCB，輸入進程信息各進程按優先數從高到低排列y就緒隊列空？結束就緒隊列首進程投入運行時間片到CPU占用時間+1運行已占用CPU時間已達到所需CPU時間y進程完成撤銷該進程是運行進程的優先數減1把運行進程插入就緒隊列 圖1-1 流程圖

源代碼：#include “stdio.h” #include #include #define getpch(type)(type*)malloc(sizeof(type))#define NULL 0 struct pcb { /* 定義進程控制塊PCB */ char name[10];char state;int super;int ntime;int rtime;struct pcb* link;}*ready=NULL,*p;typedef struct pcb PCB;void sort()/* 建立對進程進行優先級排列函數*/ { PCB *first, *second;

int insert=0;if((ready==NULL)||((p->super)>(ready->super)))/*優先級最大者,插入隊首 */ {

p->link=ready;ready=p;} else /* 進程比較優先級,插入適當的位置中*/ {

first=ready;second=first->link;

while(second!=NULL)

{

if((p->super)>(second->super))/*若插入進程比當前進程優先數

大,*/

{ /*插入到當前進程前面*/

p->link=second;

first->link=p;

second=NULL;

insert=1;}

else /* 插入進程優先數最低,則插入到隊尾*/

{

first=first->link;second=second->link;

}

}

if(insert==0)

first->link=p;} } void input()/* 建立進程控制塊函數*/ { int i,num;printf(“n請輸入進程數量:”);scanf(“%d”,&num);for(i=0;i

printf(“n 進程號No.%d:n”,i);

p=getpch(PCB);

printf(“n 輸入進程名:”);

scanf(“%s”,p->name);

printf(“n 輸入進程優先數:”);

scanf(“%d”,&p->super);

printf(“n 輸入進程運行時間:”);

scanf(“%d”,&p->ntime);

printf(“n”);

p->rtime=0;p->state='w';

p->link=NULL;

sort();/* 調用sort函數*/ } }

int space(){ int l=0;PCB* pr=ready;while(pr!=NULL){

l++;

pr=pr->link;} return(l);} void show(){ printf(“nqnametstatetsupertndtimetruntimen”);} void disp(PCB * pr)/*建立進程顯示函數,用于顯示當前進程*/ {

printf(“ %st”,pr->name);printf(“ %ct”,pr->state);printf(“ %dt”,pr->super);printf(“ %dt”,pr->ntime);printf(“ %dt”,pr->rtime);printf(“n”);} void check()/* 建立進程查看函數 */ { PCB* pr;printf(“n****當前正在運行的進程是:%s”,p->name);/*顯示當前運行進程*/ show();disp(p);pr=ready;if(pr==NULL)

printf(“n****當前就緒隊列為空!”);

else

{

printf(“n****當前就緒隊列狀態為:”);/*顯示就緒隊列狀態*/

show();

while(pr!=NULL)

{

disp(pr);

pr=pr->link;

}

} } void destroy()/*建立進程撤消函數(進程運行結束,撤消進程)*/ { printf(“n 進程[%s]已完成.n”,p->name);free(p);} void running()/* 建立進程就緒函數(進程運行時間到,置就緒狀態*/ {(p->rtime)++;if(p->rtime==p->ntime)destroy();/* 調用destroy函數*/ else {

(p->super)--;

p->state='w';

sort();/*調用sort函數*/ } } void main()/*主函數*/ { int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){

ch=getchar();

h++;

printf(“n 當前運行次數為:%d n”,h);

p=ready;

ready=p->link;

p->link=NULL;

p->state='R';

check();

running();

printf(“n 按任一鍵繼續......”);

ch=getchar();} printf(“nn 進程已經完成.n”);ch=getchar();}

輸入數據后運行結果如下圖所示：

五、問題及解決辦法

問題：當插入的進程優先級大于當前進程優先級的時候，插入的進程應該放在什么

位置？

方法：通過指針的指向變換，把插入的進程放置在當前進程前面。

六、實驗心得

通過本次實驗，了解了進程的結構，進程的創建、撤銷，掌握了進程調度策略處理機調度的理解，我更加深刻的認識到調度進程的pcb塊來調度進程的過程，以及按照優先權進行排序的算法實現。對操作系統有了進一步的認識，后面會更加努力學習，掌握這門學科。

第四篇：操作系統進程調度算法模擬實驗報告

進程調度算法模擬

專業：XXXXX 學號：XXXXX 姓名：XXX 實驗日期：20XX年XX月XX日

一、實驗目的

通過對進程調度算法的模擬加深對進程概念和進程調度算法的理解。

二、實驗要求

編寫程序實現對5個進程的調度模擬，要求至少采用兩種不同的調度算法分別進行模擬調度。

三、實驗方法內容

1.算法設計思路

將每個進程抽象成一個控制塊PCB，PCB用一個結構體描述。

構建一個進程調度類。將進程調度的各種算法分裝在一個類中。類中存在三個容器，一個保存正在或未進入就緒隊列的進程，一個保存就緒的進程，另一個保存已完成的進程。還有一個PCB實例。主要保存正在運行的進程。類中其他方法都是圍繞這三個容器可以這個運行中的PCB展開。

主要用到的技術是STL中的vector以維護和保存進程容器、就緒容器、完成容器。

當程序啟動時，用戶可以選擇不同的調度算法。然后用戶從控制臺輸入各個進程的信息，這些信息保存到進程容器中。進程信息輸入完畢后，就開始了進程調度，每調度一次判斷就緒隊列是否為空，若為空則系統時間加一個時間片。判斷進程容器中是否有新的進程可以加入就緒隊列。2.算法流程圖 主程序的框架：

開始void FCFS();//先來先服務void SJF();//最短進程優先調度void RR();//簡單時間片輪轉void PD();//最高優先數優先void PCBInput();//輸入進程信息選擇調度算法輸入進程信息將輸入容器中以滿足進入條件的進程調入就緒隊列void ProcessQueueProcess();//查看當前時間下，有無進程加入。若有則把該進程調入就緒隊列按照選擇的算法開始選擇就緒隊列的進程開始執行void ProcessSelect();//若當前就緒隊列不為空則根據選擇的調度算法開始調度,否則，系統時間加一個時間片.以等待新的進程到判斷就緒容器和輸入容器是否為空!processScheduler.m_WaitQueue.empty()||!processScheduler.m_ProcessQueue.empt()Y打印各進程信息進行統計計算周轉時間等結束void PCBDisplay();//打印當前狀況下。就緒隊列、完成隊列、運行中的進程信息void SchedulerStatistics();//調度統計，計算周轉時間等進程調度過程：

開始為空判斷就緒隊列是否為空if(m_WaitQueue.empty())非空讓系統等待一個時間片TimePast()根據設定的調度算法從就緒隊列中調入一個進程并執行（此時進程從就緒隊列中刪除，賦值到表示運行中的成員變量中）void FCFS();//先來先服務void SJF();//最短進程優先調度void RR();//簡單時間片輪轉void PD();//最高優先數優先進程運行一個時間片N是否達到該進程停止運行的條件Y選入的進程狀態是否為“完成”如進程已完成，或者分得的時間片個數已到ProcessRun()Yvector

m_WaitQueue;//進程就緒隊列進程未完成，將進程優先數減一，并放回到就緒隊列中設置進程完成時間，將該進程放入完成隊列vector

m_FinishQueue;//完成隊列結束

3.算法中用到的數據結構

struct fcfs{

//先來先服務算法從這里開始

char name[10];

float arrivetime;

float servicetime;

float starttime;

float finishtime;

float zztime;

float dqzztime;

};

//定義一個結構體，里面包含的有一個進程相關的信息

4.主要的常量變量

vector

m_ProcessQueue;//進程輸入隊列

vector

m_WaitQueue;//進程就緒隊列 vector

m_FinishQueue;//完成隊列 vector

::iterator m_iter;//迭代器 PCB m_runProcess;//運行中的進程

int m_ProcessCount;//進程數 float m_RunTime;//運行時間

int m_tagIsRun;//是否在運行標志。表示正在運行，表示沒有 float m_TimeSlice;//時間片大小

int m_TimeSliceCount;//指時間片輪轉中一次分到的時間片個數 char m_SchedulerAlgorithm;//調度算法

5.主要模塊

void PCBInput();//輸入進程信息

void PCBSort();//對進程控制塊按照優先級排序(采用冒泡排序)void ProcessSelect();//若當前就緒隊列不為空則根據選擇的調度算法開始調度。否則，系統時間void PCBDisplay();//打印當前狀況下。就緒隊列、完成隊列、運行中的進程信息

void ProcessRun();//進程運行一次。運行時間加個時間片。并判斷進程是否達到完成條件。若是則void ProcessQueueProcess();//查看當前時間下，有無進程加入。若有則把該進程調入就緒隊列 void ProcessDispatch();//進程分派，進程執行完成后決定進程該進入哪個隊列(就緒、完成)void TimePast(){ m_RunTime +=m_TimeSlice;ProcessQueueProcess();}//當前系統時間加個時間void SchedulerStatistics();//調度統計，計算周轉時間等 void FCFS();//先來先服務 void SJF();//最短進程優先調度 void RR();//簡單時間片輪轉 void PD();//最高優先數優先 加.以等待新的進程到來

ProcessStatus='f'.否則為'w';片，并檢查是否有新的進程加入

四、實驗代碼

#include #include #include

using namespace std;

struct fcfs{

//先來先服務算法從這里開始

char name[10];

float arrivetime;

float servicetime;

float starttime;

float finishtime;

float zztime;

float dqzztime;

};

//定義一個結構體，里面包含的有一個進程相關的信息

fcfs a[100];

void input(fcfs *p,int N)

{

int i;

cout<

printf(“

請您輸入進程的名字

到達時間

服務時間:(例如: a 0 100)nn”);

for(i=0;i<=N-1;i++)

{

printf(“

請您輸入進程%d的信息:t”,i+1);

scanf(“ttt%s%f%f”,&p[i].name,&p[i].arrivetime,&p[i].servicetime);

}

}

void Print(fcfs *p,float arrivetime,float servicetime,float starttime,float finishtime,float zztime,float dqzztime,int N)

{ int k;

printf(“nn調用先來先服務算法以后進程運行的順序是: ”);

printf(“%s”,p[0].name);

for(k=1;k

{

printf(“-->%s”,p[k].name);

}

cout<

printf(“n

具體進程調度信息:n”);

printf(“t進程名

到達時間

服務時間

開始時間

結束時間

周轉時間

帶權周轉時間n”);

for(k=0;k<=N-1;k++)

{

printf(“t%st%-.2ft %-.2ft

%-.2ft

%-.2ft %-.2ft %-.2fn”,p[k].name,p[k].arrivetime，p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].zztime,p[k].dqzztime);

}

getchar();

//此處必須要有這個函數，否則就看不到顯示器上面的輸出，可以看到的結果只是一閃而過的一個框剪

}

void sort(fcfs *p,int N)//排序

{

for(int i=0;i<=N-1;i++)

for(int j=0;j<=i;j++)

if(p[i].arrivetime

{

fcfs temp;

temp=p[i];

p[i]=p[j];

p[j]=temp;

}

}

void deal(fcfs *p, float arrivetime,float servicetime,float starttime,float finishtime,float &zztime,float &dqzztime,int N)

//運行階段

{ int k;

for(k=0;k<=N-1;k++)

{

if(k==0)

{

p[k].starttime=p[k].arrivetime;

p[k].finishtime=p[k].arrivetime+p[k].servicetime;}

else

{

p[k].starttime=p[k-1].finishtime;

p[k].finishtime=p[k-1].finishtime+p[k].servicetime;}

}

for(k=0;k<=N-1;k++)

{

p[k].zztime=p[k].finishtime-p[k].arrivetime;

p[k].dqzztime=p[k].zztime/p[k].servicetime;

}

}

void FCFS(fcfs *p,int N)

{

float arrivetime=0,servicetime=0,starttime=0,finishtime=0,zztime=0,dqzztime=0;

sort(p,N);

deal(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);

Print(p,arrivetime,servicetime,starttime,finishtime,zztime,dqzztime,N);

getchar();

} //先來先服務算法到此結束 struct sjf{//最短進程優先調度算法從這里開始

char name[10];float arrivetime;//到達時間

float servicetime;//運行時間

float starttime;

//開始時間

float finishtime;

//完成時間

};sjf a1[100];

void input(sjf *p,int N1)//進程信息輸入 {

int i;cout<

printf(“

請您輸入進程的名字

到達時間

服務時間:(例如: a 0 100)n”);

for(i=0;i<=N1-1;i++){

printf(“

請您輸入進程%d的信息:t”,i+1);

scanf(“ttt%s%f%f”,&p[i].name,&p[i].arrivetime,&p[i].servicetime);} }

void Print(sjf *p,float arrivetime,float servicetime,float starttime,float finishtime,int N1)//最終結果輸出

{

int k;

printf(“nt調用最短進程優先調度算法以后進程的調度順序為:”);

printf(“%s”,p[0].name);

for(k=1;k

{printf(“-->%s”,p[k].name);}

cout<

printf(“n給個進程具體調度信息如下:n”);

printf(“nt進程名t到達時間t運行時間t開始時間t完成時間n”);

for(k=0;k<=N1-1;k++)

{

printf(“ t%st %-.2ftt %-.2ftt %-.2ftt %-.2ftn”,p[k].name,p[k].arrivetime，p[k].servicetime,p[k].starttime,p[k].finishtime);

}

getchar();

} void sort(sjf *p,int N1)//排序 {

for(int i=0;i<=N1-1;i++)

for(int j=0;j<=i;j++)

if(p[i].arrivetime

{

sjf temp;

temp=p[i];

p[i]=p[j];

p[j]=temp;

} } void deal(sjf *p, float arrivetime,float servicetime,float starttime,float finishtime,int N1)//運行階段

{ int k;

for(k=0;k<=N1-1;k++)

{

if(k==0)

{

p[k].starttime=p[k].arrivetime;

p[k].finishtime=p[k].arrivetime+float(p[k].servicetime)/60;}

else

{

p[k].starttime=p[k-1].finishtime;

p[k].finishtime=p[k-1].finishtime+float(p[k].servicetime)/60;}

}

}

void sjff(sjf *p,int N1){

float arrivetime=0,servicetime=0,starttime=0,finishtime=0;

sort(p,N1);

for(int m=0;m

{if(m==0)

p[m].finishtime=p[m].arrivetime+float(p[m].servicetime)/60;

else

p[m].finishtime=p[m-1].finishtime+float(p[m].servicetime)/60;

int i=0;

for(int n=m+1;n<=N1-1;n++)

{

if(p[n].arrivetime<=p[m].finishtime)

i++;

}

float min=p[m+1].servicetime;

int next=m+1;

for(int k=m+1;k

{

if(p[k+1].servicetime

{min=p[k+1].servicetime;

next=k+1;}

}

sjf temp;

temp=p[m+1];

p[m+1]=p[next];

p[next]=temp;

}

deal(p,arrivetime,servicetime,starttime,finishtime,N1);

Print(p,arrivetime,servicetime,starttime,finishtime,N1);

getchar();}//最短進程優先調度算法到這里結束

char menu()//用來輸出相關信息的函數

{

char cse1;

while(1)

{

system(“cls”);

fflush(stdin);

cout<

cout<

cout<<“t”<<“|| <<<<<<<<<<<<歡<<<<<<<<<<< >>>>>>>>>>>>迎>>>>>>>>>>> ||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“||”<<“t 進程調度算法模擬”<<“tt”<<“||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“||”<<“tt 1.先來先服務調度算法 ”<<“tt”<<“||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“||”<<“tt 2.最短進程優先調度算法”<<“tt”<<“||”<

cout<<“t”<<“||

||”<

cout<<“t”<<“|| <<<<<<<<<<<<<<<<<<<<<<<<<您>>>>>>>>>>>>>>>>>>>>>>>>> ||”<

cout<

cout<

cout<<“tt

請輸入您的選擇（1/2）：”;

cse1=getchar();

if(cse1<'1'||cse1>'2')

cout<<“你的輸入有錯！”<

else

break;

}

return cse1;} int main(int argc, char *argv[]){

while(1)

{

switch(menu())

{

case '1':

int N;

cout<

cout<

printf(“tt<<---！!@@@先來先服務調度算法@@@！!--->>n”);

cout<

printf(“輸入進程數目:”);

scanf(“%d”,&N);

input(a,N);

FCFS(a,N);

case '2':

int N1;

cout<

cout<

printf(“tt<<---！!@@@最短進程優先調度算法@@@！!--->>n”);

cout<

printf(“輸入進程數目: ”);

scanf(“%d”,&N1);

input(a1,N1);

sjf *b=a1;

sjf *c=a1;

sjff(b,N1);

getchar();

}

}

system(“PAUSE”);

return EXIT_SUCCESS;}

五、實驗結果

1.執行結果

2.結果分析

先來先服務調度算法就是根據進程達到的時間為依據，哪一個進程先來那么該進程就會先執行；最短進程優先調度算法則是以每個進程執行所需時間長短為依據，某一個進程執行所需花的時間要短些那么該進程就先執行。以上就是本次進程調度實驗的依據。

六、實驗總結

通過本次實驗了解到算法很重要，又更加明白算法本身可以節約時間，而且不同的函數之間在調用的時候要注意很多的問題。

第五篇：操作系統 單處理機系統的進程調度

一.實驗內容描述

1.目的

（1）了解Windows內存管理器（2）理解Windows的地址過程 2.內容

任意給出一個虛擬地址，通過WinDbg觀察相關數據并找到其物理地址

二.理論分析

Windows采用頁式虛擬存儲管理技術管理內存，頁面是硬件級別上的最小保護單位 1.Windows內存管理器

Windows的內存管理主要由Windows執行體中的虛存管理程序負責，并由環境子系統負責，并由環境子系統負責與具體API相關的一些用戶態特性的實現。虛存管理程序是Windows中負責內存管理的那些子程序和數據結構的集合 內存管理器的主要任務是：

地址變換：將一個進程的虛擬地址空間轉譯為物理內存地址

交換：當內存不足時，將內存中的有些內容轉移到磁盤上，并且以后還要再次將這些內容讀回

2.Windows內存管理策略

Windows采用頁式虛擬存儲管理技術管理內存，頁面是硬件級別上最小的保護單位。根據硬件的體系結構不同，頁面尺寸被分為兩種，大頁面和小頁面。X86系統下小頁面為4KB，大頁面為4MB。大頁面的優點是：當引用同一頁面內其他數據時，地址轉移的速度會很快。不過使用大頁面通常要較大的內存空間，而且必須用一個單獨的保護項來映射，因此可能會造成出現錯誤而不引發內存訪問違例的情況。通常PC機都為小頁面 3.Windows虛擬地址空間布局 x86結構下的布局方式：

默認情況下，32位Windows系統中每個用戶進程可以占有2GB的私有地址空間。操作系統占有另外的2GB 2GB用戶的進程地址空間布局如表：

2GB的系統地址空間布局如同：

3.虛擬地址轉譯

地址轉譯是指將進程的虛擬地址空間映射到實際物理頁面的過程。x86系統中地址轉譯過程如圖：

關鍵數據結構如下： 頁目錄：每個進程都有一個頁目錄，它是內存管理器為了映射進程中所有的頁表位置而創建的一個頁面。進程也目錄的地址被保存在內核進程快KPROCESS中，在x86系統上，它被映射到虛擬地址0xC0300000，當一個進程正在執行時，CPU可以通過寄存器CR3知道該進程頁目錄的位置。頁目錄由目錄項（PDE）構成，每個PDE長4字節，描述了該進程中所有可能的頁表的狀態和位置。其格式和PTE類似。x86系統上，要描述完整的4GB虛擬地址空間，需要1024個頁表。因此映射這些頁表的進程頁目錄需包含1024個PDE，恰好占用一個頁面。

頁表：進程的頁目錄項指向頁表。每個頁表占用一個頁面，由1024項PTE組成。一個有效的PTE大小為4字節，包含兩個主域：數據所在的物理頁面的頁面幀編號（PNF）或者內存中一個頁面的物理地址的PFN；一些描述該頁面狀態和保護屬性的標志。

虛擬地質結構：x86系統上，一個32位虛擬地址被解釋為三個單獨的部分，頁目錄索引、頁表索引和字節索引。由于頁目錄項有1024個，因此頁目錄索引為10位；一個也表中含有1024個PTE。因此頁表索引也為10位，字節索引為12位，正好表示一頁（4KB）內容

三.實驗步驟及結果

1.查找頁目錄首地址

以程序WG.exe作為觀測對象。

啟動WinDbg到內核調試模式，運行程序WG.exe。終斷目標機運行，輸入命令：kd>!process

發現WG.exe進程正處于運行狀態 輸入命令：

在KPROCESS中名為DirectoryTableBase的域，對應值為0x9fa6000，即WG.exe進程頁目錄的物理地址 查看CR3寄存其中的內容，輸入命令：

CR3寄存其中的值和KPROCESS中記錄的頁目錄基址相同。這是因為在CPU切換執行任務時，其內容要更新為當前進程的頁目錄基址。2.地址轉譯過程

假設給定的虛擬地址為0x401001 輸入命令：

可以看到：

PDE的虛擬地址為C0300004.PTE的虛擬地址為C0001004 最后一行信息“pfn 9e4a---DA--UWEV”表示PDE中的具體內容，9e4a是給定虛擬地址所在頁表在內存中對應的物理頁號，“---DA—UWEV”是標志信息，“pfn a173----A--UREV”表示PTE中的具體內容，a173是數據頁裝入內存的物理頁號。

將數據頁對應的物理頁號a173加上業內索引（0x1）即可得到虛擬地址0x401001的物理地址

3.觀察系統頁表

給定觀測虛擬地址為0x80001001 輸入命令：

當前正在執行的進程是：WG.exe 輸入命令：

得到PDE為C0300800，其對應的物理頁號為3b 繼續讓目標機運行，啟動A.exe，然后中斷目標機運行。輸入命令：

當前正在執行的進程為A.exe 輸入命令：

PDE信息和對應的物理頁號與前面觀測到的相同

四.結論

1.數據頁對應的物理頁號加上相應業內索引即可得到虛擬地址的物理地址 2.不同的進程頁目錄都指向了相同的系統表頁

五.心得體會

在這次上機實驗，通過對WinDbg和VPc的調試運用，我熟悉了Windows內存管理器的結構，也認知到Windows如何進行地址轉譯和轉換。對相關的知識也進行了溫習，更牢的掌握了相關知識。當然這些還遠遠不夠，我以后還要繼續不斷努力，去學習了解掌握操作系統的各方面知識。

附錄：

1.A.exe代碼

#include #include

#define N 1

HANDLE mutexSemaphore;HANDLE synchSemaphore_1;HANDLE synchSemaphore_2;

HANDLE mutexDisplay;

void Display(char*str,int delayTime){ if(WaitForSingleObject(mutexDisplay,INFINITE)==WAIT_OBJECT_0){ printf(“%snn”,str);ReleaseMutex(mutexDisplay);Sleep(delayTime);} }

void useTime(double limit){ for(double i=0;i<=limit;i+=0.001);}

void CreateProduct(){ Display(“Creating a production...”,0);useTime(200000);Display(“Creating finished.”,100);}

void PutProduct(){ Display(“Putting a production...”,0);useTime(150000);Display(“Putting finished”,100);}

void GetProduct(){ Display(“Getting a production...”,0);useTime(100000);Display(“Getting finished.”,100);}

void ConsumeProduct(){ Display(“Cosuming a production...”,0);useTime(100000);Display(“Cosuming finished.”,100);}

void Producer(){ while(true){ CreateProduct();

if(WaitForSingleObject(synchSemaphore_1,INFINITE)==WAIT_OBJECT_0){

if(WaitForSingleObject(mutexSemaphore,INFINITE)==WAIT_OBJECT_0){ PutProduct();ReleaseSemaphore(mutexSemaphore,1,NULL);} ReleaseSemaphore(synchSemaphore_2,1,NULL);} } }

void Consumer(){ while(true){

if(WaitForSingleObject(synchSemaphore_2,INFINITE)==WAIT_OBJECT_0){

if(WaitForSingleObject(mutexSemaphore,INFINITE)==WAIT_OBJECT_0){ GetProduct();ReleaseSemaphore(mutexSemaphore,1,NULL);} ReleaseSemaphore(synchSemaphore_1,1,NULL);} ConsumeProduct();} }

int main(){ HANDLE thread[2];DWORD threadID[2];

synchSemaphore_1=CreateSemaphore(NULL,N,N,NULL);synchSemaphore_2=CreateSemaphore(NULL,0,N,NULL);mutexSemaphore=CreateSemaphore(NULL,1,1,NULL);

mutexDisplay=CreateMutex(NULL,FALSE,NULL);

printf(“Program start.Please use WinDbg to observe main thread.nPress any key to continue...n”);getchar();

thread[0]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Producer),NULL,CREATE_SUSPENDED,&threadID[0]);printf(“A producer was created.Please use WinDbg to observe producer thread.nPress any key to continue...n”);getchar();

thread[1]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Consumer),NULL,CREATE_SUSPENDED,&threadID[1]);printf(“A Consumer was created.Please use WinDbg to observe Consumer thread.nPress any key to continue...n”);getchar();

printf(“Please select:n[1]Make producer thread runn[2]Make Consumer thread runn”);bool flag=true;bool flag_1=true,flag_2=true;int count=0;while(flag){ if(getchar()=='1'&&flag_1){ ResumeThread(thread[0]);count++;flag_1=false;} else if(getchar()=='2'&&flag_2){ ResumeThread(thread[1]);count++;flag_2=false;} if(count==2)flag=false;} WaitForMultipleObjects(1,thread,TRUE,INFINITE);

return 0;}

2.WG.exe代碼： #include

int main(){ int a=0;printf(“I'm Wangn”);while(true){a++;} }