短作業調度演算法實驗目的

❶ 關於作業調度的演算法怎麼寫

網路上搜一下就有了，我做這個就是找的

❷ 作業調度的功能是什麼作業調度演算法應考慮的主要因素是什麼

1、作業調度的主要功能是：

根據作業控制塊中的信息，審查系統能否滿足用戶作業的資源需求，以及按照一定的演算法，從外存的後備隊列中選取某些作業調入內存，並為它們創建進程、分配必要的資源。然後再將新創建的進程插入就緒隊列，准備執行。

2、主要考慮因素：

要考慮數據結構的設計、程序執行時間、數據的狀態、是否使得I / O 設備得以充分利用等因素。

通常情況下，對於簡單的時間觸發式調度器來說，待命任務列表的數據結構的設計要盡可能縮短；最壞情況下，程序在調度器關鍵部分的執行時間，以防止其他任務一直在待命列表中，無法及時執行。

因此，在這種調度器中，應盡可能避免搶占式任務，甚至應該關閉調度器之外的所有中斷。當然，待命任務列表的數據結構也應根據這個系統需要的最大任務數量做進一步的優化。

(2)短作業調度演算法實驗目的擴展閱讀

調度演算法應該做到：

1 、在單位時間內運行盡可能多的作業。

2 、作業調度時應使處理機保持忙碌的狀態。

3 、使 I / O 設備得以充分利用。為適應一個進程在不同時間段的運行特點，I/O完成時，提高優先順序；時間片用完時，降低優先順序。

4 、對所有作業公平合理。

5、僅當較高優先順序的隊列為空，才調度較低優先順序的隊列中的進程執行。如果進程執行時有新進程進入較高優先順序的隊列，則搶先執行新進程，並把被搶先的進程投入原隊列的末尾。

❸ 作業調度演算法思想是什麼

作業調度演算法：1、先來先服務演算法；2、短作業優先演算法；3、最高響應比作業優先演算法；4、資源搭配演算法；5、多隊列循環演算法

對演算法的選擇要考慮三個目標：
1、盡量提高系統的作業吞吐量，即每天處理盡可能多的作業；
2、盡量使CPU和外部設備保持忙碌狀態，以提高資源利用率；
3、對各種作業公平合理，使用有用戶都滿意。

❹ 如何理解先來先服務fcfs和短作業優先sjf進程調度演算法

先來先服務FCFS和短作業優先 和短作業優先SJF進程調度演算法 先來先服務 和短作業優先 進程調度演算法 1、實驗目的 通過這次實驗，加深對進程概念的理解，進一步掌握進程狀態的 轉變、進程調度的策略及對系統性能的評價方法。 2、需求分析 (1) 輸入的形式和輸入值的范圍 輸入值：進程個數Num 依次輸入Num個進程的到達時間 依次輸入Num個進程的服務時間 范圍：0<Num<=100 范圍： 范圍： 輸入要使用的演算法（1-FCFS，2-SJF） 范圍：1或者2 輸出的形式（ 表示變數） (2) 輸出的形式（X表示變數） 時刻X：進程X開始運行。 其完成時間：X 周轉時間：X 帶權周轉時 間：X …（省略（Num-1）個） 平均周轉時間：X 平均帶權周轉時間：X (3) 程序所能達到的功能 輸入進程個數Num，每個進程到達時間ArrivalTime[i]，服務時間 ServiceTime[i]。採用先來先服務FCFS或者短作業優先SJF進程調度算 法進行調度，計算每個進程的完成時間、周轉時間和帶權周轉時間， 並且統計Num個進程的平均周轉時間和平均帶權周轉時間。 3、概要設計 說明本程序中用到的所有抽象數據類型的定義、 主程序的流程以 及各程序模塊之間的層次(調用)關系。 4、詳細設計 5、調試分析 (1)調試過程中遇到的問題以及解決方法， (1)調試過程中遇到的問題以及解決方法，設計與實現的回顧討 調試過程中遇到的問題以及解決方法 論和分析 1 ○ 開始的時候沒有判斷進程是否到達， 導致短進程優先演算法運 開始的時候沒有判斷進程是否到達， 行結果錯誤，後來加上了判斷語句後就解決了改問題。 行結果錯誤，後來加上了判斷語句後就解決了改問題。 2 ○ 基本完成的設計所要實現的功能， 總的來說， FCFS編寫容易， 基本完成的設計所要實現的功能， 總的來說， FCFS編寫容易， 編寫容易 SJF 需要先找到已經到達的進程， 需要先找到已經到達的進程， 再從已經到達的進程里找到進程服務時 間最短的進程，再進行計算。 間最短的進程，再進行計算。 (2)算 (2)演算法的改進設想 改進： 改進：即使用戶輸入的進程到達時間沒有先後順序也能准確 的計算出結果。（就是再加個循環，判斷各個進程的到達時間先後， 的計算出結果。（就是再加個循環，判斷各個進程的到達時間先後， 。（就是再加個循環 組成一個有序的序列） 組成一個有序的序列） (3)經驗和體會 (3)經驗和體會 通過本次實驗， 通過本次實驗，深入理解了先來先服務和短進程優先進程調 度演算法的思想，培養了自己的動手能力，通過實踐加深了記憶。 度演算法的思想，培養了自己的動手能力，通過實踐加深了記憶。

