輪轉rr演算法

A. 操作系統時間片輪轉演算法中，新進程到來時是插入在就緒隊列隊首還是隊尾，為什麼

那得看什麼情況了 如果是一級 那就到隊尾
如果不是一級那就復雜了
比如：我在網上看到的一道題：
設一個系統中有5個進程，他們的到達時間和服務時間如下表所示，忽略I/O以及其他開銷時間，若分別按先來先服務（FCFS）、非搶占短進程優先（SPF）、高響應比優先（HRRN）、時間片輪轉（RR，時間片=1）、多級反饋隊列（FB，第i級隊列的時間片=2i-1）調度演算法進行CPU調度，請給出各進程的完成時間、周轉時間、平均周轉時間、帶權周轉時間、平均帶權周轉時間

進程 到達時間 服務時間
A 0 3
B 2 6
C 4 4
D 6 5
E 8 2

具體流程：時間片第一級1s，第二級2s，第三級4s...優先順序第一級>第二級>第三級...首先A進入第一級執行1s，進入第二級，由於此時B還沒有到達，所以A在第二級執行2s，完成，此時是第3s。B第2s已進入第一級，此時回到第一級B執行1s進入第二級，4s的時候c進入第一級，C執行1s進入第二級排在B的後面。此時候為5S，D沒有到達，第一級沒有進程，所以第二級B執行2S，進入第三級，此時為7S，D已進入第一級，D執行一S，轉入第二級排在C後面，8S，E進入第一級，執行一S，進入第二級，排在D後面。第一級沒有進程，第二級的C執行2S，進入第三級，D執行2s進入第三級，E執行1S完成，此時是14S。第二級沒有進程，由第三級的D開始，執行3S完成，此時是17S，C執行1S完成，此時是18S，D執行2S完成，此時是20S。所以答案是，3，17，18，20，14

B. 操作系統中關於時間片輪轉調度演算法！大家幫解答下！

時間片第一級1s，第二級2s，第三級4s...優先順序第一級>第二級>第三級...首先A進入第一級執行1s，進入第二級，由於此時B還沒有到達，所以A在第二級執行2s，完成，此時是第3s。B第2s已進入第一級，此時回到第一級B執行1s進入第二級，4s的時候c進入第一級，C執行1s進入第二級排在B的後面。此時候為5S，D沒有到達，第一級沒有進程，所以第二級B執行2S，進入第三級，此時為7S，D已進入第一級，D執行一S，轉入第二級排在C後面，8S，E進入第一級，執行一S，進入第二級，排在D後面。第一級沒有進程，第二級的C執行2S，進入第三級，D執行2s進入第三級，E執行1S完成，此時是14S。第二級沒有進程，由第三級的D開始，執行3S完成，此時是17S，C執行1S完成，此時是18S，D執行2S完成，此時是20S。所以答案是，3，17，18，20，14

C. 進程創建；運行進程；基於優先順序的調度演算法。

讓他加內容提供方軟體能讓他

D. C語言編程實現時間片輪轉演算法，盡量寫得簡單易懂，謝謝

#include<stdlib.h>
#define MAX 5 //進程數量
#define RR 2 //時間片大小

/*時間片輪轉演算法*/

struct pro
{
int num;
int arriveTime;
int burst;
int rt; //記錄進程被運行的次數
struct pro *next;
};

int TOTALTIME; //記錄所有進程的總時間

//函數聲明
struct pro* creatList();
void insert(struct pro *head,struct pro *s);
struct pro* searchByAT(struct pro *head,int AT);
void del(struct pro* p);
int getCount(struct pro *head,int time);
struct pro* searchEnd(struct pro *head);
void move(struct pro *headF,struct pro *headT,int n);

struct pro* creatList() //創建鏈表，按照進程的到達時間排列,記錄所有進程的信息
{
struct pro* head=(struct pro*)malloc(sizeof(struct pro));
head->next=NULL;
struct pro* s;
int i;
TOTALTIME=0;
for(i=0;i<MAX;i++)
{
s=(struct pro*)malloc(sizeof(struct pro));
printf("請輸入進程名:\n");
scanf("%d",&(s->num));
printf("請輸入到達時間:\n");
scanf("%d",&(s->arriveTime));
printf("請輸入運行時間:\n");
scanf("%d",&(s->burst));
TOTALTIME+=s->burst; //計算總時間
s->rt=1; //rt的初始值為1
s->next=NULL;
insert(head,s);
}
return head; //到達隊列中的進程按照其到達時間的先後順序排列
}

