使用动态优先权的进程调度算法模拟(安排上了！)

1、实验目的

通过动态优先权算法的模拟加深对进程概念进程调度过程的理解。

2、实验内容

（1）用C语言来实现对N个进程采用动态优先权优先算法的进程调度。

（2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：

           •••• 进程标识数 ID。

           •••• 进程优先数 PRIORITY，并规定优先数越大的进程，其优先权越高。

          •••• 进程已占用的CPU时间CPUTIME。

          •••• 进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。

          •••• 进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，将进入阻塞状态。

          •••• 进程被阻塞的时间BLOCKTIME，表示已足赛的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。

          •••• 进程状态START。

          •••• 队列指针NEXT，用来将PCB排成队列。

  （3）优先数改变的原则：

        •••进程在就绪队列中呆一个时间片，优先数加1。

        •••进程每运行一个时间片，优先数减3。

   （4）假设在调度前，系统中有5个进程，它们的初始状态如下：

ID	0	1	2	3	4
PRIORITY	9	38	30	29	0
CPUTIME	0	0	0	0	0
ALLTIME	3	3	6	3	4
STARTBLOCK	2	-1	-1	-1	-1
BLOCKTIME	3	0	0	0	0
STATE	READY	READY	READY	READY	READY

程序要求:为了清楚的观察各进程的调度过程，程序应将每个时间片内的情况显示出来，参照的具体格式如下：

 

RUNNING PROG：i

READY-QUEUE：-〉id1-〉id2

BLOCK-QUEUE：-〉id3-〉id4

= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = == = =

ID                                             0            1            2            3            4

PRIORITY                               P0          P1          P2          P3          P4

CUPTIME                                C0         C1         C2         C3         C4

ALLTIME                                A0         A1         A2         A3         A4

STARTBLOCK                        T0          T1          T2          T3          T4

BLOCKTIME                          B0         B1         B2         B3         B4

STATE                                     S0          S1          S2          S3          S4

---

代码如下:

priority= -1：    已执行完的进程或者已被阻塞的进程优先级设置为-1

temp[i]:       储存已阻塞的进程i的优先级

process[i].startblock=  n  :     表示进程再执行n个时间片开始阻塞；-1表示不会阻塞

 

#include 
#include    //经查阅，使用库中 max_element(first,last)函数，函数返回值为数组最大元素的地址 
using namespace std;
enum State {ready,block,done }; //枚举变量  0-ready   1-block    2-done
struct Process {              //进程结构体定义
	int ID;
	int priority;
	int cputime;
	int alltime;
	int startblock;
	int blocktime;
	State state;

};

Process process[5];       //5个进程

int main() {

	void print();
	process[0].ID=0;
	process[0].priority=9;
	process[0].cputime=0;
	process[0].alltime=3;
	process[0].startblock=2;
	process[0].blocktime=3;
	process[0].state=ready;

	process[1].ID=1;
	process[1].priority=38;
	process[1].cputime=0;
	process[1].alltime=3;
	process[1].startblock=-1;
	process[1].blocktime=0;
	process[1].state=ready;

	process[2].ID=2;
	process[2].priority=30;
	process[2].cputime=0;
	process[2].alltime=6;
	process[2].startblock=-1;
	process[2].blocktime=0;
	process[2].state=ready;

	process[3].ID=3;
	process[3].priority=29;
	process[3].cputime=0;
	process[3].alltime=3;
	process[3].startblock=-1;
	process[3].blocktime=0;
	process[3].state=ready;

	process[4].ID=4;
	process[4].priority=0;
	process[4].cputime=0;
	process[4].alltime=4;
	process[4].startblock-1;
	process[4].blocktime=0;
	process[4].state=ready;


	int timeslice=0;                    //时间片
	int temp[5];                       // 阻塞进程优先级  缓存数组
	while(process[0].alltime||process[1].alltime||process[2].alltime||process[3].alltime||process[4].alltime) { //存在进程没有执行完成

		for(int i=0; i<5; i++) {
			int array[]= {process[0].priority,process[1].priority,process[2].priority,process[3].priority,process[4].priority};  //所有进程优先级 存储数组
			if((process[i].state==ready) && (process[i].priority==*max_element(array,array+5))) {               //进程i开始执行

				timeslice++;
				process[i].priority-=3;
				process[i].cputime+=1;
				process[i].alltime-=1;

				for(int j=0; j<5; j++) {                         //其余就绪进程优先级 加1
				
					if(j==i) continue;                    //跳过当前进程的优先级+1操作 
					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<5; j++) {                                         //其他阻塞进程  blocktime  -1
				
					if(process[j].state==block&&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;                       
						temp[i]=process[i].priority;        //进程i阻塞后   将优先级保存到 temp[i]
						process[i].priority=-1;
					}
				}

				cout<<"时间片为:"<"<"<