多優先級隊列調度算法

一、

多優先級隊列調度算法的描述

該算法有多個隊列，同一個隊列中的進程優先級相同，不同隊列中進程優先級不同；最高優先級上的進程運行1個時間片，次高優先級上的進程運行2個時間片，再下一級運行4個時間片，依此類推；每次從隊列頭開始運行進程，每當一個進程在一個優先級隊列中用完它的時間片後，就移到隊列的尾部；只有當高優先級隊列爲空時纔會從不爲空的低優先級隊列中選擇進程運行；在低優先級隊列中等待時間過長的進程，將移入高優先級隊列。

二、多優先級隊列數據結構的定義

多優先級隊列數據結構的定義

進程數據結構的定義

class MultiPriorityQueueSchedule{

private:

MYPROCESS MultiPriorityQueue[QUEUESIZE];

private:

void MPQSFreeProcess(MYPROCESS);

MYPROCESS MPQSSelectProcess();

void MPQSRunProcess(MYPROCESS);

void MPQSGoAfter(MYPROCESS);//到隊列尾

void MPQSPriorityScheduling();//優先級調度

public:

MultiPriorityQueueSchedule();

bool MPQSAppendProcess(MYPROCESS);

void MPQSExecute();

void MPQSDisplayQueue(ofstream&);

};

typedef struct MyProcess

{

char* MyProcessname;

int CreateTime;

int LastExecTime;

int JobWeight;

int EstimateUsedTime;

int Priority;

MyProcess *next;

}* MYPROCESS;

其他函數：

MYPROCESS CreateMyProcess(char* name, int JW, int Prio); //創建進程

int EstimateRunTime(int JW); //估計進程運行時間

void BurstTime(int st); //SYSTIME增加

void PriorityScheduling(MYPROCESS); //調整進程優先級

三、Select方法

1）從高優先級隊列到低優先級隊列，當高優先級隊列爲空時才進入低優先級隊列，否則跳到2）。當所有隊列爲空時，跳到4）。

2）選擇此優先級隊列的頭一個進程運行，進程運行完它的時間片後，把此進程放到此優先級隊列的尾部，跳到3）。

3）調整所有進程的優先級，跳到1）。

4） <?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

四、編程測試

根據上述內容進行編程，運行程序截圖如下：

<?xml:namespace prefix = v ns = "urn:schemas-microsoft-com:vml" />

圖1：動態多優先級調度的過程圖

圖2：靜態多優先級隊列和動態多優先級隊列的比較

附錄中展示了程序中的類、函數和一些變量的定義。

附錄