void insert(struct pro *head,struct pro *s) //插入節點
{
struct pro *p=searchByAT(head,s->arriveTime);
s->next=p->next;
p->next=s;
return;
}

struct pro* searchByAT(struct pro *head,int AT) //查找第一個到達時間大於等於AT的節點，返回其前一個指針
{
struct pro *p,*q;
p=head;
q=head->next;
while(q!=NULL&&q->arriveTime<=AT)
{
p=q;
q=q->next;
}
return p;
}

void del(struct pro* p) //刪除p的下一個節點
{
struct pro *tmp;
tmp=p->next;
p->next=tmp->next;
free(tmp);
return;
}

int getCount(struct pro *head,int time) //察看在time之前到達但未移動到運行隊列的進程數量
{
int count=0;
struct pro *s,*t;
s=head;
t=s->next;
while(t!=NULL&&t->arriveTime<=time)
{
s=t;
t=t->next;
count++; //count記錄當前時刻到達的進程數
}
return count;
}

struct pro* searchEnd(struct pro *head) //查找並返回循壞隊列的尾節點的前一個節點
{
struct pro *p,*q;
p=head;
q=head->next;
while(q->next!=head)
{
p=q;
q=q->next;
}
return p;
}

void move(struct pro *headF,struct pro *headT,int n) //將headF後的n個節點移動到循環隊列headT中
{
struct pro *r,*s,*t;
s=headF;
t=s->next;
r=t; //r記錄要移動的第一個節點
while(n>1)
{
t=t->next;
n--;
}
s->next=t->next; //以上完成從原隊列中摘除相關節點,r,t分別為第一個和最後一個節點
s=searchEnd(headT);
t->next=s->next;
s->next=r;
}

void run(struct pro *head)
{
int time=0; //記錄當前時間
int newarrive;//新到達進程數
struct pro *runhead=(struct pro*)malloc(sizeof(struct pro));
runhead->next=runhead; //創建新的循環鏈表，存放當前就緒隊列中的進程
struct pro *p,*q;
p=runhead;
q=p->next; //q記錄當前應當運行的進程
while(time<=TOTALTIME)
{
newarrive=getCount(head,time);
if(newarrive>0)
move(head,runhead,newarrive); //將head後的newarrive個節點移動到runhead隊列中
if(runhead->next==runhead) //就緒隊列中沒有進程
time++;
else if(q==runhead)
{
p=q;
q=q->next;
}
else
{
printf("進程名:%d\n",q->num);
printf("到達時間:%d\n",q->arriveTime);
if(q->rt==1)
printf("響應時間:%d\n",time-q->arriveTime);
else
printf("第%d次運行開始時間:%d\n",q->rt,time);
if(q->burst<=RR)
{
time+=q->burst;
printf("第%d次運行結束時間:%d\n",q->rt,time);
printf("周轉時間:%d\n",time-q->arriveTime);
printf("************************************\n");
struct pro *tmp=q;
q=q->next;
p->next=q;
free(tmp);
}
else //q->burst>RR
{
time+=RR;
printf("第%d次運行結束時間:%d\n",q->rt,time);
printf("************************************\n");
q->burst-=RR;
q->rt++;
p=q;
q=q->next;
}
}
}
}

void main()
{
struct pro *head=creatList();
printf("當前時間片大小為:%d\n",RR);
run(head);
}

E. 考慮一種RR(時間片輪轉)調度演算法的變種,演算法中就緒隊列中存放的是指向各個進程式控制

#include 「stdio.h」
#define running 1 // 用running表示進程處於運行態
#define aready 2 // 用aready表示進程處於就緒態
#define blocking 3 // 用blocking表示進程處於阻塞態
#define sometime 5 // 用sometime表示時間片大小
#define n 10 //假定系統允許進程個數為n
struct
{
int name; //進程標識符
int status; //進程狀態
int ax,bx,cx,dx ; //進程現場信息，通用寄存器內容
int pc ; //進程現場信息，程序計數器內容
int psw; //進程現場信息，程序狀態字內容
int next; //下一個進程式控制制塊的位置
}pcbarea[n]; //模擬進程式控制制塊區域的數組
int PSW, AX,BX,CX,DX , PC ,TIME ; //模擬寄存器
int run; //定義指向正在運行進程的進程式控制制塊的指針
struct
{
int head;
int tail;
}ready; //定義就緒隊列的頭指針head和尾指針tail
int pfree; //定義指向空閑進程式控制制塊隊列的指針

