使用动态优先权的进程调度算法的模拟

1.实验目的

通过动态优先权算法的模拟加深进程概念和进程调度过程的理解，并学习撰写规范的科学研究报告。

2.实验内容和要求

1．对N个进程采用动态优先权算法的进程调度；
2．每个用来标识进程的进程控制块PCB用结构描述，包括以下字段：进程标识数ID，进程优先数PRIORITY，进程以占用的CPU时间CPUTIME，进程还需占用的CPU时间ALLTIME，进程状态STATE等。
3．优先数改变的原则：进程在就绪队列中呆一个时间片，优先数增加1，进程每运行一个时间片优先数减3。
4．设置调度前的初始状态。
5．将每个时间片内的进程情况显示出来。

3.流程图

4.源程序

#include<iostream>
#include<algorithm>
using namespace std;
enum State {ready,block,done
};

struct Process{
	int id;
	int priority;
	int cputime;//cpu time already  occupied by the process
	int alltime;//cpu time still required by the process
	int startblock;//after the process runs for more than startblock time slices,it will enter a blocked state.
	int blocktime;//after the blocked process waits for "blocktime" time slices,it will translate to the ready state.
	State state;
}; 
Process process[3];
void print();
int main()
{	
	/*process0*/
	process[0].id = 0;
	process[0].priority = 9;
	process[0].cputime = 0;
	process[0].alltime = 2;
	process[0].startblock = 2;
	process[0].blocktime = 2;
	process[0].state = ready;
	/*process1*/
	process[1].id = 1;
	process[1].priority = 38;
	process[1].cputime = 0;
	process[1].alltime = 2;
	process[1].startblock = -1;
	process[1].blocktime = 0;
	process[1].state = ready;
	/*process2*/
	process[2].id = 2;
	process[2].priority = 30;
	process[2].cputime = 0;
	process[2].alltime = 2;
	process[2].startblock = -1;
	process[2].blocktime = 0;
	process[2].state = ready;
	
	int timeslice = 0;
	int temp[3];// an array to store blocking process priorities
	
	while(process[0].alltime||process[1].alltime||process[2].alltime){//existing process is not completed
	for(int i=0;i<3;i++)
	{
		int array[]={process[0].priority,process[1].priority,process[2].priority};
		if((ready==process[i].state)&&(process[i].priority==*max_element(array,array+3)))//process[i] statisfies the conditions and starts execution. 
		{
			timeslice++;
			process[i].priority-=3;
			process[i].cputime+=1;
			process[i].alltime-=1;
		
		for(int j=0;j<3;j++){//increase the priority of the remaining processes by one.
			if(j==i) continue;//skip current process
			if(process[j].alltime>0 && process[j].state == ready)
			{
				process[j].priority+=1;
			}
		}
		
		if(process[i].alltime == 0)
		{
			process[i].state=done;
			process[i].priority=-1;
		}
	
		for(int j=0;j<3;j++)//blocktime of other blocking processes is reduced by one.
		{
			if(block==process[j].state && process[j].blocktime>0)
			{
				process[j].blocktime -=1;
				if(process[j].blocktime==0){
					process[j].state=ready;
					process[j].priority=temp[j];
				}	
			}
			
		}
		
		if(process[i].startblock>0){
			process[i].startblock-=1;
			if(process[i].startblock==0)
			{
				process[i].state=block;//this process is blocked. 
				temp[i]=process[i].priority;//save the priority of the process to the temp array. 
				process[i].priority=-1;
			}
		}
		cout<<"the timeslice is:"<<timeslice<<endl;
		cout<<"the execution time is:"<<process[i].id<<endl;
		print();
	}
	}
	
}
	return 0;	
}

void print(){
	cout<<"ready queue:";
	for(int i=0;i<3;i++){
		if(ready==process[i].state)
		{
			cout<<"->"<<process[i].id;	
		}
	}
	
	cout<<endl;
	cout<<"blocked queue:"<<endl;
	for(int i=0;i<3;i++)
	{
		if(block==process[i].state)
		{
			cout<<"->"<<process[i].id;
		}
	}
	cout<<endl;
	cout<<"id |\t priority |\t cputime |\t alltime |\t startblock |\t blocktime |\t state"<<endl;
	for(int i=0;i<3;i++)
	{
		cout<<process[i].id<<"|"<<"\t\t"<<process[i].priority<<"|"<<"\t\t"<<process[i].cputime<<"|"<<"\t\t"<<process[i].alltime<<"|"<<"\t\t"<<process[i].startblock<<"|"<<"\t\t"<<process[i].blocktime<<"|"<<"\t\t"<<process[i].state<<endl;
	}
}

5.实验步骤与调试

1.定义Process结构体

struct Process{
	int id;
	int priority;
	int cputime;//程序已经占用的cpu时间
	int alltime;//程序还需要占用的cpu时间
	int startblock;//程序运行超过startblock时间片后进入阻塞状态
	int blocktime;//程序再等待blocktime时间片后从block状态进入ready状态
	State state;//定义枚举数组，enum State{ready,block,done};
};

2.定义print()函数
print()函数要输出的有：当前时间片内的ready进程队列、block进程队列、每个进程的PCB字段。

3.定义main()函数
main()函数中，首先给出三个进程的PCB字段信息，即定义process0、1、2。
初始时间片slicetime设置为0，当有进程的process.alltime不为0，即还有进程需要占用CPU，则执行while循环。用array[]数组来保存各个进程的优先级，用max_element(array,array+3)来返回最大优先级对应的process地址。每次循环找优先级最高的进程，执行后该进程优先级-3，其余ready状态进程优先级+1。其他PCB信息也随之改变。print()函数输出此时间片的各进程信息，进入下一个时间片。程序执行到所有进程的alltime为0结束。

4.初始状态三个进程的PCB信息

程序运行过程中遇到的问题
刚开始运行程序的时候，发现每一个时间片都输出了3次，然后每一次只改变了1个进程的PCB信息，但是理想输出应该是每个时间片输出1次，每次输出3个进程的PCB改变信息，后面调试发现，print()函数在循环中的位置放错了，改正后程序运行的时间片数slicetimes 为6，而3个进程的alltime总和也为6，符合预期。

运行结果