/*MultiPriorityQueue.h*/
/*Power by Keamou@CS@CITS@NKU*/
#include <string.h>
#include <math.h>
#define QUEUESIZE 32 //隊列大小
#define SLICETIME 5 //時間片
static int SYSTIME = 0; //假設系統時間
int EstimateRunTime(int JobWeight)
{
return JobWeight;
} /*估計進程運行時間*/
typedef struct MyProcess
{
char* MyProcessname;
int CreateTime;
int LastExecTime;
int JobWeight;
int EstimateUsedTime;
int Priority;
MyProcess *next;
}* MYPROCESS; /*進程定義*/
MYPROCESS CreateMyProcess(char* name, int JW, int Prio)
{
MYPROCESS myproc;
myproc = new MyProcess;
myproc->MyProcessname = new char [10];
strcpy(myproc->MyProcessname,name);
myproc->CreateTime = SYSTIME ;
myproc->LastExecTime = SYSTIME;
myproc->JobWeight = JW ;
myproc->EstimateUsedTime = EstimateRunTime(JW) ;
myproc->Priority = Prio;
myproc->next=NULL;
return myproc;
} /*創建進程*/
void BurstTime(int st)
{
SYSTIME += st ;
} /*改變系統時間*/
void PriorityScheduling(MYPROCESS myproc)
{
if ((SYSTIME-myproc->LastExecTime) > myproc->EstimateUsedTime)
{
myproc->Priority--;
if (myproc->Priority<0)
{
myproc->Priority=0;
}
}
} /*優先級調度*/
class MultiPriorityQueueSchedule
{
private:
MYPROCESS MultiPriorityQueue[QUEUESIZE];
private:
void MPQSFreeProcess(MYPROCESS);
MYPROCESS MPQSSelectProcess();
void MPQSRunProcess(MYPROCESS);
void MPQSGoAfter(MYPROCESS);
void MPQSPriorityScheduling();
public:
MultiPriorityQueueSchedule();
bool MPQSAppendProcess(MYPROCESS);
void MPQSExecute();
void MPQSDisplayQueue(ofstream&);
}; /*多優先級調度隊列的定義*/
MultiPriorityQueueSchedule::MultiPriorityQueueSchedule(){
for(int i=0;i<QUEUESIZE;i++)
{
MultiPriorityQueue[i] = NULL;
}
} /*構造函數*/
bool MultiPriorityQueueSchedule::MPQSAppendProcess(MYPROCESS myproc)
{
if (myproc->Priority >= QUEUESIZE)
{
return false;
}
myproc->next = MultiPriorityQueue[myproc->Priority];
MultiPriorityQueue[myproc->Priority] = myproc;
return true;
} /*在多優先級隊列中加入進程*/
void MultiPriorityQueueSchedule::MPQSFreeProcess(MYPROCESS myproc)
{
MultiPriorityQueue[myproc->Priority] = myproc->next ;
delete myproc;
} /*釋放進程*/
MYPROCESS MultiPriorityQueueSchedule::MPQSSelectProcess()
{
int SearchNum ;
for(SearchNum = 0; SearchNum < QUEUESIZE; SearchNum++ )
{
if (MultiPriorityQueue[SearchNum] != NULL)
{
return MultiPriorityQueue[SearchNum];
}
}
return NULL;
} /*選擇運行進程*/
void MultiPriorityQueueSchedule::MPQSGoAfter(MYPROCESS myproc)
{
int QueueNum;
QueueNum = myproc->Priority ;
MultiPriorityQueue[QueueNum] = myproc->next;
MYPROCESS proctemp;
proctemp= MultiPriorityQueue[QueueNum];
if (proctemp == NULL)
{
MultiPriorityQueue[QueueNum] = myproc;
return;
}
while (proctemp->next != NULL)
{
proctemp = proctemp->next ;
}
proctemp->next = myproc ;
myproc->next=NULL;
} /*將運行後的進程放到隊列尾部*/
void MultiPriorityQueueSchedule::MPQSPriorityScheduling()
{
int PriorityNum ;
MYPROCESS myproc;
MYPROCESS proctemp;
for(PriorityNum = 0; PriorityNum < QUEUESIZE; PriorityNum++ )
{
myproc = MultiPriorityQueue[PriorityNum];
while (myproc!=NULL)
{
PriorityScheduling(myproc);
if (myproc->Priority != PriorityNum)
{
MultiPriorityQueue[PriorityNum]=myproc->next;
MPQSAppendProcess(myproc);
myproc=MultiPriorityQueue[PriorityNum];
}
else
break;
}
while (myproc!=NULL&&myproc->next!=NULL)
{
PriorityScheduling(myproc->next);
if (myproc->next->Priority!=PriorityNum)
{
proctemp=myproc->next;
myproc->next=myproc->next->next;
MPQSAppendProcess(proctemp);
}
else
myproc=myproc->next;
}
}
}
void MultiPriorityQueueSchedule::MPQSRunProcess(MYPROCESS myproc)
{
if(myproc == NULL)
return;
int Runtime;
Runtime = (pow(2,myproc->Priority))*SLICETIME ;
myproc->EstimateUsedTime -= Runtime;
if (myproc->EstimateUsedTime <= 0)
{
BurstTime(Runtime+myproc->EstimateUsedTime);
cout<<SYSTIME<<" /t"<<myproc->MyProcessname<<" /t"<<myproc->Priority<<" /tFree"<<endl;
MPQSFreeProcess(myproc);
}
else
{
BurstTime(Runtime);
cout<<SYSTIME<<" /t"<<myproc->MyProcessname<<" /t"<<myproc->Priority<<" /tSwitch"<<endl;
MPQSGoAfter(myproc);
}
} /*多優先級隊列中的優先級調整調度*/
void MultiPriorityQueueSchedule::MPQSExecute()
{
MYPROCESS myproc;
do {
myproc=MPQSSelectProcess();
MPQSRunProcess(myproc);
MPQSPriorityScheduling();
} while(myproc!=NULL);
} /*運行進程*/
void MultiPriorityQueueSchedule::MPQSDisplayQueue(ofstream& fout)
{
int SearchNum ;
MYPROCESS myproc;
for(SearchNum = 0; SearchNum < QUEUESIZE; SearchNum++ )
{
myproc = MultiPriorityQueue[SearchNum];
while (myproc != NULL)
{
fout<<myproc->MyProcessname<<" /t"<<myproc->Priority<<" /t"<<myproc->EstimateUsedTime<<endl;
myproc = myproc->next ;
}
}
} /*顯示多優先級隊列的狀態*/