❺ 常見的調度演算法總結

一、FCFS——先來先服務和短作業（進程）優先調度演算法

1. 先來先服務調度演算法。

先來先服務（FCFS）調度演算法是一種最簡單的調度演算法，該演算法既可用於作業調度， 也可用於進程調度。FCFS演算法比較有利於長作業（進程），而不利於短作業（進程）。由此可知，本演算法適合於CPU繁忙型作業， 而不利於I/O繁忙型的作業（進程）。

2. 短作業（進程）優先調度演算法。

短作業（進程）優先調度演算法（SJ/PF）是指對短作業或短進程優先調度的演算法，該演算法既可用於作業調度， 也可用於進程調度。但其對長作業不利；不能保證緊迫性作業（進程）被及時處理；作業的長短只是被估算出來的。

二、FPF高優先權優先調度演算法

1. 優先權調度演算法的類型。

為了照顧緊迫性作業，使之進入系統後便獲得優先處理，引入了最高優先權優先（FPF）調度演算法。 此演算法常被用在批處理系統中，作為作業調度演算法，也作為多種操作系統中的進程調度，還可以用於實時系統中。當其用於作業調度， 將後備隊列中若干個優先權最高的作業裝入內存。當其用於進程調度時，把處理機分配給就緒隊列中優先權最高的進程，此時， 又可以進一步把該演算法分成以下兩種：

1)非搶占式優先權演算法

2)搶占式優先權調度演算法（高性能計算機操作系統）

2. 優先權類型 。

對於最高優先權優先調度演算法，其核心在於：它是使用靜態優先權還是動態優先權， 以及如何確定進程的優先權。

3.動態優先權

高響應比優先調度演算法為了彌補短作業優先演算法的不足，我們引入動態優先權，使作業的優先等級隨著等待時間的增加而以速率a提高。 該優先權變化規律可描述為：優先權=（等待時間+要求服務時間）/要求服務時間；即 =（響應時間）/要求服務時間

三、基於時間片的輪轉調度演算法

1.時間片輪轉法。

時間片輪轉法一般用於進程調度，每次調度，把CPU分配隊首進程，並令其執行一個時間片。 當執行的時間片用完時，由一個記時器發出一個時鍾中斷請求，該進程被停止，並被送往就緒隊列末尾；依次循環。

2. 多級反饋隊列調度演算法

多級反饋隊列調度演算法多級反饋隊列調度演算法，不必事先知道各種進程所需要執行的時間，它是目前被公認的一種較好的進程調度演算法。 其實施過程如下：

1) 設置多個就緒隊列，並為各個隊列賦予不同的優先順序。在優先權越高的隊列中， 為每個進程所規定的執行時間片就越小。

2) 當一個新進程進入內存後，首先放入第一隊列的末尾，按FCFS原則排隊等候調度。 如果他能在一個時間片中完成，便可撤離；如果未完成，就轉入第二隊列的末尾，在同樣等待調度…… 如此下去，當一個長作業（進程）從第一隊列依次將到第n隊列（最後隊列）後，便按第n隊列時間片輪轉運行。

3) 僅當第一隊列空閑時，調度程序才調度第二隊列中的進程運行；

僅當第1到第（ i-1 ）隊列空時， 才會調度第i隊列中的進程運行，並執行相應的時間片輪轉。

