優先數調度演算法實現處理器調度的程序

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

沒有完全符合的,但是差不多的,你自己改改吧!
#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;
}

② 設計一個按響應比高者優先調度演算法實現進程調度的程序。

只幫你寫點開頭，後面你應該會的
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream.h>

typedef struct node
{
char name[10];
int prio;
int round;
int cputime;
int needtime;
int count;
char state;
struct node *next;
}PCB;
PCB *finish,*ready,*tail,*run,; //隊列指針
int N; //進程數

void zhunbei()
{
run=ready; //就緒隊列頭指針賦值給運行頭指針
run->state='G'; //進程狀態變為運行態]
ready=ready->next; //就緒隊列頭指針後移到下一進程
}
//輸出標題函數
void output1(char a)
{
if(toupper(a)=='P') //優先順序法
cout<<" "<<endl;
cout<<"進程名 佔用CPU時間 已運行時間 還要的時間 輪轉時間片 狀態"<<endl;
}

③ 處理機調度模擬程序:選擇一個調度演算法,實現處理機調度.

處理機調度主要有：先到先服務、短作業優先、優先權調度、輪轉法調度、多級隊列調度、多級反饋隊列。

在實現時：
1、創建三個狀態（隊列）：運行（隊長為1）、就緒、阻塞。
2、創建一個數據結構代表進程，裡面有一些進程特徵標記（根據我上面說的調度演算法）。
3、寫演算法，讀進程的數據結構進行入隊、出隊。

④ 設計一個按優先數調度演算法實現處理器調度的程序。

#include "stdio.h"
#include "malloc.h"
#include "string.h"
typedef struct node{
int time;
int name;
char statement;
int num;
struct node *next;
}node,*L;
void createL(L &l,int n){
l=(L)malloc(sizeof(node));
if(!l)
printf("error!");
else
l->next=NULL;
L p,q;
q=l;
for(int i=0;i<n;i++){
p=(L)malloc(sizeof(node));
printf("請輸入進程的名字name:\n");
scanf("%d",&p->name);
getchar();
printf("請輸入該進程的運行時間time:\n");
scanf("%d",&p->time);
printf("請輸入其優先順序數num:\n");
scanf("%d",&p->num);
getchar();
printf("請輸入其狀態:\n");
p->statement=getchar();
p->next=q->next;
q->next=p;
q=p;
getchar();
}

}
void traL(L &l){
L p;
p=l->next;
printf("進程名\t運行時間\t優先數\t狀態\n");
while(p){
printf(" %d\t%5d\t%11d\t %c",p->name,p->time,p->num,p->statement);
printf("\n");
p=p->next;
}
}
void Sort(L &l)
{
L tail=NULL;

while(tail!= l->next)
{
L pre = l;
L cur = pre->next;
while(cur != tail && cur->next != tail)
{
if( cur->num < cur->next->num )
{
pre->next = cur->next;
cur->next = cur->next->next;
pre->next->next = cur;
}
pre = pre->next;
cur = pre->next;
}
tail = cur;
}
}
void run(L &l){
Sort(l);
L p,r,q;
q=l;
if(l->next!=NULL)
p=l->next;
int j=0;
printf("第k次運行\t進程名\t運行時間\t優先數\t狀態\n");
while(p!=NULL){
j++;
printf("%5d\t %d\t%5d\t%11d\t %c",j,p->name,p->time,p->num,p->statement);
printf("\n");
p->num--;
p->time--;
if(p->time==0){
p->statement='E';
r=p;
if(p->next!=NULL)
{
l->next=p->next;
free(r);
p=l->next;
}
else
break;
}
else{
Sort(l);
if(l->next!=NULL)
p=l->next;
else
break;
}
}
}

void main(){
L l;
int n;
printf("請輸入進程的數目n:\n");
scanf("%d",&n);
createL(l,n);
traL(l);
run(l);
}
//這是運行過的，應該符合你的要求！

⑤ 處理機調度模擬程序：選擇一個調度演算法，實現處理機調度。

七、源程序：

#include <stdio.h>