scheling( ) //進程調度函數
{
int i;
if (ready.head==-1) //空閑進程式控制制塊隊列為空，退出
{
printf(「無就緒進程\n」);
return;
}
i=ready.head; //就緒隊列頭指針賦給i
ready.head=pcbarea[ready.head].next; //就緒隊列頭指針後移
if(ready.head==-1) ready.tail=-1; //就緒隊列為空，修正尾指針ready.tail
pcbarea[i].status=running; //修改進程式控制制塊狀態
TIME=sometime; //設置相對時鍾寄存器
//恢復該進程現場信息
AX=pcbarea[run].ax;
BX=pcbarea[run].bx;
CX=pcbarea[run].cx;
DX=pcbarea[run].dx;
PC=pcbarea[run].pc;
PSW=pcbarea[run].psw;
run=i;
}//進程調度函數結束

create(int x) //進程創建函數
{
int i;
if(pfree==-1) //空閑進程式控制制塊隊列為空
{
printf(「無空閑進程式控制制塊，進程創建失敗\n」);
return;
}
i=pfree; //取空閑進程式控制制塊隊列的第一個
pfree=pcbarea[pfree].next; // pfree後移
//填寫該進程式控制制塊的內容
pcbarea[i].name=x;
pcbarea[i].status=aready;
pcbarea[i].ax=x;
pcbarea[i].bx=x;
pcbarea[i].cx=x;
pcbarea[i].dx=x;
pcbarea[i].pc=x;
pcbarea[i].psw=x;
if (ready.head!=-1) //就緒隊列不為空時，掛入就緒隊列的方式
{
pcbarea[ready.tail].next=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
else //就緒隊列為空時，掛入就緒隊列的方式
{
ready.head=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
}//進程創建函數結束

main()
{ //系統初始化
int num,i,j;
run=ready.head=ready.tail =-1;
pfree=0;
for(j=0;j<n-1;j++)
pcbarea[j].next=j+1;
pcbarea[n-1].next=-1;
printf(「輸入進程編號（避免編號沖突，以負數輸入結束，最多可以創建10個進程）：\n」);
scanf(「%d」,num);
while(num>=0)
{
create(num) ;
scanf(「%d」,num) ;
}
scheling(); //進程調度
if(run!=-1)
{
printf(「進程標識符 進程狀態 寄存器內容：ax bx cx dx pc psw:\n」);
printf(「%8d%10d%3d%3d%3d%3d%3d%3d\n」, pcbarea[run].name, pcbarea[run].status, pcbarea[run].ax, pcbarea[run].bx, pcbarea[run].cx, pcbarea[run].dx, pcbarea[run].pc, pcbarea[run].psw);
}
}//main()結束
我用的是vc++6.0的，你可以試試，有不懂得在和我交流吧

F. 在時間片輪轉調度中,如果一個進程在一個時間片內就已經運行結束,那剩下的時間片時間怎麼利用

如果進程在時間片結束前阻塞或結束，則CPU當即進行切換。結束的進程會從運行隊列中清除，剩下的時間片隨進程結構的清除而清除，並不影響到其他進程的調度。

時間片由操作系統內核的調度程序分配給每個進程。首先，內核會給每個進程分配相等的初始時間片，然後每個進程輪番地執行相應的時間，當所有進程都處於時間片耗盡的狀態時，內核會重新為每個進程計算並分配時間片，如此往復。

在每個進程的task_struct結構中有以下四項：policy、priority、counter、rt_priority。這四項是選擇進程的依據。其中，policy是進程的調度策略，用來區分實時進程和普通進程，實時進程優先於普通進程運行；priority是進程(包括實時和普通)的靜態優先順序。

counter是進程剩餘的時間片，它的起始值就是priority的值；由於counter在後面計算一個處於可運行狀態的進程值得運行的程度goodness時起重要作用，因此，counter也可以看作是進程的動態優先順序。rt_priority是實時進程特有的，用於實時進程間的選擇。

(6)輪轉rr演算法擴展閱讀：

時間片長度的影響：

時間片輪轉調度中特別需要關注的是時間片的長度。從一個進程切換到另一個進程是需要一定時間的--保存和裝入寄存器值及內存映像，更新各種表格和隊列等。

假如進程切換(process switch) - 有時稱為上下文切換(context switch)，需要5毫秒，再假設時間片設為20毫秒，則在做完20毫秒有用的工作之後，CPU將花費5毫秒來進行進程切換。CPU時間的20%被浪費在了管理開銷上。

為了提高CPU效率，我們可以將時間片設為500毫秒。假設所有其他進程都用足它們的時間片的話，最後一個不幸的進程不得不等待5秒鍾才獲得運行機會。多數用戶無法忍受一條簡短命令要5秒鍾才能做出響應。同樣的問題在一台支持多道程序的個人計算機上也會發生。

結論可以歸結如下：時間片設得太短會導致過多的進程切換，降低了CPU效率；而設得太長又可能引起對短的交互請求的響應變差。

G. 時間片輪轉演算法（RR）能不能用在作業調度上還是只能用在進程調度上

導師給出的答案是不能，但是吧友似乎有一些別的看法。
先來看作業調度的定義，高級調度又稱長程調度或作業調度，他的調度對象是作業。主要功能是根據演算法，決定將外存處於後備隊列的哪幾個作業調入內存，為他們創建進程，分配必要的資源，並將它們放入就緒隊列。分時和實時系統不設置高級調度。
其次簡單的敘述一下低級調度（進程調度）：對象為進程，功能是決定就緒隊列中的哪個進程應獲得處理機，並分配。
最後來看一下RR的核心，進程切換：在RR調度演算法中，應在合適進行進程的切換，可分為兩種情況：1，若一個時間片尚未用完，正在運行的進程便已經完成，立刻激活調度程序，將他從就緒隊列中刪除，再調度就緒隊列中對手的進程運行，並啟動一個新的時間片。2.在一個時間片用完時，計時調度器中斷處理程序被激活。如果進程尚未運行完畢，調度程序將把它送往就緒隊列的末尾。
可見，RR演算法在切換進程時只涉及了就緒隊列的c、a、o作，也就是只有低級調度參與，並沒有從外存將作業調入內存，另外，RR演算法常用於分時系統，分時系統也是不設置作業調度的。

H. 雲計算：資源調度管理的目錄

第1章 雲計算概述
1.1 雲計算發展背景
1.2 雲計算是集大成者
1.3 為什麼需要雲計算？
1.4 雲計算發展現狀和趨勢
1.5 雲計算應用初步分類
1.6 雲計算的產業鏈中的不同角色
1.7 雲計算主要特徵和技術挑戰
1.8 小結
思考題
參考文獻
第2章 雲數據中心概述
2.1 雲數據中心概述
2.1.1 雲數據中心介紹
2.1.2 雲數據中心的需求和挑戰
2.2 雲計算數據中心資源調度需求分析
2.2.1 技術需求
2.2.2 技術目標
2.3 雲計算數據中心資源調度研究進展
2.4 雲計算數據中心資源調度方案分析
2.4.1 goosle解決方案
2.4.2 amazon解決方案
2.4.3 1bm解決方案
2.4.4 hp解決方案
2.4.5 vmware解決方案
2.4.6 其他廠家解決方案
2.5 雲計算數據中心資源調度標准進展
2.6 雲計算數據中心資源調度關鍵技術及研究熱點
2.7 小結
思考題
參考文獻
第3章 雲資源定義與建模
3.1 引言
3.2 雲數據中心資源建模
3.2.1 雲數據中心多級體系結構
3.2.2 雲數據中心涉及的資源
3.3 雲數據中心資源定義
3.4 資源管理
3.5 小結
思考題
參考文獻
第4章 雲資源管理
4.1 概述
4.1.1 面向基礎設施搭建的管理軟體
4.1.2 面向能效設備控制的管理軟體
4.1.3 面向虛擬化的數據中心管理軟體
4.2 雲數據中心資源管理的內容
4.2.1 用戶管理
4.2.2 任務管理
4.2.3 資源管理
4.3 資源管理的目標
4.3.1 自動化
4.3.2 資源優化
4.3.3 簡潔管理
4.3.4 虛擬資源與物理資源的整合
4.4 資源管理的關鍵問題
4.4.1 動態多層次分布式資源監控
4.4.2 物理和虛擬資源動態調度
4.4.3 物理和虛擬資源動態快速部署與維護
4.5 數據中心管理系統案例分析
4.6 小結
思考題
參考文獻
第5章 雲資源調度策略
5.1 資源調度關鍵技術
5.2 雲計算數據中心調度策略對比分析
5.2.1 amazon調度策略
5.2.2 1bm調度策略
5.2.3 hp調度策略
5.2.4 vmware調度策略
5.2.5 其他方案
5.3 主要調度策略分類
5.3.1 性能優先
5.3.2 成本優先
5.4 調度策略約束條件
5.5 調度任務執行時間和觸發條件
5.6 小結
附：基本術語
思考題
參考文獻
第6章 雲資源負載均衡調度演算法的分析與設計
6.1 雲計算數據中心綜合負載均衡調度策略概述
6.2 雲計算數據中心負載均衡調度策略中主要調度演算法分析
6.2.1 輪轉調度演算法(rr)
6.2.2 加權輪轉調度演算法(wrr)
6.2.3 目標地址哈希調度演算法(dh)
6.2.4 源地址哈希調度演算法(sh)
6.2.5 最小鏈接演算法(lc)
6.2.6 加權最小鏈接演算法(wlc)
6.3 幾種動態綜合負載均衡調度演算法分析
6.3.1 綜合利用率乘積法
6.3.2 綜合負載基準對比法
6.3.3 動態反饋綜合負載均衡調度演算法
6.4 負載均衡調度演算法對比
6.5 動態反饋綜合負載均衡調度演算法詳細設計
6.5.1 優化目標
6.5.2 動態反饋綜合負載均衡調度演算法
6.6 小結
思考題
參考文獻
第7章 雲數據中心資源調度模擬系統
7.1 簡介
7.2 現有系統分析
7.2.1 cloudsim
7.2.2 cloudanalyst
7.3 cloudsched模擬系統設計框架
7.4 模擬系統分析——以考慮需求特性的調度演算法為例
7.4.1 考慮需求特性調度演算法解決的問題
7.4.2 考慮需求特性調度演算法主要步驟
7.4.3 考慮需求特性調度演算法流程圖
7.4.4 考慮需求特性調度演算法偽代碼
7.4.5 演算法類圖
7.4.6 演算法時序圖
7.5 各種演算法結果分析
7.5.1 其他演算法思想簡介
7.5.2 4種演算法數據中心不均衡度對比
7.5.3 4種演算法物理伺服器不均衡度對比
7.5.4 4種演算法運行時間對比
7.6 小結
思考題
參考文獻
第8章 總結與展望
附錄i 虛擬伺服器管理系統vmmanager
附i.1 簡介
附i.2 體系結構
附i.3 用戶界面設計
附i.4 安裝與配置
附i.5 vmmanager使用說明
附錄ii 雲計算模擬分析器cloudanalyst
附ii.1 cloudanalyst的安裝過程
附ii.2 cloudanalyst的運行過程及配量方法

I. 處理機調度可以分為

在多道程序設計系統中，內存中有多道程序運行，他們相互爭奪處理機這一重要的資源。處理機調度就是從就緒隊列中，按照一定的演算法選擇一個進程並將處理機分配給它運行，以實現進程並發地執行。
1.處理機調度的功能
一般情況下，當佔用處理機的進程因為某種請求得不到滿足二不得不放棄CPU進入等待狀態時，或者當時間片到，系統不得不將CPU分配給就緒隊列中另以進程的時候，都要引起處理機調度。除此之外，進程正常結束、中斷處理等也可能引起處理機的調度。因此，處理機調度是操作系統核心的重要組成部分，它的主要功能如下：
（1）記住進程的狀態，如進程名稱、指令計數器、程序狀態寄存器以及所有通用寄存器等現場信息，將這些信息記錄在相應的進程式控制制塊中。
（2）根據一定的演算法，決定哪個進程能獲得處理機，以及佔用多長時間。
（3）收回處理機，即正在執行的進程因為時間片用完或因為某種原因不能再執行的時候，保存該進程的現場，並收回處理機。
處理機調度的功能中，很重要的一項就是根據一定演算法，從就緒隊列中選出一個進程佔用CPU運行。可見，演算法是處理機調度的關鍵。
2.處理機調度的性能准則
處理機調度，有許多不問的調度演算法，不同的調度演算法具有不同的特性。因此，再介紹演算法之前，先介紹衡量一個演算法的基本准則。
衡量喝比較調度演算法性能優劣主要有一下幾個因素：
（1）CPU利用率。CPU是計算機系統中最重要的資源，所以應盡可能使CPU保持忙，使這一資源利用率最高。
（2）吞吐量。CPU運行時表示系統正處於工作狀態，工作量的大小是以每單位時間所完成的昨夜樹木來描述的，這就叫吞吐量。
（3）周轉時間。指從作業提交到作業完成所經過的時間，包括作業等待，在就緒隊列中排隊，在處理機上運行以及進行輸入/輸出操作所花時間的總和。
（4）等待時間。處理機調度演算法實際上並不影響作業執行或輸入/輸出操作的時間，隻影響作業在就緒隊列中等待所花的時間。因此，衡量一個調度演算法優劣常常簡單的考察等待時間。
（5）響應時間。指從作業提交到系統作出相應所經過的時間。在互動式系統中，作業的周轉時間並不一定是最好的衡量准則，因此，常常使用另一種度量准則，即相應時間。從用戶觀點看，相應時間應該快一點好，但這常常要犧牲系統資源利用率為代價。
3.處理機調度演算法
1）先來先服調度演算法（FIFO）
這是最簡單的處理機調度演算法，其基本思想是按照進程進入就緒隊列的先後順序調度並分配處理機執行。先來先服務調度演算法是一種不可搶占的演算法，先進入就緒隊列的進程，先費培處理機運行。一旦一個進程佔有了處理機，它就一直運行下去，知道該進程完成工作或者因為等待某事件而不能繼續運行時才釋放處理機。
從表面上看，FIFO演算法對所有作業都是公平的，並且一個作業的等待時間時可能預先估計的。但實際上這種演算法是不利於小作業的，因為當一個大作業先進入就緒隊列時，就會使其後的許多小作業等待很長的時間。這對小作業來說，等待時間可能要遠遠超出它運行的時間。
先來先服演算法簡單，易於程序實現，但它性能較差，在實際運行的操作系統中，很少單獨使用，它常常配合其他調度演算法一起使用。
2）時間片輪轉調度演算法（RR）
時間片輪轉調度演算法的基本思想是：對就緒隊列中的每一進程部分配一個時間片，時間片的長度q一般從10ms-1100ms不等。把就緒隊列堪稱時一個環狀結構，調度程序按時間片長度q輪流電鍍就緒隊列中的每一進程，使每一進程都有機會獲得相同長度的時間佔用處理機運行。
時間片輪轉調度演算法在分時系統中，時一種既簡單又有效的調度策略。一個分時系統又許多中斷。中斷用戶在各自的中斷設備上同時使用計算機。如果某個中斷用戶的程序長時間的暫用處理機，那麼其他中斷用戶的請求就不能得到即使相應。一般說來，中斷用戶提出請求後，能在幾秒鍾內得到相應也就感到滿意了。採用時間片輪轉演算法，可以使系統即使的相應各中斷用戶的請求。
時間片輪轉調度演算法的性能極大的以來於時間片長度q的取值，如果時間片過大。則RR演算法就退化為FIFO演算法了；反之，如果時間片過小，那麼，處理機在各進程之間頻繁轉接，處理機時間開銷變得很大，而提供給用戶程序的時間將大大減少。

J. 模擬短作業優先演算法、時間片輪轉演算法（RR）和優先數演算法的執行情況

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#define LENsizeof(struct job)

struct job
{
char name[2];
int cometime;
int runtime;
int priority;
int finishtime;
int state;
struct job *next;
};

void readtxt();
void SJF();
void (structjob *,struct job *);
void RR(int);
void FPF();
void print1(structjob *);
void print2(structjob *);

int n=0;
struct job*head=NULL;
struct job*end=NULL;
FILE*fp=NULL;

void main()
{
if((fp=fopen("JOB1.txt","rb"))==NULL){
printf("can not find file\n");
exit(0);
}
while(!feof(fp)){
readtxt();
}
fclose(fp);

int x,y;
printf("請選擇進程調度演算法：\n");
printf("1.短作業優先演算法 2.時間片輪轉演算法 3.優先數演算法\n");
printf("選擇序號：");
scanf("%d",&x);
if((x!=1)&&(x!=2)&&(x!=3))printf("序號不存在！\n");
else{
switch(x){
case 1: SJF(); break;
case 2: {
printf("輸入時間片：");
scanf("%d",&y);
RR(y);
break;
}
case 3: FPF(); break;
}
}
}

void readtxt(){
struct job *p1;
p1=(struct job *)malloc(LEN);
fscanf(fp,"%s %d %d%d",(*p1).name,&((*p1).cometime),&((*p1).runtime),&((*p1).priority));
(*p1).state=0;
(*p1).finishtime=0;
if(n==0){
head=p1;
end=p1;
(*end).next=NULL;
n++;
}
else{
(*end).next=p1;
end=p1;
(*end).next=NULL;
n++;
}
}

void SJF(){
struct job *shead,*send,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).runtime<(*p1).runtime)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
shead=p;
send=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).runtime<(*p1).runtime)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*send).next=p;
send=p;
}
(*send).next=NULL;
printf("%s\n","短作業優先演算法執行結果：");
printf("%s\n","進程執行順序 周轉時間");
print1(shead);
}