4) 如果處理機正在處理第i隊列中某進程，又有新進程進入優先權較高的隊列， 則此新隊列搶占正在運行的處理機，並把正在運行的進程放在第i隊列的隊尾。

❻ 什麼是短作業優先的作業調度演算法

1.先來先服務調度演算法（FCFS）:就是按照各個作業進入系統的自然次序來調度作業。這種調度演算法的優點是實現簡單，公平。其缺點是沒有考慮到系統中各種資源的綜合使用情況，往往使短作業的用戶不滿意，因為短作業等待處理的時間可能比實際運行時間長得多。
2.短作業優先調度演算法(SPF): 就是優先調度並處理短作業，所謂短是指作業的運行時間短。而在作業未投入運行時，並不能知道它實際的運行時間的長短，因此需要用戶在提交作業時同時提交作業運行時間的估計值。
3.最高響應比優先演算法(HRN)：FCFS可能造成短作業用戶不滿，SPF可能使得長作業用戶不滿，於是提出HRN，選擇響應比最高的作業運行。響應比=1+作業等待時間/作業處理時間。
4. 基於優先數調度演算法(HPF)：每一個作業規定一個表示該作業優先順序別的整數，當需要將新的作業由輸入井調入內存處理時，優先選擇優先數最高的作業。
5.均衡調度演算法，即多級隊列調度演算法
基本概念：
作業周轉時間（Ti）＝完成時間(Tei)－提交時間(Tsi)
作業平均周轉時間(T)＝周轉時間/作業個數
作業帶權周轉時間（Wi）＝周轉時間/運行時間
響應比＝（等待時間＋運行時間）/運行時間

❼ 什麼是短作業優先的作業調度演算法

短作業優先（SJF, Shortest Job First）又稱為「短進程優先」SPN(Shortest Process Next)；這是對FCFS演算法的改進,其目標是減少平均周轉時間.
定義
對預計執行時間短的作業（進程）優先分派處理機.通常後來的短作業不搶先正在執行的作業.

❽ 關於短作業進程優先調度演算法。

我算了，起碼這數據是正確的

你看看

❾ 先來先服務調度演算法。 優先順序調度演算法。 短作業優先調度演算法 輪轉調度演算法 響應比高優先調度演算法

你試一下

#include<stdio.h>
//using namespace std;
#define MAX 10
struct task_struct
{
char name[10]; /*進程名稱*/
int number; /*進程編號*/
float come_time; /*到達時間*/
float run_begin_time; /*開始運行時間*/
float run_time; /*運行時間*/
float run_end_time; /*運行結束時間*/
int priority; /*優先順序*/
int order; /*運行次序*/
int run_flag; /*調度標志*/
}tasks[MAX];
int counter; /*實際進程個數*/
int fcfs(); /*先來先服務*/
int ps(); /*優先順序調度*/
int sjf(); /*短作業優先*/
int hrrn(); /*響應比高優先*/
int pinput(); /*進程參數輸入*/
int poutput(); /*調度結果輸出*/

void main()
{ int option;
pinput();
printf("請選擇調度演算法（0~4）:\n");
printf("1.先來先服務\n");
printf("2.優先順序調度\n");
printf(" 3.短作業優先\n");
printf(" 4.響應比高優先\n");
printf(" 0.退出\n");
scanf("%d",&option);
switch (option)
{case 0:
printf("運行結束。\n");
break;
case 1:
printf("對進程按先來先服務調度。\n\n");
fcfs();
poutput();
break;
case 2:
printf("對進程按優先順序調度。\n\n");
ps();
poutput();
break;
case 3:
printf("對進程按短作業優先調度。\n\n");
sjf();
poutput();
break;
case 4:
printf("對進程按響應比高優先調度。\n\n");
hrrn();
poutput();
break;
}
}
int fcfs() /*先來先服務*/
{
float time_temp=0;
inti;
intnumber_schel;
time_temp=tasks[0].come_time;
for(i=0;i<counter;i++)
{
tasks[i].run_begin_time=time_temp;
tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time;
tasks[i].run_flag=1;
time_temp=tasks[i].run_end_time;
number_schel=i;
tasks[number_schel].order=i+1;
}
return 0;
}