int m1; //共享變數
int m2; //共享變數
struct{
int id; //進程標號
int waiter1; //指針，用於標識等待隊列的下一個進程
int priority; //進程優先順序
char status; //進程狀態
}pcb[4];
struct{
int value; //信號量的值
int waiter2; //指針，用於標識等待此信號量隊列的第一個進程
}sem[3];
char stack[11][4]; //現場保護堆棧
int i； //cpu中的通用寄存器
int ep; //當前運行進程指針
char addr; //程序運行時的地址
void init(); //初始化
int find(); //找出就緒進程
int w2(); //
int process1(); //進程1
int process2(); //進程2
int process3(); //進程3
int p(int,int ,char); //P原語
int v(int,int ,char); //V原語

main()
{

init();
printf("系統程序開始執行\n");
for(;;){
if(find()!=0) //找出就緒進程
w2(); //進程調度
else break;//退出程序
}
printf("系統程序結束\n");
}

void init() //初始化進程
{
int j,k;
pcb[0].status='w'; //進程狀態設置為等待
pcb[0].priority=4; //進程的優先順序別
for(j=1;j<=3;j++){
pcb[j].id=j; //進程編號
pcb[j].status='r'; //進程狀態設置為就緒
pcb[j].waiter1=0; //進程指針初始化為0
pcb[j].priority=j; //設置進程優先順序
}
for(j=1;j<=2;j++){
sem[j].value=1; //信號量賦值為1
sem[j].waiter2=0; //等待信號量隊列的初始化
}
i=0; //CPU通用寄存器初始化
ep=0; //
addr='0'; //程序運行地址
m1=0; //共享變數初始化
m2=0; //共享變數初始化
for(j=1;j<=10;j++){
for(k=1;k<=3;k++)
stack[j][k]='0'; //現場保護堆棧初始化
}
}

int find(){ //查找初始化變數
int j;
for(j=1;j<=3;j++)
if(pcb[j].status=='r') return(j); //如果pcb隊列中有就緒進程，返回進程編號
return(0);
}

int w2(){ //進程調度程序
int pd;
pd=find(); //找出就緒進程編號
if(pd==0) return(0); //如果沒有找到就緒進程，退出程序
else if(ep==0){ //如果當前運行進程是否為0
pcb[pd].status='e'; //直接將當前進程設置為運行狀態
ep=pd; //當前運行進程設置為pd
printf("進程%d正在執行\n",ep);
}
else
if(pcb[pd].priority<pcb[ep].priority)//如果當前進程比待調入進程優先順序進行比較
{//調入進程優先順序別高
pcb[ep].status='r'; //把CPU運行進程執行狀態設置為就緒
printf("讀取進程%d\n",pcb[pd].id);
pcb[pd].status='e'; //將待調入進程執行狀態設置為執行
ep=pd; //將當前運行進程指針為待調入進程
}

printf("運行進程%d\n",ep);
i=stack[1][ep]; //恢復進程的通用寄存器中的值和運行地址。
addr=stack[2][ep];
switch(ep){ //根據當前運行的進程選擇運行
case 1:process1();
break;
case 2:process2();
break;
case 3:process3();
break;
default:printf("當前進程出現錯誤%d\n",ep);
break;
}
}

int process1(){//進程1
if(addr=='m') goto m; //如果當前運行地址是m，跳到m運行
i=1;
a:
printf("進程1在信號量sem[1]上調用P操作\n");
if(p(1,1,'m')==0) return(0); //進行p操作，m表示程序執行到m
else goto m;
m:
printf("列印進程1...m1=%d\n",m1); //進程1的操作，列印，寄存器i＋5
printf("列印進程1...i=%d\n",i);
i+=5;

goto a; //跳回a執行
}

int process2(){//進程分為3部分
if(addr=='m') goto m;
if(addr=='n') goto n;
i=1;

a:
printf("進程2在信號量sem[2]上調用P操作\n");
if(p(2,2,'m')==0) return(0);

m:
m1=2*m2;
printf("進程2在信號量sem[1]上調用V操作m1=%d\n",m1);
if(v(1,2,'n')==0) return(0);
else{

n:
printf("列印進程2...i=%d\n",i);
i+=10;
goto a;
}
}

