verilog帶權重的優先順序輪轉演算法

Ⅰ 基於優先數的時間片輪轉調度演算法調度處理器

沒有完全符合的,但是差不多的,你自己改改吧!
#include<iostream.h>
#include<stdlib.h>
#include<string.h>
typedef struct PCBA
{
char name[30];
int round;
int prio;
int cputime;
int needtime;
char state;
struct PCBA *next;
} PCB,*CurrentRunPCB,*LinkQueue;
CurrentRunPCB SelMosHeiPrio(LinkQueue *Q);//從Q鏈表中選擇一個優先順序最大的進程
void InitQueue(LinkQueue *Q);//初始化鏈表Q，如果鏈表沒有頭指針，可以省略；
void InsertQueue(LinkQueue * Q,PCB* run);
{
}//將Run結點插入鏈表Q中，表示就緒隊列里多了一個進程
void Priosch(LinkQueue Wait_Queue,LinkQueue Finish_Queue)//優先法運行，從就緒隊列Wait_Queue中選擇進程執行，（選擇隊列中優先順序最高的進程），執行結束的進程放入完成隊列中；

{ while (WaitQueue!=NULL)
{
CurrentRunPCB run=SelMosHeiPrio(&WaitQueue); //run為就緒隊列中優先順序最高的進程

run->cputime+=2;//時間片為2
run->needtime-=2;
run->prio=50-run->needtime;//動態優先順序，但是優先順序隨著運行時間的增加，優先順序增加，所以誰優先順序高會一直佔用CPU
run->state='r';
if(run->needtime>0)
{ run->state='w';
InsertQueue(&WaitQueue,run) ;
}

else
{cout<<"當前運行進稱為："<<run->name<<"運行結束後就緒隊列情況："<<'\n';
run->state='F';
run->needtime=0;
InsertQueue(&FinishQueue,run) ;
Print(&WaitQueue);
}
//當然可以採用不看進程運行過程，直接將優先順序高的運行完，插入完成隊列
/*
CurrentRunPCB run=SelMosHeiPrio(&WaitQueue);
cout<<"當前運行進稱為："<<run->name<<"運行結束後就緒隊列情況："<<'\n';
Print(&WaitQueue);
run->cputime=run->needtime;
run->needtime=0;
run->prio=50;//動態優先順序，但是優先順序隨著運行時間的增加，優先順序增加，所以誰優先順序高會一直佔用CPU
run->state='F';
InsertQueue(&FinishQueue,run) ;*/
}
void Print(LinkQueue*Q)//將隊列的元素顯示輸出，輸出包含進程名，進程CPUTIME,NEEDTIME,狀態，優先順序

{LinkQueue p=*Q;
cout<<"name cputime needtime state prio'"<<'\n';
while (p!=NULL)
{ cout<<p->name<<'\t'<<p->cputime<<'\t'<<p->needtime<<'\t'<<p->state<<'\t'<<p->prio<<'\n';
p=p->next;
}
}
CurrentRunPCB DeQueue(LinkQueue*Q)//從就緒隊列中取出一個進程

{LinkQueue p=*Q;

*Q=(*Q)->next;
p->next=NULL;
return p;
}
void Roundsch(LinkQueue WaitQueue,LinkQueue FinishQueue)//輪轉法運行，從就緒隊列Wait_Queue中選擇進程執行一個時間片，執行結束的進程放入完成隊列中；若一個時間片未能執行完的進程再插入到就緒隊列
{ while (WaitQueue!=NULL)
{
CurrentRunPCB run=DeQueue(&WaitQueue);
cout<<"當前運行進稱為："<<run->name<<"運行結束後就緒隊列情況："<<'\n';
run->cputime+=2;//時間片為2
run->needtime-=2;
run->prio=50- run->cputime;
run->state='r';
if(run->needtime>0)
{InsertQueue(&WaitQueue,run) ;
run->state='w';
}
else
{run->state='F';
run->needtime=0;
InsertQueue(&FinishQueue,run) ;
}

Print(&WaitQueue);
}
cout<<"完成隊列情況："<<'\n';
Print(&FinishQueue);
}

void SetAllpro(LinkQueue*Q)//設置優先順序函數50-p->needtime
{int max=0;
LinkQueue p,t;
t=NULL;
p=*Q;
if (p!=NULL)
{
max=p->prio;
p=p->next;
while(p)
{
if (max<p->prio) max=p->prio;
p=p->next;
}
p=*Q;
t=*Q;
if (t==p&&max==t->prio)
{*Q=(*Q)->next;
t->next=NULL;
return t;}
else{
t=t->next;
while(t)
{
if (max==t->prio)
{
p->next=t->next;
t->next=NULL;
return t;

}
else{p=t;
t=t->next;
}
}
}
}
return t;
}
void main()
{
PCBA *pcb0,*pcb1,*pcb2,*pcb3,*pcb4; //five processes 五個進程
LinkQueue Wait_Queue,Finish_Queue; //兩個隊列 等待和完成
Wait_Queue=NULL; //給隊列賦初值，如果帶有頭指針的鏈表，可以用函數；
Finish_Queue=NULL;
//InitQueue(&Wait_Queue);
//InitQueue(&Finish_Queue);
char ch;
//給各個進程設置初值
pcb0= new PCBA();
pcb1= new PCBA();
pcb2= new PCBA();
pcb3= new PCBA();
pcb4= new PCBA();
//example
strcpy(pcb0->name,"process1");
pcb0->round=2;
pcb0->prio=0;
pcb0->cputime=0;
pcb0->needtime=5;
pcb0->state='W';
pcb0->next=NULL;
strcpy(pcb1->name,"process2");
pcb1->round=2;
pcb1->prio=0;
pcb1->cputime=0;
pcb1->needtime=7;
pcb1->state='W';
pcb1->next=NULL;
strcpy(pcb2->name,"process3");
pcb2->round=2;
pcb2->prio=0;
pcb2->cputime=0;
pcb2->needtime=3;
pcb2->state='W';
pcb2->next=NULL;
strcpy(pcb3->name,"process4");
pcb3->round=2;
pcb3->prio=0;
pcb3->cputime=0;
pcb3->needtime=11;
pcb3->state='W';
pcb3->next=NULL;
strcpy(pcb4->name,"process5");
pcb4->round=2;
pcb4->prio=0;
pcb4->cputime=0;
pcb4->needtime=8;
pcb4->state='W';
pcb4->next=NULL;

//將各個進程插入就緒隊列中
InsertQueue(&Wait_Queue,pcb0);
InsertQueue(&Wait_Queue,pcb1);
InsertQueue(&Wait_Queue,pcb2);
InsertQueue(&Wait_Queue,pcb3);
InsertQueue(&Wait_Queue,pcb4);
//利用此演算法實現Wait_Queue中prio=50-needtime;
SetAllpro(&Wait_Queue);

cout<<"請輸入選擇的調度演算法(1 or 2 or anykey exit!)："<<endl;
cin>>ch;
switch(ch)
{
case '1':
Print(&Wait_Queue);
Roundsch(Wait_Queue,Finish_Queue);
break;
case '2':
Print(&Wait_Queue);
Priosch(Wait_Queue,Finish_Queue);
break;
default :
cout<<"你選擇了退出!"<<endl;
system("pause");
return;
}

return;
}

Ⅱ systemverilog中dist分配的權重怎麼計算

如果想在模擬中產生隨機數 vhdl可以使用math_real函數包中的uniform函數 得到一個real類型的歸一隨機數 可以對這個數進行其它處理來滿足具體要求 比如擴大倍數、截掉小數等 舉例如下（產生0~99的隨機整數） library ieee; use ieee.math_real.al...

Ⅲ 作業調度的多級反饋隊列

多級反饋隊列演算法(Round Robin with Multiple Feedback)是輪轉演算法和優先順序演算法的綜合和發展。 設置多個就緒隊列，分別賦予不同的優先順序，如逐級降低，隊列1的優先順序最高。每個隊列執行時間片的長度也不同，規定優先順序越低則時間片越長，如逐級加倍。
新進程進入內存後，先投入隊列1的末尾，按FCFS演算法調度；若按隊列1一個時間片未能執行完，則降低投入到隊列2的末尾，同樣按FCFS演算法調度；如此下去，降低到最後的隊列，則按「時間片輪轉」演算法調度直到完成。
僅當較高優先順序的隊列為空，才調度較低優先順序的隊列中的進程執行。如果進程執行時有新進程進入較高優先順序的隊列，則搶先執行新進程，並把被搶先的進程投入原隊列的末尾。 為提高系統吞吐量和縮短平均周轉時間而照顧短進程。
為獲得較好的I/O設備利用率和縮短響應時間而照顧I/O型進程。
不必估計進程的執行時間，動態調節 I/O型進程：讓其進入最高優先順序隊列，以及時響應I/O交互。通常執行一個小時間片，要求可處理完一次I/O請求的數據，然後轉入到阻塞隊列。
計算型進程：每次都執行完時間片，進入更低級隊列。最終採用最大時間片來執行，減少調度次數。
I/O次數不多，而主要是CPU處理的進程。在I/O完成後，放回優先I/O請求時離開的隊列，以免每次都回到最高優先順序隊列後再逐次下降。
為適應一個進程在不同時間段的運行特點，I/O完成時，提高優先順序；時間片用完時，降低優先順序。
優先順序演算法（Priority Scheling）是多級隊列演算法的改進，平衡各進程對響應時間的要求。適用於作業調度和進程調度，可分成搶先式和非搶先式。

Ⅳ 輪轉調度演算法中，帶權周轉時間怎麼算

周轉時間：從作業提交算起，直到執行完畢這段時間 帶權周轉時間：作業的周轉時間T與系統為其提供服務的服務時間之比 平均XX時間即算這些時間的數學期望值 響應比優先權：（等待時間+要求服務時間）/要求服務時間=響應時間/要求服務時間 FCFS: A[

Ⅳ 時間片輪轉演算法和優先順序調度演算法 C語言模擬實現

一、目的和要求
進程調度是處理機管理的核心內容。本實驗要求用高級語言編寫模擬進程調度程序，以便加深理解有關進程式控制制快、進程隊列等概念，並體會和了解優先數演算法和時間片輪轉演算法的具體實施辦法。
二、實驗內容
1.設計進程式控制制塊PCB的結構，通常應包括如下信息：
進程名、進程優先數（或輪轉時間片數）、進程已佔用的CPU時間、進程到完成還需要的時間、進程的狀態、當前隊列指針等。
2.編寫兩種調度演算法程序：
優先數調度演算法程序
循環輪轉調度演算法程序
3.按要求輸出結果。
三、提示和說明
分別用兩種調度演算法對伍個進程進行調度。每個進程可有三種狀態；執行狀態（RUN）、就緒狀態（READY,包括等待狀態）和完成狀態（FINISH），並假定初始狀態為就緒狀態。
（一）進程式控制制塊結構如下：
NAME——進程標示符
PRIO/ROUND——進程優先數/進程每次輪轉的時間片數（設為常數2）
CPUTIME——進程累計佔用CPU的時間片數
NEEDTIME——進程到完成還需要的時間片數
STATE——進程狀態
NEXT——鏈指針
註：
1.為了便於處理，程序中進程的的運行時間以時間片為單位進行計算；
2.各進程的優先數或輪轉時間片數，以及進程運行時間片數的初值，均由用戶在程序運行時給定。
（二）進程的就緒態和等待態均為鏈表結構，共有四個指針如下：
RUN——當前運行進程指針
READY——就需隊列頭指針
TAIL——就需隊列尾指針
FINISH——完成隊列頭指針
（三）程序說明
1. 在優先數演算法中，進程優先數的初值設為：
50-NEEDTIME
每執行一次，優先數減1，CPU時間片數加1，進程還需要的時間片數減1。
在輪轉法中，採用固定時間片單位（兩個時間片為一個單位），進程每輪轉一次，CPU時間片數加2，進程還需要的時間片數減2，並退出CPU，排到就緒隊列尾，等待下一次調度。
2. 程序的模塊結構提示如下：
整個程序可由主程序和如下7個過程組成：
（1）INSERT1——在優先數演算法中，將尚未完成的PCB按優先數順序插入到就緒隊列中；
（2）INSERT2——在輪轉法中，將執行了一個時間片單位（為2），但尚未完成的進程的PCB，插到就緒隊列的隊尾；
（3）FIRSTIN——調度就緒隊列的第一個進程投入運行；
（4）PRINT——顯示每執行一次後所有進程的狀態及有關信息。
（5）CREATE——創建新進程，並將它的PCB插入就緒隊列；
（6）PRISCH——按優先數演算法調度進程；
（7）ROUNDSCH——按時間片輪轉法調度進程。
主程序定義PCB結構和其他有關變數。
（四）運行和顯示
程序開始運行後，首先提示：請用戶選擇演算法，輸入進程名和相應的NEEDTIME值。
每次顯示結果均為如下5個欄位：
name cputime needtime priority state
註：
1．在state欄位中，"R"代表執行態，"W"代表就緒（等待）態，"F"代表完成態。
2．應先顯示"R"態的，再顯示"W"態的，再顯示"F"態的。
3．在"W"態中，以優先數高低或輪轉順序排隊；在"F"態中，以完成先後順序排隊。

view plain to clipboardprint?
/*
操作系統實驗之時間片輪轉演算法和優先順序調度演算法
By Visual C++ 6.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node
{
char name[20]; /*進程的名字*/
int prio; /*進程的優先順序*/
int round; /*分配CPU的時間片*/
int cputime; /*CPU執行時間*/
int needtime; /*進程執行所需要的時間*/
char state; /*進程的狀態，W——就緒態，R——執行態，F——完成態*/
int count; /*記錄執行的次數*/
struct node *next; /*鏈表指針*/
}PCB;
PCB *ready=NULL,*run=NULL,*finish=NULL; /*定義三個隊列，就緒隊列，執行隊列和完成隊列*/
int num;
void GetFirst(); /*從就緒隊列取得第一個節點*/
void Output(); /*輸出隊列信息*/
void InsertPrio(PCB *in); /*創建優先順序隊列，規定優先數越小，優先順序越高*/
void InsertTime(PCB *in); /*時間片隊列*/
void InsertFinish(PCB *in); /*時間片隊列*/
void PrioCreate(); /*優先順序輸入函數*/
void TimeCreate(); /*時間片輸入函數*/
void Priority(); /*按照優先順序調度*/
void RoundRun(); /*時間片輪轉調度*/
int main(void)
{
char chose;
printf("請輸入要創建的進程數目:\n");
scanf("%d",&num);
getchar();
printf("輸入進程的調度方法：(P/R)\n");
scanf("%c",&chose);
switch(chose)
{
case 'P':
case 'p':
PrioCreate();
Priority();
break;
case 'R':
case 'r':
TimeCreate();
RoundRun();
break;
default:break;
}
Output();
return 0;
}
void GetFirst() /*取得第一個就緒隊列節點*/
{
run = ready;

if(ready!=NULL)
{
run ->state = 'R';
ready = ready ->next;
run ->next = NULL;
}
}
void Output() /*輸出隊列信息*/
{
PCB *p;
p = ready;
printf("進程名\t優先順序\t輪數\tcpu時間\t需要時間\t進程狀態\t計數器\n");
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
p = finish;
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
p = run;
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
}
void InsertPrio(PCB *in) /*創建優先順序隊列，規定優先數越小，優先順序越低*/
{
PCB *fst,*nxt;
fst = nxt = ready;

if(ready == NULL) /*如果隊列為空，則為第一個元素*/
{
in->next = ready;
ready = in;
}
else /*查到合適的位置進行插入*/
{
if(in ->prio >= fst ->prio) /*比第一個還要大，則插入到隊頭*/
{
in->next = ready;
ready = in;
}
else
{
while(fst->next != NULL) /*移動指針查找第一個別它小的元素的位置進行插入*/
{
nxt = fst;
fst = fst->next;
}

if(fst ->next == NULL) /*已經搜索到隊尾，則其優先順序數最小，將其插入到隊尾即可*/
{
in ->next = fst ->next;
fst ->next = in;
}
else /*插入到隊列中*/
{
nxt = in;
in ->next = fst;
}
}
}
}
void InsertTime(PCB *in) /*將進程插入到就緒隊列尾部*/
{
PCB *fst;
fst = ready;

if(ready == NULL)
{
in->next = ready;
ready = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void InsertFinish(PCB *in) /*將進程插入到完成隊列尾部*/
{
PCB *fst;
fst = finish;

if(finish == NULL)
{
in->next = finish;
finish = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void PrioCreate() /*優先順序調度輸入函數*/
{
PCB *tmp;
int i;

printf("輸入進程名字和進程所需時間：\n");
for(i = 0;i < num; i++)
{
if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
{
perror("malloc");
exit(1);
}
scanf("%s",tmp->name);
getchar(); /*吸收回車符號*/
scanf("%d",&(tmp->needtime));
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 50 - tmp->needtime; /*設置其優先順序，需要的時間越多，優先順序越低*/
tmp ->round = 0;
tmp ->count = 0;
InsertPrio(tmp); /*按照優先順序從高到低，插入到就緒隊列*/
}
}
void TimeCreate() /*時間片輸入函數*/
{
PCB *tmp;
int i;

printf("輸入進程名字和進程時間片所需時間：\n");
for(i = 0;i < num; i++)
{
if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
{
perror("malloc");
exit(1);
}
scanf("%s",tmp->name);
getchar();
scanf("%d",&(tmp->needtime));
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 0;
tmp ->round = 2; /*假設每個進程所分配的時間片是2*/
tmp ->count = 0;
InsertTime(tmp);
}
}
void Priority() /*按照優先順序調度，每次執行一個時間片*/
{
int flag = 1;

GetFirst();
while(run != NULL) /*當就緒隊列不為空時，則調度進程如執行隊列執行*/
{
Output(); /*輸出每次調度過程中各個節點的狀態*/
while(flag)
{
run->prio -= 3; /*優先順序減去三*/
run->cputime++; /*CPU時間片加一*/
run->needtime--;/*進程執行完成的剩餘時間減一*/
if(run->needtime == 0)/*如果進程執行完畢，將進程狀態置為F，將其插入到完成隊列*/
{
run ->state = 'F';
run->count++; /*進程執行的次數加一*/
InsertFinish(run);
flag = 0;
}
else /*將進程狀態置為W，入就緒隊列*/
{
run->state = 'W';
run->count++; /*進程執行的次數加一*/
InsertTime(run);
flag = 0;
}
}
flag = 1;
GetFirst(); /*繼續取就緒隊列隊頭進程進入執行隊列*/
}
}
void RoundRun() /*時間片輪轉調度演算法*/
{

int flag = 1;

GetFirst();
while(run != NULL)
{
Output();
while(flag)
{
run->count++;
run->cputime++;
run->needtime--;
if(run->needtime == 0) /*進程執行完畢*/
{
run ->state = 'F';
InsertFinish(run);
flag = 0;
}
else if(run->count == run->round)/*時間片用完*/
{
run->state = 'W';
run->count = 0; /*計數器清零，為下次做准備*/
InsertTime(run);
flag = 0;
}
}
flag = 1;
GetFirst();
}

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

多級反饋隊列調度演算法
(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

Ⅶ 怎麼用verilog實現下面的公式，在xilinx ISE上。

無法直接實現，而且你還用的是浮點的，基本就是買IP了
或者像樓上說的，自己拿軟體算一個表，把你能用到的值都算出來，每次查表進行，不過這適用於x范圍不大的情況，如果x是隨機的，那就只有買ip了

Ⅷ 基於優先順序的時間片輪轉進程調度演算法

#include<iostream>
using namespace std;
struct PCB_Type{
char name;
int cpu_time;
};
struct QueueNode{
struct PCB_Type PCB;
struct QueueNode *next;
};

int main(){
int m,n,t;
int usecpu=0,unusecpu=0;
cout<<"輸入就緒隊列中的進程數目m：";
cin>>m;
cout<<"輸入阻塞隊列中的進程的數目n：";
cin>>n;
cout<<"輸入喚醒系統資源的相隔時間片個數t：";
cin>>t;
struct QueueNode *readyhead=new QueueNode ,*readytail=new QueueNode,
*blockedhead=new QueueNode,*blockedtail=new QueueNode;
// readyhead=NULL;readytail=NULL;blockedhead=NULL;blockedtail=NULL;
readyhead=readytail;
blockedhead=blockedtail;
for(int i=1;i<=m;i++){
struct QueueNode *t1=new QueueNode;
cout<<"輸入就緒隊列中進程的name和cpu_time：";
cin>>t1->PCB.name>>t1->PCB.cpu_time;
readytail->next=t1;
readytail=t1;
}
for(int j=1;j<=n;j++){
struct QueueNode *t2=new QueueNode;
cout<<"輸入阻塞隊列中進程的name和cpu_time：";
cin>>t2->PCB.name>>t2->PCB.cpu_time;
blockedtail->next=t2;
blockedtail=t2;
}

cout<<"輸出就緒隊列的進程信息：";
for(struct QueueNode *t3=readyhead->next;t3!=readytail->next;t3=t3->next){
cout<<t3->PCB.name<<"、"<<t3->PCB.cpu_time<<"---> ";
}
cout<<"無進程";
cout<<endl;
cout<<"輸出阻塞隊列的進程信息：";
struct QueueNode *t4;
t4=blockedhead->next;
while(t4!=blockedtail->next){
cout<<t4->PCB.name<<"、"<<t4->PCB.cpu_time<<"---> ";
t4=t4->next;
}
cout<<"無進程";
cout<<endl<<"進程的運行順序：";
int x=0;
while(readyhead!=readytail||blockedhead!=blockedtail){
if(readyhead!=readytail){
struct QueueNode *p=readyhead->next;
cout<<p->PCB.name<<",";
p->PCB.cpu_time--;
usecpu++;
if(readyhead->next!=readytail){
if(p->PCB.cpu_time>0){
readyhead->next=p->next;//出隊列
readytail->next=p;
readytail=p;
}
else{
readyhead->next=p->next;
delete p;
}
}
else//隊列中只有兩個節點 頭結點和尾結點
{
if(p->PCB.cpu_time<=0){readytail=readyhead;//只有進程為執行完，就繼續執行，完成之後，把隊列清空，釋放指針p；就緒隊列無進程
delete p;}
}

}
else
{
unusecpu++;
cout<<"_,";
}
x++;
if(x==t){
if(blockedhead!=blockedtail){

struct QueueNode *q=blockedhead->next;
if(blockedhead->next!=blockedtail)
{
blockedhead->next=q->next;
}
else
{
blockedhead=blockedtail;
}
readytail->next=q;
readytail=q;
x=0;
}
}
}
cout<<endl;
cout<<"cpu的利用率="<<usecpu<<"/"<<usecpu+unusecpu<<endl;
return 0;
}

#include"stdio.h"
#include"stdlib.h"
#include "string.h"
#define WAIT 1
#define RUN 2
#define FINISH 3

typedef struct pcb
{
int num;
struct pcb *next;
int priority;
int timeneed;
int state;
}pcb;/*用此結構體來模擬一個進程*/

struct pcb *head;
struct pcb *run;

pcb *jccreat(int n)/*此函數用於創建進程隊列*/
{
int i=1;
pcb *head,*p,*q;

randomize();/*隨機函數的初始化*/

head=(pcb *)malloc(sizeof(pcb));/*創建一個空表頭*/
p=head;

for(i=1;i<=n;i++)/*用循環來創建指定個 結點*/
{
q=(pcb *)malloc(sizeof(pcb));
p->next=q;
q->num=i;
q->next=NULL;
q->priority=random(10);/*隨機產生優先順序*/
q->timeneed=random(10);/*隨機產生運行時間*/
q->state=WAIT;
p=q;
}

return head;/*返回表頭指針*/
}

pcb *getmaxpriority(struct pcb *head)/*此函數用來挑選一個優先順序最大的進程來執行*/
{
struct pcb *p,*q;
int max;
p=head->next;
max=p->priority;/*初始max為隊首結點的優先順序*/
q=p;
while(p) /*當p不為空時，進行逐一比較*/
{
if(p->priority>max)/*逐一比較，選出優先順序最大的結點*/
{max=p->priority;
q=p;}
p=p->next;
}
return q;
}

void delect(struct pcb *head,struct pcb *run)/*此函數用來將運行完的進程刪除出進程隊列*/
{
struct pcb *q=head;

while(q->next)/*掃描進程隊列，找到執行完了的進程*/
{
if(q->next->num==run->num)/*判斷是不是已完成的進程*/
{
if(run->next!=NULL)
q->next=run->next;
else q->next=NULL;
free(run);/*釋放申請的空間*/
return;
}
q=q->next;
}

}

void control()/*此函數是用來控制各個進程的執行和調度*/
{
struct pcb *p;
run=head->next;/*初始讓第一個進程運行*/
run->state=RUN;
while(run) /*當進程狀態是不為空時運行*/
{
if(run->timeneed>0)/*如果當前run指針指向的進程所需時間不為零，狀態為運行狀態，就讓這個進程運行*/
if(run->state==RUN)
{printf("pcb%d is running.\n",run->num);
printf("Waiting list:");/*顯示整個等待隊列*/
p=head->next;
while(p)
{
if(p!=run)
printf("pcb%d ",p->num);
p=p->next;
}
printf("\n");
delay(10000000);/*模擬進程運行*/
run->timeneed--;/*進程需要時間減一*/
run->priority=run->priority-3;/*進程優先順序減三*/
}

if(run->timeneed!=0)
{
if(run->priority<=head->next->priority)/*如果當前運行完的進程的優先順序低於隊首進程的優先順序*/
{run->state=WAIT;
run=getmaxpriority(head);/*則從進程隊列中挑選一個優先順序最大的進程來運行*/
run->state=RUN;}
}
else
{ printf("pcb%d is finished.\n",run->num);
delect(head,run);/*刪除該結點*/
if(head->next!=NULL)/*判斷進程隊列是不是為空*/
{run=head->next;
run->state=RUN;}
else
{printf("All progresses are done.\n");

return;}
}
}
}

main()
{
int n;
int flag=1;

printf("Enter the number of the progresses:");
scanf("%d",&n);/*輸入要創建的進程的數量*/

head=jccreat(n);/*創建進程隊列，將鏈表的表頭賦給head指針*/
run=head->next;/*run指針指向正在運行的進程的pcb*/
while(run)
{
printf("num: %d ,priority: %d ,timenees: %d \n",run->num,run->priority,run->timeneed);

run=run->next;
} /*將剛創建的進程隊列列印出來*/
while(flag)/*由flag的值判斷是否繼續執行control()函數*/
{
if(head->next)/*判斷進程是否完成*/
control();
else flag=0;
}
getch();
}

選一個把

Ⅸ 以下五個作業，fcfs sjf hrrn三種調度演算法平均周轉時間，高響應比怎麼算

作業調度演算法 .

1. 先來先服務（FCFS, First Come First Serve）是最簡單的調度演算法，按先後順序進行調度。

定義：

按照作業提交或進程變為就緒狀態的先後次序，分派CPU；

當前作業或進程佔用CPU，直到執行完或阻塞，才出讓CPU（非搶占方式）。

在作業或進程喚醒後（如I/O完成），並不立即恢復執行，通常等到當前作業或進程出讓CPU。

適用場景：

比較有利於長作業，而不利於短作業。因為長作業會長時間占據處理機。

有利於CPU繁忙的作業，而不利於I/O繁忙的作業。

演算法實現原理圖：

2. 輪轉法(Round Robin)

輪轉法是讓每個進程在就緒隊列中的等待時間與享受服務的時間成正比例。

定義：

將系統中所有的就緒進程按照FCFS原則，排成一個隊列。

每次調度時將CPU分派給隊首進程，讓其執行一個時間片。時間片的長度從幾個ms到幾百ms。

在一個時間片結束時，發生時鍾中斷。

調度程序據此暫停當前進程的執行，將其送到就緒隊列的末尾，並通過上下文切換執行當前的隊首進程。

進程可以未使用完一個時間片，就出讓CPU（如阻塞）。

時間片長度的確定：

時間片長度變化的影響

過長－>退化為FCFS演算法，進程在一個時間片內都執行完，響應時間長。

過短－>用戶的一次請求需要多個時間片才能處理完，上下文切換次數增加，響應時間長。

對響應時間的要求：T(響應時間)=N(進程數目)*q(時間片)

就緒進程的數目：數目越多，時間片越小

系統的處理能力：應當使用戶輸入通常在一個時間片內能處理完，否則使響應時間，平均周轉時間和平均帶權周轉時間延長。

演算法實現原理圖：

3. 多級反饋隊列演算法(Round Robin with Multiple Feedback)

多級反饋隊列演算法是輪轉演算法和優先順序演算法的綜合和發展。

定義：

設置多個就緒隊列，分別賦予不同的優先順序，如逐級降低，隊列1的優先順序最高。每個隊列執行時間片的長度也不同，規定優先順序越低則時間片越長，如逐級加倍。

新進程進入內存後，先投入隊列1的末尾，按FCFS演算法調度；若按隊列1一個時間片未能執行完，則降低投入到隊列2的末尾，同樣按FCFS演算法調度；如此下去，降低到最後的隊列，則按「時間片輪轉」演算法調度直到完成。

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

優點：

為提高系統吞吐量和縮短平均周轉時間而照顧短進程。

為獲得較好的I/O設備利用率和縮短響應時間而照顧I/O型進程。

不必估計進程的執行時間，動態調節

幾點說明：

I/O型進程：讓其進入最高優先順序隊列，以及時響應I/O交互。通常執行一個小時間片，要求可處理完一次I/O請求的數據，然後轉入到阻塞隊列。

計算型進程：每次都執行完時間片，進入更低級隊列。最終採用最大時間片來執行，減少調度次數。

I/O次數不多，而主要是CPU處理的進程。在I/O完成後，放回優先I/O請求時離開的隊列，以免每次都回到最高優先順序隊列後再逐次下降。

為適應一個進程在不同時間段的運行特點，I/O完成時，提高優先順序；時間片用完時，降低優先順序。

演算法實現原理圖：

4. 優先順序法（Priority Scheling）

優先順序演算法是多級隊列演算法的改進，平衡各進程對響應時間的要求。適用於作業調度和進程調度，可分成搶先式和非搶先式。

靜態優先順序：

作業調度中的靜態優先順序大多按以下原則確定：

由用戶自己根據作業的緊急程度輸入一個適當的優先順序。

由系統或操作員根據作業類型指定優先順序。

系統根據作業要求資源情況確定優先順序。

進程的靜態優先順序的確定原則：

按進程的類型給予不同的優先順序。

將作業的情態優先順序作為它所屬進程的優先順序。

動態優先順序：

進程的動態優先順序一般根據以下原則確定：

根據進程佔用有CPU時間的長短來決定。

根據就緒進程等待CPU的時間長短來決定。

5．短作業優先法（SJF, Shortest Job First）

短作業優先又稱為「短進程優先」SPN(Shortest Process Next)；這是對FCFS演算法的改進，其目標是減少平均周轉時間。

定義：

對預計執行時間短的作業（進程）優先分派處理機。通常後來的短作業不搶先正在執行的作業。

SJF的特點：

(1) 優點：

比FCFS改善平均周轉時間和平均帶權周轉時間，縮短作業的等待時間；

提高系統的吞吐量；

(2) 缺點：

對長作業非常不利，可能長時間得不到執行；

未能依據作業的緊迫程度來劃分執行的優先順序；

難以准確估計作業（進程）的執行時間，從而影響調度性能。

SJF的變型：

「最短剩餘時間優先」SRT(Shortest Remaining Time)（允許比當前進程剩餘時間更短的進程來搶占）

「最高響應比優先」HRRN(Highest Response Ratio Next)（響應比R = (等待時間 + 要求執行時間) / 要求執行時間，是FCFS和SJF的折衷）

6. 最高響應比優先法(HRN，Highest Response_ratio Next)

最高響應比優先法是對FCFS方式和SJF方式的一種綜合平衡。FCFS方式只考慮每個作業的等待時間而未考慮執行時間的長短，而SJF方式只考慮執行時間而未考慮等待時間的長短。因此，這兩種調度演算法在某些極端情況下會帶來某些不便。HRN調度策略同時考慮每個作業的等待時間長短和估計需要的執行時間長短，從中選出響應比最高的作業投入執行。

響應比R定義如下： R =(W+T)/T = 1+W/T

其中T為該作業估計需要的執行時間，W為作業在後備狀態隊列中的等待時間。每當要進行作業調度時，系統計算每個作業的響應比，選擇其中R最大者投入執行。這樣，即使是長作業，隨著它等待時間的增加，W / T也就隨著增加，也就有機會獲得調度執行。這種演算法是介於FCFS和SJF之間的一種折中演算法。由於長作業也有機會投入運行，在同一時間內處理的作業數顯然要少於SJF法，從而採用HRN方式時其吞吐量將小於採用SJF 法時的吞吐量。另外，由於每次調度前要計算響應比，系統開銷也要相應增加。

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

你試一下

#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;
}