int ps() /*優先順序調度*/
{
float temp_time=0;
inti=0,j;
intnumber_schel,temp_counter;
intmax_priority;
max_priority=tasks[i].priority;
j=1;
while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].priority>tasks[i].priority)
{
max_priority=tasks[j].priority;
i=j;
}
j++;
} /*查找第一個被調度的進程*/
/*對第一個被調度的進程求相應的參數*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
max_priority=0;
for(j=0;j<counter;j++)
{if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if (tasks[j].priority>max_priority)
{
max_priority=tasks[j].priority;
number_schel=j;
}
} /*查找下一個被調度的進程*/
/*對找到的下一個被調度的進程求相應的參數*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;

}return 0;
}

int sjf() /*短作業優先*/
{
float temp_time=0;
inti=0,j;
intnumber_schel,temp_counter;
float run_time;
run_time=tasks[i].run_time;
j=1;
while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].run_time<tasks[i].run_time)
{
run_time=tasks[j].run_time;
i=j;
}
j++;
} /*查找第一個被調度的進程*/
/*對第一個被調度的進程求相應的參數*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
for(j=0;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{run_time=tasks[j].run_time;number_schel=j;break;}
}

for(j=0;j<counter;j++)
{if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if(tasks[j].run_time<run_time)
{run_time=tasks[j].run_time;
number_schel=j;
}
}
/*查找下一個被調度的進程*/
/*對找到的下一個被調度的進程求相應的參數*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;
}return 0;
}

int hrrn() /*響應比高優先*/
{ int j,number_schel,temp_counter;
float temp_time,respond_rate,max_respond_rate;
/*第一個進程被調度*/
tasks[0].run_begin_time=tasks[0].come_time;
tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time;
temp_time=tasks[0].run_end_time;
tasks[0].run_flag=1;
tasks[0].order=1;
temp_counter=1;
/*調度其他進程*/
while(temp_counter<counter)
{
max_respond_rate=0;
for(j=1;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{respond_rate=(temp_time-tasks[j].come_time)/tasks[j].run_time;
if (respond_rate>max_respond_rate)
{
max_respond_rate=respond_rate;
number_schel=j;
}
}
} /*找響應比高的進程*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].run_flag=1;
temp_counter+=1;
tasks[number_schel].order=temp_counter;
}
return 0;
}
int pinput() /*進程參數輸入*/
{ int i;
printf("please input the processcounter:\n");
scanf("%d",&counter);

for(i=0;i<counter;i++)
{printf("******************************************\n");
printf("please input the process of %d th :\n",i+1);
printf("please input the name:\n");
scanf("%s",tasks[i].name);
printf("please input the number:\n");
scanf("%d",&tasks[i].number);
printf("please input the come_time:\n");
scanf("%f",&tasks[i].come_time);
printf("please input the run_time:\n");
scanf("%f",&tasks[i].run_time);
printf("please input the priority:\n");
scanf("%d",&tasks[i].priority);
tasks[i].run_begin_time=0;
tasks[i].run_end_time=0;
tasks[i].order=0;
tasks[i].run_flag=0;
}
return 0;
}
int poutput() /*調度結果輸出*/
{
int i;
float turn_round_time=0,f1,w=0;
printf("name number come_time run_timerun_begin_time run_end_time priority order turn_round_time\n");
for(i=0;i<counter;i++)
{
f1=tasks[i].run_end_time-tasks[i].come_time;
turn_round_time+=f1;
w+=(f1/tasks[i].run_time);
printf(" %s, %d, %5.3f, %5.3f, %5.3f, %5.3f, %d, %d,%5.3f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time,tasks[i].priority,tasks[i].order,f1);
}
printf("average_turn_round_timer=%5.2f\n",turn_round_time/counter);
printf("weight_average_turn_round_timer=%5.2f\n",w/counter);
return 0;
}

❿ 什麼是作業調度程序起什麼作用

補充一下，作業調度又稱高級調度或長程調度，沒有作業控制塊的說法吧，進程才有進程式控制制塊。每次作業調度要考慮2個因素：1、接納多少個作業。這個取決於多道程序度（Degree of Multiprogamming），即同時允許多少個作業在內存中運行。太多影響系統性能，太低降低了系統的資源利用率和吞吐率。2、接納哪些作業。這個取決於調度演算法，調度的演算法很多，常見的就FCFS（先來先服務）、短作業優先調度演算法、高優先權調度演算法和基於時間片輪轉的演算法。