int process3(){
if(addr=='m') goto m;
if(addr=='n') goto n;
i=1;
a:
if(i>4){
printf("進程3在信號量sem[2]上調用P操作\n");
if(p(2,3,'n')==0) return(0);
}
n:
m2=i;
printf("進程3在sem[2]信號量上調用V操作m=%d\n",m2);
if(v(2,3,'m')==0) return(0);
else{
m:
i+=1;
goto a;
}
}

int p(int se,int p,char ad){
int w;
sem[se].value--; //信號量減1
if(sem[se].value==0) return(1); //如果信號量＝0，返回1，說明阻塞
printf("阻塞當前進程%d\n",p);
pcb[p].status='w'; //改變進程狀態
ep=0; //運行進程為空
pcb[p].waiter1=0; //設為尾末
w=sem[se].waiter2; //找出等待隊列的隊尾
if(w==0) sem[se].waiter2=p; //插入等待隊列
else{
while(pcb[w].waiter1!=0) w=pcb[w].waiter1;
pcb[w].waiter1=p;
}
stack[1][p]=i; //保存現場
stack[2][p]=ad;
return(0);
}

int v(int se,int p,char ad){
int w;
sem[se].value++; //信號量加1
if(sem[se].value>0) return(1); //信號量>0，無等待進程
w=sem[se].waiter2; //返回第一個等待進程
sem[se].waiter2=pcb[w].waiter1; //調整位置
pcb[w].status='r'; //進程改變狀態
printf("喚醒進程%d\n",w);
stack[1][p]=i; //進程狀態進棧
stack[2][p]=ad;
return(0);
}

⑥ 急~~超急~~請於2011·1·5十點前告訴我 操作系統課程設計 設計一個按優先數調度演算法實現處理機調度的程序

這個怎麼來告訴你，，課程設計
曾經搞過UCOS2系統，也是任務調度，時間輪換制的，
可以參考一下，畢竟是開源的，所以資料，改進的文章很多

⑦ 如何用C語言編寫:設計一個時間片輪轉調度演算法實現處理機調度的程序

實驗三 進程調度

一、實驗目的
在採用多道程序設計的系統中，往往有若干個進程同時處於就緒狀態。當就緒進程個數大於處理機數時，就必須依照某種策略來決定那些進程優先佔用處理機。本實驗模擬在單處理機情況下的處理機調度，幫助學生加深了解處理機調度的工作。

二、實驗內容
設計一個時間片輪轉調度演算法實現處理機調度的程序。

三、實驗指導
1.實驗中使用的數據結構：
1)PCB進程式控制制塊
其中包括參數①進程名name；②要求運行時間runtime；③優先數prior；④狀態state；⑤已運行時間runedtime。
2)為簡單起見，只設運行隊列，就緒鏈表兩種數據結構，進程的調度在這兩個隊列中切換，如圖3.1所示。

圖3.1PCB鏈表

2.運行結果，包括各個進程的運行順序，每次佔用處理機的運行時間

3.每個進程運行時間隨機產生，為1~20之間的整數。
4.時間片的大小由實驗者自己定義，可為3或5。

四、實驗要求
1.在上機前寫出全部源程序；
2.能在機器上正確運行程序。
五、程序清單
六、運行結果
七、調試分析及實驗心得
我的回答和這位老兄的差不多

⑧ 設計一個按優先數調度演算法實現處理器調度的程序。 高手幫忙!!

#include <stdio.h>
#include <stdlib.h> //提供atoi()函數
#include <conio.c> //提供clrscr()函數
#define M 10 //字元串大小常量
#define N 3 //進程數常量
#define SLOT 2
typedef struct node{
char name[M];
int prio; //優先順序
int round; //時間片長度
int cputime; //已經使用的cpu時間
int needtime;//需要多少cpu時間
int count; //計數器
char state; //進程的當前狀態
struct node *next; //指向下一個進程
}PCB;

