當前位置:首頁 » 操作系統 » 時間輪演算法

時間輪演算法

發布時間: 2022-02-01 06:45:19

❶ 程序調度(時間片輪轉演算法)用C語言程序怎麼寫啊謝謝

#include<stdio.h>
struct
pcb
{
char
name;
int
time;
};
void
main()
{
int
n,i,j,flag=1;
struct
pcb
a[100];
printf("輸入程序個數:");
scanf("%d",&n);
getchar();/*接收回車*/
for(i=0;i<n;i++)
{
printf("輸入程序的名字:如A
B
C...\n");
scanf("%c",&a[i].name);
getchar();/*接收回車*/
printf("輸入佔用的時間片:");
scanf("%d",&a[i].time);
getchar();/*接收回車*/
}
i=0;
while(flag
&&
n>0)
{
if(a[i].time!=0)
{
printf("%c",a[i].name);
a[i].time--;
}
for(j=0;j<n;j++)
if(a[j].time)
{
flag=1;
break;
}
else
flag=0;
i=(++i)%n;
}
}

❷ 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);
}

❸ 時間片輪轉調度演算法

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
typedef struct node
{
char name[10]; /*進程標識符*/
int prio; /*進程優先數*/
int round; /*進程時間輪轉時間片*/
int cputime; /*進程佔用CPU時間*/
int needtime; /*進程到完成還要的時間*/
int count; /*計數器*/
char state; /*進程的狀態*/
struct node *next; /*鏈指針*/
}PCB;
PCB *finish,*ready,*tail,*run; /*隊列指針*/
int N; /*進程數*/
/*將就緒隊列中的第一個進程投入運行*/
firstin()
{
run=ready; /*就緒隊列頭指針賦值給運行頭指針*/
run->state='R'; /*進程狀態變為運行態*/
ready=ready->next; /*就緒對列頭指針後移到下一進程*/
}
/*標題輸出函數*/
void prt1(char a)
{
if(toupper(a)=='P') /*優先數法*/
printf(" name cputime needtime priority state\n");
else
printf(" name cputime needtime count round state\n");
}
/*進程PCB輸出*/
void prt2(char a,PCB *q)
{
if(toupper(a)=='P') /*優先數法的輸出*/
printf(" %-10s%-10d%-10d%-10d %c\n",q->name,
q->cputime,q->needtime,q->prio,q->state);
else/*輪轉法的輸出*/
printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,
q->cputime,q->needtime,q->count,q->round,q->state);
}
/*輸出函數*/
void prt(char algo)
{
PCB *p;
prt1(algo); /*輸出標題*/
if(run!=NULL) /*如果運行指針不空*/
prt2(algo,run); /*輸出當前正在運行的PCB*/
p=ready; /*輸出就緒隊列PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
p=finish; /*輸出完成隊列的PCB*/
while(p!=NULL)
{
prt2(algo,p);
p=p->next;
}
getch(); /*壓任意鍵繼續*/
}
/*優先數的插入演算法*/
insert1(PCB *q)
{
PCB *p1,*s,*r;
int b;
s=q; /*待插入的PCB指針*/
p1=ready; /*就緒隊列頭指針*/
r=p1; /*r做p1的前驅指針*/
b=1;
while((p1!=NULL)&&b) /*根據優先數確定插入位置*/
if(p1->prio>=s->prio)
{
r=p1;
p1=p1->next;
}
else
b=0;
if(r!=p1) /*如果條件成立說明插入在r與p1之間*/
{
r->next=s;
s->next=p1;
}
else
{
s->next=p1; /*否則插入在就緒隊列的頭*/
ready=s;
}
}
/*輪轉法插入函數*/
insert2(PCB *p2)
{
tail->next=p2; /*將新的PCB插入在當前就緒隊列的尾*/
tail=p2;
p2->next=NULL;
}
/*優先數創建初始PCB信息*/
void create1(char alg)
{
PCB *p;
int i,time;
char na[10];
ready=NULL; /*就緒隊列頭指針*/
finish=NULL; /*完成隊列頭指針*/
run=NULL; /*運行隊列指針*/
printf("Enter name and time of process\n"); /*輸入進程標識和所需時間創建PCB*/
for(i=1;i<=N;i++)
{
p=malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->state='w';
p->prio=50-time;
if(ready!=NULL) /*就緒隊列不空調用插入函數插入*/
insert1(p);
else
{
p->next=ready; /*創建就緒隊列的第一個PCB*/
ready=p;
}
}
clrscr();
printf(" output of priority:\n");
printf("************************************************\n");
prt(alg); /*輸出進程PCB信息*/
run=ready; /*將就緒隊列的第一個進程投入運行*/
ready=ready->next;
run->state='R';
}
/*輪轉法創建進程PCB*/
void create2(char alg)
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("Enter name and time of round process\n");
for(i=1;i<=N;i++)
{
p=malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->count=0; /*計數器*/
p->state='w';
p->round=2; /*時間片*/
if(ready!=NULL)
insert2(p);
else
{
p->next=ready;
ready=p;
tail=p;
}
}
clrscr();
printf(" output of round\n");
printf("************************************************\n");
prt(alg); /*輸出進程PCB信息*/
run=ready; /*將就緒隊列的第一個進程投入運行*/
ready=ready->next;
run->state='R';
}
/*優先數調度演算法*/
priority(char alg)
{
while(run!=NULL) /*當運行隊列不空時,有進程正在運行*/
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
run->prio=run->prio-3; /*每運行一次優先數降低3個單位*/
if(run->needtime==0) /*如所需時間為0將其插入完成隊列*/
{
run->next=finish;
finish=run;
run->state='F'; /*置狀態為完成態*/
run=NULL; /*運行隊列頭指針為空*/
if(ready!=NULL) /*如就緒隊列不空*/
firstin(); /*將就緒對列的第一個進程投入運行*/
}
else /*沒有運行完同時優先數不是最大,則將其變為就緒態插入到就緒隊列*/
if((ready!=NULL)&&(run->prio<ready->prio))
{
run->state='W';
insert1(run);
firstin(); /*將就緒隊列的第一個進程投入運行*/
}
prt(alg); /*輸出進程PCB信息*/
}
}
/*時間片輪轉法*/
roundrun(char alg)
{
while(run!=NULL)
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
run->count=run->count+1;
if(run->needtime==0)/*運行完將其變為完成態,插入完成隊列*/
{
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
firstin(); /*就緒對列不空,將第一個進程投入運行*/
}
else
if(run->count==run->round) /*如果時間片到*/
{
run->count=0; /*計數器置0*/
if(ready!=NULL) /*如就緒隊列不空*/
{
run->state='W'; /*將進程插入到就緒隊列中等待輪轉*/
insert2(run);
firstin(); /*將就緒對列的第一個進程投入運行*/
}
}
prt(alg); /*輸出進程信息*/
}
}
/*主函數*/
main()
{
char algo; /*演算法標記*/
clrscr();
printf("type the algorithm:P/R(priority/roundrobin)\n");
scanf("%c",&algo); /*輸入字元確定演算法*/
printf("Enter process number\n");
scanf("%d",&N); /*輸入進程數*/
if(algo=='P'||algo=='p')
{
create1(algo); /*優先數法*/
priority(algo);
}
else
if(algo=='R'||algo=='r')
{
create2(algo); /*輪轉法*/
roundrun(algo);
}
}

