进程动态优先调度算法

前言：进程动态优先调度算法笔记，这边简单的记录下，可能代码不太完善

题目和实验要求

• 假设在调度前，系统中有3个进程，合理设计它们的初始状态。

在代码中的体现就是：PCB process[PROCESS_SIZE] = { {0,9,0,2,2,2,READY}, {1,38,0,2,-1,0,READY}, {2,30,0,2,-1,0,READY} };

代码

主要讲下自己编写的思路，如下所示

• 首先就是运行态READY的进程每次执行完之后priority数是需要-1的，然后就绪态的进程的话priority都是需要+3，对于队列形式的实现我这里直接就是通过数组来进行判断了

• 正常的进程执行（指的是无start_block的情况）只要到达了指定的获取时间片的使用次数之后就可以直接将state属性设置为完成属性了，下次就不需要将其考虑进来

• 除了正常执行的情况（指的是无start_block的情况），还有的就是需要考虑到某些进程存在start_block和block_time的情况，那么如果执行这个进程的时候对priority修正完了，还需要考虑下时间片的获取次数是否达到了start_block，如果是的话那么就需要那么就需要将其state属性设置为BLOCK，下次就不需要将其考虑进来

• 还有种特殊的情况，我自己也没有仔细想过，就是如果此时单系统执行的时候，此时进程队列中只存活一个进程了，并且该进程是存在start_block和block_time的情况，那么当我们执行完start_block次数之后，这个时候还需要考虑block_time吗？我自己的实现就是不需要进行等待时间片执行的次数了，而是直接将block状态的进程直接重置为READY，然后下次时间片继续执行即可

下面实现的代码并没有对于第四点的情况未做过验证调试，仅作参考

// 操作系统实验作业1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include<stdio.h>
#include<windows.h>

#define PROCESS_SIZE 3
#define READY 0
#define BLOCK 1
#define DONE 2
typedef int status;

typedef struct _PCB {
	int process_id; // 进程标识 id
	int process_priority; // 优先数越大的进程，其优先权越高
	int use_cpu_time; // 当前进程已经占用cpu的时间
	int need_cpu_time; //  还需要占用cpu的时间，当进程完成之后，all_time为0
	int start_block;
	int block_time;
	status state; // 初始状态都是READY的state的情况
}PCB, * PPCB;

void print_process_desc(PCB* ppcb) {
	printf("%8s\t%8s\t%8s\t%8s\t%8s\t%8s\t%8s\n", "id", "priority", "cputime", "all_time", "startblock", "blocktime", "state");
	for (int i = 0;i < PROCESS_SIZE;i++) {
		printf("%8d\t%8d\t%8d\t%8d\t%8d\t%8d\t%8d\n", ppcb[i].process_id, ppcb[i].process_priority, ppcb[i].use_cpu_time, 
			ppcb[i].need_cpu_time, ppcb[i].start_block, ppcb[i].block_time, ppcb[i].state);
	}
}

int get_max_process_id(PCB* ppcb) {
	PCB temp_pcb = ppcb[0];
	for (int i = 1;i < PROCESS_SIZE;i++) {
		if ((temp_pcb.process_priority < ppcb[i].process_priority) && ppcb[i].need_cpu_time > 0 && ppcb[i].state != DONE) {
			temp_pcb = ppcb[i];
		}
	}
	return temp_pcb.process_id;
}

int get_remain_process_num(PCB* ppcb) {
	int remain_process_num = 0;
	for (int i = 0;i<PROCESS_SIZE;i++) {
		if (ppcb[i].state == READY) {
			remain_process_num += 1;
		}
	}
	return remain_process_num;
}

int main(int argc, char** argv) {
	int max_priority_process_id = -1;
	int time_splice = 1;
	int current_process_size = PROCESS_SIZE;
	int process_is_should_block[PROCESS_SIZE] = { 0,0,0, };
	PCB process[PROCESS_SIZE] = { {0,9,0,2,2,2,READY}, {1,38,0,2,-1,0,READY}, {2,30,0,2,-1,0,READY} };

	for (int i = 0;i < PROCESS_SIZE;i++) {
		// 只要存在start_block != -1 ，那么该进程一定情况下会出现主动堵塞的情况
		if (process[i].start_block != -1) {
			// 标记
			process_is_should_block[i] = 1;
		}
	}
	printf("init process: \n");
	print_process_desc(process);
	
	while (time_splice) {

		if (process[0].need_cpu_time + process[1].need_cpu_time + process[2].need_cpu_time == 0) {
			printf("process schedule finish...\n");
			break;
		}
		
		max_priority_process_id = get_max_process_id(&process[0]);
		for (int i = 0;i< PROCESS_SIZE;i++) {
			int self_process_block = -1;
			
			if ( (process[i].process_id != max_priority_process_id) && process[i].need_cpu_time > 0 && process[i].state == READY) {
				process[i].process_priority += 1;
			}else if ((process[i].process_id == max_priority_process_id) && process[i].need_cpu_time > 0 && process[i].state == READY){
				process[i].process_priority -= 3;
				process[i].use_cpu_time += 1;
				process[i].need_cpu_time -= 1;
				
				if (process_is_should_block[i]) {
					process[i].start_block -= 1;

					if (process[i].start_block == 0) {
						process[i].state = BLOCK;
						self_process_block = i;
						// 特殊情况下的处理，如果单系统单进程，那就不需要时间片切换去等待block_time，重置READY状态让下次直接执行即可
						if (get_remain_process_num(&process[0]) == 1) {
							process[i].state = READY;
							process[i].start_block = 0xFF;
						}
					}
				}
			}
			
			for (int i = 0;i<PROCESS_SIZE;i++) {
				// 需要注意的是，要除去本身的情况
				if (process[i].state == BLOCK && i != self_process_block) {
					process[i].start_block += 1;
				}
				
				// 重置当前process的state情况为READY
				if (process[i].start_block == process[i].block_time) {
					process[i].state = READY;
				}
			}

			if (process[max_priority_process_id].need_cpu_time == 0) {
				process[max_priority_process_id].process_priority = -1;
				process[max_priority_process_id].state = DONE;
			}
		}

		printf("current_time_splice: %d\n", time_splice);
		print_process_desc(process);
		
		// 每次循环都是一个时间片
		Sleep(2000);
		time_splice += 1;
	}
	
	return 0;
}