PCB *finish,*ready,*tail,*run;

void ShowHead(char *s1,char *s2);
int Menu_Select();
void Creat(int select);
void InsertPriority(PCB *q);
void InsertSlot(PCB *q);
void PrintOneProcess(int select,PCB *q);
void PrintAllProcess(int select);
void FirstIn();
void FIFODo(int select);
void PriorityDo(int select);
void SlotDo(int select);
void Quit();
main()
{
while(1)
{
clrscr();
switch(Menu_Select())
{
case 1:
Creat(1);
FIFODo(1);
printf("\n\n\t\t按回車鍵返回菜單...");
getchar();
getchar();
break;
case 2:
Creat(2);
PriorityDo(2);
printf("\n\n\t\t按回車鍵返回菜單...");
getchar();
getchar();
break;
case 3:
Creat(3);
SlotDo(3);
printf("\n\n\t\t按回車鍵返回菜單...");
getchar();
getchar();
break;
case 0:
Quit();
break;
}
}
}

/*列印每個界面的開頭顯示*/
void ShowHead(char *s1,char *s2)
{
printf("\t ==================%s========================\n\n",s1);
printf("\t\t\t\t%s\n\n",s2);
printf("\t ========================================================\n\n");
}

/*主菜單*/
int Menu_Select()
{
int choose;
char s[2];
clrscr();
printf("====================進程調度演算法模擬程序=====================\n\n");
printf("\t\t 1.先進先出調度策略\n");
printf("\t\t 2.優先數調度策略\n");
printf("\t\t 3.時間片輪轉調度策略\n");
printf("\t\t 0.退出系統\n\n");
printf("=============================================================\n\n");
do
{
printf("\n請輸入你的選擇(0-3):");
scanf("%s",s);
choose=atoi(s);
}while(choose<0 || choose>3);
return choose;
}

/*創建調度演算法的鏈表*/
void Creat(int select)
{
PCB *p,*q; //q為就緒隊列的最後一個結點
int i,time,rounds;
char na[M];
ready=NULL;
finish=NULL;
run=NULL;
if(select==1) //先進先出調度創建
{
printf("\nEnter name and time of process:\n");
for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->state='W';
p->next=NULL;
if(ready!=NULL) //就緒隊列不為空
{
q->next=p;
q=p;
}
else //就緒隊列為空
{
p->next=ready;
ready=p;
q=ready;
}
}
clrscr();
ShowHead("先進先出調度策略","FIFO dispatching algorithm ");
printf("\t\t name cputime needtime state\n");
PrintAllProcess(select); //列印出初始狀態的信息
}
else if(select==2) //優先數調度創建
{
printf("\nEnter name and time of process:\n");
for(i=1;i<=N;i++)
{
p=(PCB *)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) //就緒隊列不為空的時候
InsertPriority(p);
else //就緒隊列為空
{
p->next=ready;
ready=p;
}
}//end of for()
clrscr();
ShowHead("優先順序調度策略","Priority dispatching algorithm ");
printf("\t\t name cputime needtime prio state\n");
PrintAllProcess(select); //列印出初始狀態的信息
}//end of else if()
else if(select==3) //時間片輪轉調度創建
{
printf("\nEnter name and the time of process:\n");
for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
p->count=0; //計數器
p->round=SLOT;
p->state='W';
if(ready!=NULL)
InsertSlot(p);
else
{
p->next=ready;
ready=p;
}
}
clrscr();
ShowHead("時間片輪轉調度策略","Time slot dispatching algorithm ");
printf("\n\t\t name cputime needtime count slot state\n");
PrintAllProcess(select); //列印出初始狀態的信息
}
run=ready; //從就緒隊列取一個進程，使其運行，同時就緒隊列的頭指針後移
run->state='R';
ready=ready->next;
}

/*優先調度：把進程插入到合適的位置，就緒隊列按優先順序由高到低的順序排列*/
void InsertPriority(PCB *q)
{
PCB *pre,*p;
int flag=1;
pre=NULL;
p=ready;
while(p!=NULL && flag)
{
if(p->prio>q->prio)
{
pre=p;
p=p->next;
}
else
flag=0;
}
if(pre==NULL)
{
q->next=ready;
ready=q;
}
else
{
pre->next=q;
q->next=p;
}
}