void RR(intpertime){
structjob *rhead,*rend,*rrhead,*rrend,*p1,*p2,*p;
int i,curtime=0,m=0,temp1=0,temp2;
while(m!=n){
p1=head;
temp2=temp1;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).runtime!=0)&&((*p1).state!=1)){temp1++;break;}
else p1=(*p1).next;
}
if(p1!=NULL){
p2=(*p1).next;
for(i=i+1;i<n;i++){
if((((*p2).cometime<(*p1).cometime)&&((*p2).runtime!=0)&&((*p2).state!=1))||
(((*p2).cometime==(*p1).cometime)&&((*p2).priority<(*p1).priority)&&((*p2).runtime!=0)&&((*p2).state!=1)))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
}

if(temp2!=temp1){
(*p1).state=1;
p=(struct job *)malloc(LEN);
(p,p1);
if(temp1==1) {rhead=p;rend=p;}
else{
(*rend).next=p;
rend=(*rend).next;
}
}
else{
if((temp1==1)&&(m==0)){
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
}
p=(struct job *)malloc(LEN);
(p,rhead);
rrhead=p;
rrend=p;
}
else{
if(strcmp((*rhead).name,(*rrend).name)==0){
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}

}
else{
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}
}
}
}
}
(*rrend).next=NULL;
printf("%s%d%s\n","時間片輪轉演算法執行結果(時間片",pertime,")：");
print2(rrhead);
}