❹ 時間片輪轉調度演算法如何選擇時間片的大小

時間片輪轉演算法。
時間片不是相等的嗎?!!
難道您說的是時間片不相同的時間片輪轉。
那就是按照事件的優先順序來排序了。
看看linux源代碼。O(1)演算法。
你會明白很多。

❺ 時間片輪轉調度演算法的演算法

多級反饋隊列調度演算法
(1) 設置多個就緒隊列,並為各個隊列賦予不同的優先順序. 第一個隊列的優先順序最高,第二個隊列次之,其餘各隊列的優先權逐個降低.
該演算法賦予各個隊列中進程執行時間片的大小也各不相同:
在優先權愈高的隊列中,為每個進程所規定的執行時間片就愈小.
例如:第二個隊列的時間片要比第一個隊列的時間片長一倍,……,第i+1個隊列的時間片要比第i個隊列的時間片長一倍.
(2) 當一個新進程進入內存後,首先將它放入第一隊列的末尾,按FCFS原則排隊等待調度.當輪到該進程執行時,如它能在該時間片內完成,便可准備撤離系統;如果它在一個時間片結束時尚未完成,調度程序便將該進程轉入第二隊列的末尾,再同樣地按FCFS原則等待調度執行;如果它在第二隊列中運行一個時間片後仍未完成,再依次將它放入第三隊列,……,如此下去,當一個長作業(進程)從第一隊列依次降到第n隊列後,在第n隊列中便採取按時間片輪轉的方式運行.
(3) 僅當第一隊列空閑時,調度程序才調度第二隊列中的進程運行; 僅當第1~(i-1) 隊列均空時,才會調度第i隊列中的進程運行.如果處理機正在第i隊列中為某進程服務時,又有新進程進入優先權較高的隊列(第1~(i-1)中的任何一個隊列),則此時新進程將搶占正在運行進程的處理機,即由調度程序把正在運行的進程放回到第i隊列的末尾,把處理機分配給新到的高優先權進程.?
性能
(1)終端型作業用戶
(2) 短批處理作業用戶
(3) 長批處理作業用戶
滿足了多數用戶的需求 優先權調度演算法
1,優先權調度演算法的類型
非搶占式優先權演算法
在這種方式下,系統一旦把處理機分配給就緒隊列中優先權最高的進程後,該進程便一直執行下去,直至完成; 或因發生某事件使該進程放棄處理機時,系統方可再將處理機重新分配給另一優先權最高的進程.這種調度演算法主要用於批處理系統中;也可用於某些對實時性要求不嚴的實時系統中.
搶占式優先權調度演算法
系統同樣把處理機分配給優先權最高的進程,使之執行.但在其執行期間,只要又出現了另一個其優先權更高的進程,進程調度程序就立即停止當前進程(原優先權最高的進程)的執行,重新將處理機分配給新到的優先權最高的進程.
這種搶占式的優先權調度演算法,能更好地滿足緊迫作業的要求,常用於要求比較嚴格的實時系統中, 以及對性能要求較高的批處理和分時系統中.
2,優先權的類型
(1) 靜態優先權
靜態優先權是在創建進程時確定的,且在進程的整個運行期間保持不變.
一般地,優先權是利用某一范圍內的一個整數來表示的,例如,0~7或0~255中的某一整數, 又把該整數稱為優先數.只是具體用法各異:有的系統用0表示最高優先權,當數值愈大時,其優先權愈低;而有的系統恰恰相反.
確定進程優先權的依據有如下三個方面:
1.進程類型.(系統進程/用戶進程)
2.進程對資源的需求.(需求量的大小)
3.用戶要求.(用戶進程緊迫程度)
(2) 動態優先權
動態優先權是指在創建進程時所賦予的優先權,可以隨進程的推進或隨其等待時間的增加而改變的,以便獲得更好的調度性能.
例如,我們可以規定,在就緒隊列中的進程,隨其等待時間的增長,其優先權以速率a提高.若所有的進程都具有相同的優先權初值,則顯然是最先進入就緒隊列的進程,將因其動態優先權變得最高而優先獲得處理機,此即FCFS演算法.
優先權的變化規律可描述為:
由於等待時間與服務時間之和,就是系統對該作業的響應時間,故該優先權又相當於響應比RP.據此,又可表示為:
3,高響應比優先調度演算法
由上面的式子可以得到以下結論:
(1) 如果作業的等待時間相同,則要求服務的時間愈短,其優先權愈高,因而該演算法有利於短作業.
(2) 當要求服務的時間相同時,作業的優先權決定於其等待時間,等待時間愈長,其優先權愈高,因而它實現的是先來先服務.
(3) 對於長作業,作業的優先順序可以隨等待時間的增加而提高,當其等待時間足夠長時,其優先順序便可升到很高, 從而也可獲得處理機.
該演算法照顧了短作業,且不會使長作業長期得不到服務 1. 非搶占式調度演算法
為每一個被控對象建立一個實時任務並將它們排列成一輪轉隊列,調度程序每次選擇隊列中的第一個任務投入運行.該任務完成後便把它掛在輪轉隊列的隊尾等待下次調度運行.
2. 非搶占式優先調度演算法.
實時任務到達時,把他們安排在就緒隊列的對首,等待當前任務自我終止或運行完成後才能被調度執行.
3. 搶占式調度演算法
1)基於時鍾中斷的搶占式優先權調度演算法.
實時任務到達後,如果該任務的優先順序別高於當前任務的優先順序並不立即搶占當前任務的處理機,而是等到時鍾中斷到來時,調度程序才剝奪當前任務的執行,將處理機分配給新到的高優先權任務.
2)立即搶占的優先權調度演算法.
在這種調度策略中,要求操作系統具有快速響應外部時間中斷的能力.一旦出現外部中斷,只要當前任務未處於臨界區便立即剝奪當前任務的執行,把處理機分配給請求中斷的緊迫任務,實時進程調度,實時進程搶占當前。 1 實現實時調度的基本條件
1-1. 提供必要的信息-就緒時間.
1-2. 開始截止時間和完成截止時間.
1-3. 處理時間.
1-4. 資源要求.
1-5. 優先順序.
2. 系統處理能力強
在實時系統中,通常都有著多個實時任務.若處理機的處理能力不夠強,則有可能因處理機忙不過來而使某些實時任務不能得到及時處理, 從而導致發生難以預料的後果.假定系統中有m個周期性的硬實時任務,它們的處理時間可表示為Ci,周期時間表示為Pi,則在單處理機情況下,系統可調度必須滿足下面的限制條件:
當系統不可調度時解決的方法是提高系統的處理能力,其途徑有二:
其一仍是採用單處理機系統,但須增強其處理能力, 以顯著地減少對每一個任務的處理時間;
其二是採用多處理機系統.假定系統中的處理機數為N,則應將上述的限制條件改為:
3. 採用搶占式調度機制
當一個優先權更高的任務到達時,允許將當前任務暫時掛起,而令高優先權任務立即投入運行.採用這種方式去滿足那些開始截止時間即將到來的任務.?
4. 具有快速切換機制
應具有的能力:
(1) 對外部中斷的快速響應能力.為使在緊迫的外部事件請求中斷時系統能及時響應,要求系統具有快速硬體中斷機構,還應使禁止中斷的時間間隔盡量短,以免耽誤時機(其它緊迫任務).?
(2) 快速的任務分派能力.在完成任務調度後,便應進行任務切換.為了提高分派程序進行任務切換時的速度, 應使系統中的每個運行功能單位適當的小,以減少任務切換的時間開銷.實時調度實例
一, 最早截止時間優先演算法(EDF)
EDF演算法用於非搶占調度方式
優先順序:根據任務的開始截止時間來確定任務的優先順序.
二,最低鬆弛優先演算法(LLF)
例如:系統中有兩個周期性實時任務A和B,任務A要求每20ms執行一次,執行時間為10ms;任務B要求每50ms執行一次,執行時間為25ms.這樣可知A和B每次必須完成的時間和開始截止時間如圖所示
優先順序:根據任務緊急程度來確定任務優先順序
A和B任務每次必須完成的時間
A1 (10) A2 (30) A3(50) A4 (70) A5(90) A6 (110) A7(130) A8(150)
0 、10、 20、 30 、40、 50 、60、 70、 80 、90 、100 、110、 120、130、 140、 150
B1(25) B2(75) B3(125)
A和B任務每次必須開始的時間
時間(ms) A截止時間 B截止時間 調度對象
0 A1(10) B1(25) A1
10 A2(20) B1(15) B1
30 A2(0) B1(15) A2
40 A3(10) B1(5) B1
45 A3(5) B2(30) A3
55 A4(15) B2(20) B2
70 A4(0) B2(20) A4
鬆弛度
鬆弛度
( 20-10-0 ) ( 50-25-0 )
(40-10-10 ) ( 50-25-10 )
(40-10-30) (50-5-30)
(60-10-40) (50-5-40)
(60-10-45) (100-25-45)
(80-10-55) (100-25-55)
(80-10-70) (100-10-70 )
3.4.1 多處理器系統的類型
(1) 緊密耦合(Tightly Coupted)MPS.
這通常是通過高速匯流排或高速交叉開關,來實現多個處理器之間的互連的.它們共享主存儲器系統和I/O設備,並要求將主存儲器劃分為若干個能獨立訪問的存儲器模塊,以便多個處理機能同時對主存進行訪問.系統中的所有資源和進程,都由操作系統實施統一的控制和管理.
3.4 多處理機系統中的調度
從處理器之間耦合的緊密程度上劃分:
鬆散耦合(Loosely Coupled)MPS.
在鬆散耦合MPS中,通常是通過通道或通信線路,來實現多台計算機之間的互連.每台計算機都有自己的存儲器和I/O設備,並配置了OS來管理本地資源和在本地運行的進程.因此,每一台計算機都能獨立地工作, 必要時可通過通信線路與其它計算機交換信息,以及協調它們之間的工作.
根據系統中所用處理器的相同與否劃分:
(1) 對稱多處理器系統SMPS. 在系統中所包含的各處理器單元,在功能和結構上都是相同的,當前的絕大多數MPS都屬於SMP系統.例如,IBM公司的SR/6000 Model F50, 便是利用4片Power PC處理器構成的.?
(2) 非對稱多處理器系統.在系統中有多種類型的處理單元,它們的功能和結構各不相同,其中只有一個主處理器,有多個從處理器:
1. 對稱多處理器系統中的進程分配方式
在SMP系統中,所有的處理器都是相同的,因而可把所有的處理器作為一個處理器池(Processor pool),由調度程序或基於處理器的請求,將任何一個進程分配給池中的任何一個處理器去處理.在進行進程分配時,可採用以下兩種方式之一.
1) 靜態分配(Static Assigenment)方式
2) 動態分配(Dynamic Assgement)方式?
3.4.2 進程分配方式
靜態分配(Static Assigenment)方式
一個進程從開始執行直到完成,都被固定分配到一個處理器上去執行.
2) 動態分配(Dynamic Assgement)方式
系統中設置有公共的就緒隊列.分配進程時,可以將進程分配到任何一個處理器上.
動態分配方式的主要優點是消除了各處理器忙閑不均的現象
2. 非對稱MPS中的進程分配方式?
對於非對稱MPS,其OS大多採用主—從(Master-Slave)式OS,即OS的核心部分駐留在一台主機上(Master),而從機(Slave)上只是用戶程序,進程調度只由主機執行.每當從機空閑時,便向主機發送一索求進程的信號,然後,便等待主機為它分配進程.在主機中保持有一個就緒隊列,只要就緒隊列不空,主機便從其隊首摘下一進程分配給請求的從機.從機接收到分配的進程後便運行該進程,該進程結束後從機又向主機發出請求.
缺點:對主機要求高,出現故障導致整個系統癱瘓
1. 自調度(Self-Scheling)方式
1) 自調度機制?
在系統中設置有一個公共的進程或線程就緒隊列, 所有的處理器在空閑時,都可自己到該隊列中取得一進程(或線程)來運行.在自調度方式中,可採用在單處理機環境下所用的調度演算法,如先來先服務(FCFS)調度演算法,最高優先權優先(FPF)調度演算法和搶占式最高優先權優先調度演算法等.
3.4.3 進程(線程)調度方式
2) 自調度方式的優點?
1,系統中的公共就緒隊列可按照單處理機系統中所採用的各種方式加以組織;其調度演算法也可沿用單處理機系統所用的演算法,即很容易將單處理機環境下的調度機制移植到多處理機系統中
2,只要系統中有任務(公共就緒隊列不空)就不會出現處理機空閑的情況,也不會發生處理器忙閑不均的現象,因而有利於提高處理器的利用率.
3)自調度方式的缺點
3.4.4進程調度過程
1、進程名:作為進程的標識。
指針:進程按順序排成循環鏈表,用指針指出下一個進程的進程式控制制塊首地址,最後一個進程中的指針指出第一個進程的進程式控制制塊首地址。
2、要求運行時間:假設進程需要運行的單位時間數。
已運行時間:假設進程已經運行的單位時間數,初值為0。
狀態:可假設有兩種狀態,就緒狀態和結束狀態。進程的初始狀態都為就緒狀態。
3、每次運行所設計的處理器調度程序調度進程之前,為每個進程任意確定它的要求運行時間。
4、此程序是模擬處理器調度,因此,被選中的進程並不實際啟動運行,而是執行
已運行時間+1
來模擬進程的一次運行,表示進程已經運行過一個單位時間。
.5、在所設計的程序中應有顯示或列印語句,能顯示或列印每次被選中的進程名以及運行一次後進程隊列的變化。
6、為進程任意確定要求運行時間,運行所設計的處理器調度程序,顯示或列印逐次被選中進程的進程名以及進程式控制制塊的動態變化過程。
7、設有一個就緒隊列,就緒進程按優先數(優先數范圍0-100)由小到大排列(優先數越小,級別越高)。當某一進程運行完一個時間片後,其優先順序應下調(如優先數加2或3)。
8、例如一組進程如下表: 進程名 A B C D E F G H J K L M 到達時間 0 1 2 3 6 8 12 12 12 18 25 25 服務時間 6 4 10 5 1 2 5 10 4 3 15 8