/*時間片輪轉：把結點插入到就緒隊列的末尾*/
void InsertSlot(PCB *q)
{
PCB *pre,*p;
pre=NULL;
p=ready;
while(p!=NULL)
{
pre=p;
p=p->next;
}
pre->next=q;
q->next=NULL; /*由於插入到隊列的末尾，所以必須要使其的下一個結點為空值*/
}

/*列印一個信息*/
void PrintOneProcess(int select,PCB *q)
{
if(select==1)
printf("\t\t %-10s%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->state);
else if(select==2)
printf("\t\t %-10s%-10d%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->prio,q->state);
else if(select==3)
printf("\t\t %-10s%-10d%-10d%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);
}

/*將所有的進程列印出來，按運行，就緒，完成順序列印*/
void PrintAllProcess(int select)
{
PCB *p;
if(run!=NULL)
PrintOneProcess(select,run);
p=ready;
while(p!=NULL)
{
PrintOneProcess(select,p);
p=p->next;
}
p=finish;
while(p!=NULL)
{
PrintOneProcess(select,p);
p=p->next;
}
}

/*把就緒隊列的第一個進程調入運行*/
void FirstIn()
{
run=ready;
ready=ready->next;
run->state='R';
}

/*先進先出調度策略*/
void FIFODo(int select)
{
while(run!=NULL)
{

run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
if(run->needtime==0) //進程執行結束
{
printf("\n\t\t name cputime needtime state\n");
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
FirstIn();
PrintAllProcess(1);
}
}
}

/*優先順序演算法*/
void PriorityDo(int select)
{
while(run!=NULL)
{
printf("\n\t\t name cputime needtime prio state\n");
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
run->prio=run->prio-3;
if(run->needtime==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';
InsertPriority(run);
FirstIn();
}
PrintAllProcess(select);
}
}

/*時間片輪轉演算法*/
void SlotDo(int select)
{
while(run!=NULL)
{
printf("\n\t\t name cputime needtime count slot state\n");
run->count=run->count+1;
run->cputime=run->cputime+1;
run->needtime=run->needtime-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; //時間片
if(ready!=NULL)
{
run->state='W';
InsertSlot(run);
FirstIn();
}
}
PrintAllProcess(select); //列印本次的所有記錄
}
}

void Quit()
{
char ch;
clrscr();
gotoxy(10,5);
printf("==========================================================\n\n");
printf(" Thank you for you using\n\n");
gotoxy(10,9);
printf("==========================================================\n\n");
gotoxy(13,15);

getchar();
printf("\n\t\tDo you really want to quit(y/Y or n/N):");
scanf("%c",&ch);
if(ch=='y' || ch=='Y')
{
printf("\n\t\t按任意鍵退出系統...");
getchar();
exit(0);
}

}

⑨ 進程調度方案設計 實現一個基本動態優先順序的調度演算法

前兩天做操作系統作業的時候學習了一下幾種進程調度演算法，在思考和討論後，有了一些自己的想法，現在就寫出來，跟大家討論下。，或者說只有有限的CPU資源，當系統中有多個進程處於就緒狀態，要競爭CPU資源時，操作系統就要負責完成如何分配資源的任務。在操作系統中，由調度程序來完成這一選擇分配的工作，調度程序所使用的演算法即是調度演算法。調度演算法需要考慮的指標主要有盡量保證CPU資源分配的公平性；按照一定策略強制執行演算法調度；平衡整個計算機系統，盡量保持各個部分都處於忙碌狀態。而根據系統各自不同的特點和要求，調度演算法又有一些側重點和目標不同，因此，演算法按照系統差異主要分為三大類：批處理系統中的調度演算法，代表調度演算法有：先來先服務、最短作業優先、最短剩餘時間優先。互動式系統中的調度演算法，代表調度演算法有：輪轉調度、優先順序調度、多級隊列、最短進程優先、保證調度、彩票調度、公平分享調度。實時系統中的調度演算法，代表調度演算法有：速率單調調度、最早最終時限優先調度。下面就上述提到的調度演算法中挑出幾個進行重點分析：保證調度保證調度是指利用演算法向用戶做出明確的性能保證，然後盡力按照此保證實現CPU的資源分配。利用這種演算法，就是定一個進程佔用CPU的時間的標准，然後按照這個標准去比較實際佔用CPU的時間，調度進程每次使離此標准最遠的進程得到資源，不斷滿足離所保證的標准最遠的進程，從而平衡資源分配滿足這個標準的要求。保證調度演算法的優點是：能很好的保證進程公平的CPU份額，當系統的特點是：進程的優先順序沒有太大懸殊，所制定的保證標准差異不大，各個進程對CPU的要求較為接近時，比如說系統要求n個進程中的每個進程都只佔用1/n的CPU資源，利用保證調度可以很容易的實現穩定的CPU分配要求。但缺點是，這種情況太過理想，當系統的各個進程對CPU要求的緊急程度不同，所制定的保證較為復雜的時候，這個演算法實現起來比較困難。彩票調度彩票調度這種演算法的大意是指向進程提供各種系統資源如CPU資源的彩票，當系統需要做出調度決策時，隨機抽出一張彩票，由此彩票的擁有者獲得資源。在彩票調度系統中，如果有一個新的進程出現並得到一些彩票，那麼在下一次的抽獎中，該進程會有同它持有彩票數量成正比例的機會贏得獎勵。進程持有的彩票數量越多，則被抽中的可能性就越大。調度程序可以通過控制進程的彩票持有數量來進行調度。彩票調度有很多優點：首先，它很靈活，系統增加分給某個進程的彩票數量，就會大大增加它佔用資源的可能性，可以說，彩票調度的反應是迅速的，而快速響應需求正是互動式系統的一個重要要求。其次，彩票調度演算法中，進程可以交換彩票，這個特點可以更好的保證系統的平衡性，使其各個部分都盡可能的處於忙碌狀態。而且利用彩票調度還可以解決許多別的演算法很難解決的問題，例如可以根據特定的需要大致成比例的劃分CPU的使用。速率單調調度速率單調調度演算法是一種可適用於可搶占的周期性進程的經典靜態實時調度演算法。當實時系統中的進程滿足：每個周期性進程必須在其周期內完成，且進程之間沒有相互依賴的關系，每個進程在一次突發中需要相同的CPU時間量，非周期的進程都沒有最終時限四個條件時，並且為了建模方便，我們假設進程搶占即刻發生沒有系統開銷，可以考慮利用速率單調演算法。速率單調調度演算法是將進程的速率（按照進程周期所算出的每秒響應的次數）賦為優先順序，則保證了優先順序與進程速率成線性關系，這即是我們所說的速率單調。調度程序每次運行優先順序最高的，只要優先順序較高的程序需要運行，則立即搶占優先順序低的進程，而優先順序較低的進程必須等所有優先順序高於它的進程結束後才能運行。速率單調調度演算法可以保證系統中最關鍵的任務總是得到調度，但是缺點是其作為一種靜態演算法，靈活性不夠好，當進程數變多，系統調度變得復雜時，可能不能較好的保證進程在周期內運行。最早最終時限優先調度最早最終時限優先調度演算法是一個動態演算法，不要求進程是周期性的，只要一個進程需要CPU時間，它就宣布它的到來時間和最終時限。調度程序維持一個可運行的進程列表，按最終時限排序，每次調度一個最終時限最早的進程得到CPU 。當新進程就緒時，系統檢查其最終時限是否在當前運行的進程結束之前，如果是，則搶占當前進程。由於是動態演算法，最早最終優先調度的優點就是靈活，當進程數不超過負載時，資源分配更優，但也同樣由於它的動態屬性，進程的優先順序都是在不斷變化中的，所以也沒有哪個進程是一定可以保證滿足調度的，當進程數超過負載時，資源分配合理度會急速下降，所以不太穩定。