void FPF(){
structjob *fhead,*fend,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).priority<(*p1).priority)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
fhead=p;
fend=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).priority<(*p1).priority)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*fend).next=p;
fend=p;
}
(*fend).next=NULL;
printf("%s\n","最高優先權優先演算法執行結果(非搶占方式)：");
printf("%s\n","進程執行順序 周轉時間");
print1(fhead);
}

void (structjob *p,struct job *p1){
strcpy((*p).name,(*p1).name);
(*p).cometime=(*p1).cometime;
(*p).runtime=(*p1).runtime;
(*p).priority=(*p1).priority;
(*p).finishtime=(*p1).finishtime;
(*p).state=(*p1).state;
}

void print1(structjob *p){
while(p!=NULL){
printf("%-14s%d\n",(*p).name,(*p).finishtime-(*p).cometime);
p=(*p).next;
}
}

void print2(structjob *p){
struct job *head;
head=p;
printf("%s\n","進程執行順序");
while(head!=NULL){
printf("%3s",(*head).name);
head=(*head).next;
}
printf("\n%s\n","進程周轉時間");
head=p;
while(head!=NULL){
if(((*head).finishtime-(*head).cometime)>0)
printf("%-4s%d\n",(*head).name,(*head).finishtime-(*head).cometime);
head=(*head).next;
}
}

網上找的，自己看著辦