❻ 實驗目的:了解時間片輪轉演算法的基本原理

答:若某一時間片還未用完,有新的進程請求調度,則會優先調度新的進程。附:時間片輪轉調度是一種最古老,最簡單,最公平且使用最廣的演算法是時間片調度。每個進程被分配一個時間段,稱作它的時間片,即該進程允許運行的時間。如果在時間片結束

❼ 操作系統的時間片輪轉法具體的演算法

四、演算法實現
1)系統初始化時給每一個進程賦以一個needtime,並將所有進程按needtime從小到大的次序排成一個隊列。
2) 取隊頭進程,並投入運行。
3) 採用相對固定時間片(Time_piece),進程每執行一次,進程佔用的CPU時間加Time_piece。
4) 若進程沒有運行完,進程needtime減Time,並排到就緒隊列的尾部。
5) 如果尚有進程在隊列中,那麼轉入2)
PCB結構:N 進程個數
name 進程名
Time_piece 進程優先數/進程輪轉時間片
Cpu_time 進程佔用的CPU時間
Need_time 進程到完成還要的時間
Count 計數器
State 進程狀態(P,W,F)
Arrive_time到達時間
next 鏈指針
run 當前運行進程指針
start 就緒隊列頭指針
end 就緒隊列尾指針
finish 完成隊列頭指針
void insert(PCB *p) //時間片插入函數
void create() //時間片演算法創建進程函數
void roundrobin() //時間片演算法函數
void firstin() //運行就緒隊列的第一個進程

你可以到這個地址下載文章看一下。
'http://wenku..com/view/f3bca1d333d4b14e85246830.html'

❽ 關於時間片輪轉演算法

答:若某一時間片還未用完,有新的進程請求調度,則會優先調度新的進程。

附:
時間片輪轉調度是一種最古老,最簡單,最公平且使用最廣的演算法是時間片調度。每個進程被分配一個時間段,稱作它的時間片,即該進程允許運行的時間。如果在時間片結束時進程還在運行,則CPU將被剝奪並分配給另一個進程。如果進程在時間片結束前阻塞或結束,則CPU當即進行切換。調度程序所要做的就是維護一張就緒進程列表,當進程用完它的時間片後,它被移到隊列的末尾。

熱點內容
我的世界可以建組織的新伺服器 發布:2023-02-01 11:14:02 瀏覽:890
des演算法破解 發布:2023-02-01 11:01:31 瀏覽:556
安卓機關機設置在哪裡 發布:2023-02-01 10:58:43 瀏覽:202
密碼箱有什麼樣子 發布:2023-02-01 10:57:15 瀏覽:899
集合文件夾 發布:2023-02-01 10:56:18 瀏覽:63
刺刀編程 發布:2023-02-01 10:56:07 瀏覽:381
90番號ftp 發布:2023-02-01 10:56:07 瀏覽:816
ftp刪除命令 發布:2023-02-01 10:52:25 瀏覽:877
qq空間訪問排名 發布:2023-02-01 10:51:39 瀏覽:867
qq泄露資料庫 發布:2023-02-01 10:44:22 瀏覽:154