操作系统进程调度模拟算法实现（C/C++）

实验内容

实验目的

用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

实验内容

1、设计简单的进程PCB 结构，完成进程信息记录；
2、设计一个有 N个进程并发执行的进程调度程序（以下三选一）
1）编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。静态优先数是在创建进程时确定的，并在整个进程运行期间不再改变。动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定原则修改优先数。例如：在进程获得一次CPU后就将其优先数减少1。或者进程等待的时间超过某一时限时增加其优先数的值，等等。

2）编写并调试一个模拟的进程调度程序，采用“轮转法”调度算法对五个进程进行调度。轮转法可以是简单轮转法、可变时间片轮转法，或多队列轮转法。简单轮转法的基本思想是：所有就绪进程按 FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。如果运行进程用完它的时间片后还为完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。直至所有的进程运行完毕。
3）编写并调试一个模拟的进程调度程序，采用“短进程优先”调度算法对五个进程进行调度。
3、完成设计的调度算法的测试
使用下表进程（几乎同时到达）作为测试数据完成设计的调度算法的测试，输出各个进程的周转时间和带权周转时间，计算并输出平均周转时间和平均带权周转时间。

参考进程信息

进程名	到达时间	运行时间	优先级
A	0	3	2
B	1	6	1
C	2	4	3
D	2	5	4
E	2	2	5

实验代码

参考源码

#include 
#include 
#include 
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0

struct pcb{	/* 定义进程控制块PCB */
	char name[10];
	char state;
	int super;
	int ntime;
	int rtime;
	struct pcb* link;
}*ready=NULL,*p;

typedef struct pcb PCB;

void sort(){	/* 建立对进程进行优先级排列函数 */
	PCB*first, *second;
	int insert=0;
	/*优先级最大者,插入队首*/
	if((ready==NULL)||((p->super)>(ready->super))){
		p->link=ready;
		ready=p;
	} 
	else{	/* 进程比较优先级,插入适当的位置中 */
		first=ready;
		second=first->link;
		while(second!=NULL){
			if((p->super)>(second->super))/*若插入进程比当前进程优先数大,*/
			{ /*插入到当前进程前面*/
				p->link=second;
				first->link=p;
				second=NULL;
				insert=1;
			}
			else /*向后移动指针*/
			{
				first=first->link;
				second=second->link;
			}
		}
		/*插入进程优先数最低,则插入到队尾*/
		if(insert==0) first->link=p;
	}
}

void input() /* 建立进程控制块函数*/
{
	int i,num;
	system("dir");
	//clrscr(); /*清屏*/
	printf("\n 请输入进程数 ");
	scanf("%d",&num);
	for(i=0;i<num;i++){
		printf("\n进程号No.%d:\n",i);
		p=getpch(PCB);
		printf("\n输入进程名:");
		scanf("%s",p->name);
		printf("\n输入进程优先数:");
		scanf("%d",&p->super);
		printf("\n输入进程运行时间:");
		scanf("%d",&p->ntime);
		printf("\n");
		p->rtime=0;p->state='w';
		p->link=NULL;
		sort(); /*调用sort函数*/
	}
}

int space(){
	int l=0; PCB* pr=ready;
	while(pr!=NULL)
	{
		l++;
		pr=pr->link;
	}
	return(l);
}

void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/
{
	printf("\n qname \t state \t super \tndtime \t runtime \n");
	printf("|%s\t",pr->name);
	printf("|%c\t",pr->state);
	printf("|%d\t",pr->super);
	printf("|%d\t",pr->ntime);
	printf("|%d\t",pr->rtime);
	printf("\n");
}

void check() /* 建立进程查看函数 */
{
	PCB* pr;
	printf("\n ****当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/
	disp(p);
	pr=ready;
	printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/
	while(pr!=NULL)
	{
		disp(pr);
		pr=pr->link;
	}
}

void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
{
	printf("\n进程[%s]已完成.\n",p->name);
	free(p);
}

void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
{
	(p->rtime)++;
	if(p->rtime==p->ntime)
		destroy(); /* 调用destroy函数*/
	else
	{
		(p->super)--;
		p->state='w';
		sort(); /*调用sort函数*/
	}
}

void main() /*主函数*/
{
	int len, h=0;
	char ch;
	input();
	len=space();
	while((len!=0)&&(ready!=NULL))
	{
		ch=getchar();
		h++;
		printf("\n The execute number:%d\n",h);
		p=ready;
		ready=p->link;
		p->link=NULL;
		p->state='R';
		check();
		running();
		printf("\n按任一键继续......");
		ch=getchar();
	}
	printf("\n\n进程已经完成.\n");
	ch=getchar();
}

短进程优先算法–无优先级

//短进程优先调度算法
#include 
#include 
 
//定义一个结构体：PCB
struct pcb{   
	char name[10];   
	float arrivetime;   
	float servicetime;   
	float starttime;   
	float finishtime;   
	float zztime;   
	float dqzztime;   
}; 
 
//***输入进程信息，将N个进程的信息写入pcb型数组***
void input(pcb *p,int N)   
{
	int i;   
	printf("\n");
	for(i=0; i <= N-1; i++)   
	{   
		printf("请输入进程%d的进程名：", i+1);
		scanf("%s", &p[i].name);
		printf("请输入进程到达时间:");	
		scanf("%f", &p[i].arrivetime);
		printf("请输入进程运行时间:");
		scanf("%f", &p[i].servicetime);	
		printf("\n");
	}   
}
   
//***优先级排序***
void sort(pcb *p, int N)   
{   
	
	/*
	1、对pcb型数组中的元素进行一个简单的排序
	找到优先级最高的进程
	并把其他进程也进行简单排序，方便后续工作
	*/
	//排序: N次循环,每次找到从i到N-1中优先级最高的进程，放到p[i]
	for(int i=0;i<=N-1;i++)  
	{
		//循环比较剩余的变量    //排序后：从0~N-1  arrivetime增加 ， arrivetime相同时， servicetime短的优先 
		for(int j=i+1;j<N;j++) 
		{
			if(p[i].arrivetime>p[j].arrivetime || (p[i].arrivetime==p[j].arrivetime && p[i].servicetime>p[j].servicetime) )   
			{  
				//p[j]的优先级高于p[i],因此把p[j]放到p[i]
				pcb temp;   
				temp = p[i];   
				p[i] = p[j];   
				p[j] = temp;   
             } 
		}
	}
	/*
	2、每个进程运行完成之后，找到当前时刻已经到达的最短进程
	P[0]优先级最高，p[0].finishtime=p[0].arrivetime+p[0].servicetime
	m!=0时：p[m].finishtime=p[m-1].finishtime+p[m].servicetime
	*/
	for(int m=0; m<N-1; m++)      
	{
		if(m == 0)   
			p[m].finishtime = p[m].arrivetime + p[m].servicetime;   
		else
			p[m].finishtime = ((p[m-1].finishtime >= p[m].arrivetime)? p[m-1].finishtime: p[m].arrivetime) + p[m].servicetime;
		//(1)找到p[m].finishtime时刻哪些进程已经到达
		int i=0;  //i统计 p[m].finishtime时刻有几个进程已经到达
		//从下一个进程p[m+1]开始寻找
		for(int n = m+1; n <= N-1; n++)   
		{
			if(p[n].arrivetime <= p[m].finishtime)              
				i++;   
			else
				break;
			    /*由于在第1步已经对进程按照到达时间进行了排序
			      故：当p[n].arrivetime > p[m].finishtime时，
				      说明p[n]进程和其后面的其他进程都未到达。
				i的值为p[m].finishtime时刻已经到达的进程数目。
			   */
		}  
		//(2)找到p[m].finishtime时刻已经到达的最短进程
		float min = p[m+1].servicetime;   //next进程服务时间为p[m+1].servicetime （初值） 
		int next = m+1;                   //next进程为m+1 （初值） 
		//p[m+1]至p[m+i]这i个已到达进程中找到最短进程
		for(int k = m+1; k < m+i; k++)       //k为m+1 ~ m+i-1   
		{   
			//min的初值是p[m+1].servicetime, k+1为m+2 ~m+i 
			if(p[k+1].servicetime < min)   
			{
				min = p[k+1].servicetime;              
				next = k+1;
			}                              
		}  
		//(3)把最短进程放在p[m+1]进程处
		pcb temp;               
		temp=p[m+1];              
		p[m+1]=p[next];              
		p[next]=temp;           
	}    
} 
  
//***运行***
void run(pcb *p, int N)   
{
	int k; 
	//计算各进程的开始时间和结束时间
	for(k=0; k <= N-1; k++)   
     {            
		if(k==0) //第1个进程   
		{     
			p[k].starttime = p[k].arrivetime; //第1个进程到达之后即可执行   
			p[k].finishtime = p[k].starttime + p[k].servicetime; 
		}    
		else 
		{    
			p[k].starttime = (p[k-1].finishtime >= p[k].arrivetime)? p[k-1].finishtime: p[k].arrivetime;    
			p[k].finishtime = p[k].starttime + p[k].servicetime;
		}    
	} 
	//计算各进程的周转时间和带权周转时间
	for(k=0; k<=N-1; k++)   
	{        
		p[k].zztime = p[k].finishtime - p[k].arrivetime;   
		p[k].dqzztime = p[k].zztime / p[k].servicetime;   
     }   
}  
 
//***显示***
void Print(pcb *p, int N)   
{
	int k;      
	printf("调用最短进程优先算法以后进程运行的顺序是: ");
	printf("%s",p[0].name); 
	for(k=1;k<N;k++)   
	{
		printf("-->");		
		printf("%s", p[k].name); 
	}    
	printf("\n"); 
	printf("具体进程调度信息:\n");
	printf("进程名  到达时间  服务时间  开始时间  结束时间  周转时间  带权周转时间\n");
	for(k=0; k<=N-1; k++)        
	{	
		printf("%4s", p[k].name);
		//%m.nf：输出共占m列，其中有n位小数，如数值宽度小于m左端补空格
		printf("%10.3f", p[k].arrivetime);	
		printf("%10.3f", p[k].servicetime);
		printf("%10.3f", p[k].starttime);
		printf("%10.3f", p[k].finishtime);
		printf("%10.3f", p[k].zztime);
		printf("%10.3f\n", p[k].dqzztime);
	}         
}  
  
//***短进程优先***
void sjff(pcb *p,int N)   
{
	sort(p, N);                 
	run(p, N);         
	Print(p, N);  
	int k;
	float Attime = 0; // 平均周转时间 
	float AQttime = 0; //平均带权周转时间 
	for(k=0; k<=N-1; k++)    
     {   
		Attime += p[k].zztime;  
		AQttime += p[k].dqzztime;		
     }  
	Attime = Attime/N; 
	AQttime = AQttime/N;
	printf("调用短进程优先算法的平均周转时间为:");
	printf("%.3f\n", Attime);
	printf("调用短进程优先算法的平均带权周转时间为:");
	printf("%.3f\n", AQttime);      
}   
 
//***主函数***
int main()   
{ 
	//定义一个pcb型数组a
	pcb a[100]; 
	int N;  //进程数目                    		
	printf("\n");                          		
	printf("\n");		
	printf("<<----------******短进程优先调度算法******---------->>");	
	printf("\n");	
	printf("请输入进程数目:");
	scanf("%d", &N);                 		
	input(a, N);  		
	sjff(a, N);
	return 0; 
}   

短进程优先算法–无优先级 运行结果

短进程优先调度–有优先级

//短进程优先调度算法
#include
#include
#define MAX 10

/* 定义进程控制块PCB */
struct pcb{
	char name[10]; //进程名
	int super;     //进程优先级
	int need_time;  //运行时间
	float come_time;   //到达时间
	float start_time; //开始运行时间
	float end_time;   //结束运行时间
	int run_flag;     //调度标志
	int order;        //运行次序
}p[MAX];

/* 建立进程控制块函数 输入进程信息*/
int input(){
	int i,num;
	printf("\n请输入进程数:");
	scanf("%d",&num);
	for(i=0;i<num;i++){
		printf("\n******************************");
		printf("\n进程号:%d\n",i);
		printf("请输入进程名:");
		scanf("%s",&p[i].name);
		printf("请输入进程到达时间:");
		scanf("%f",&p[i].come_time);
		printf("请输入进程运行时间:");
		scanf("%d",&p[i].need_time);
		printf("请输入进程优先级:");
		scanf("%d",&p[i].super);
		p[i].start_time = 0;
		p[i].end_time = 0;
	}
	printf("\n");
	return num;
}

/* 显示 */
void print(int num){
	int k;
	float turn_round_time=0,f1,w=0;
	float s1=0;
	float s2=0;
	printf("调用最短进程优先算法以后进程运行的顺序是: ");
	printf("%s",p[0].name);
	for(k=1;k<num;k++){
		printf("-->");
		printf("%s",p[k].name);
	}
	printf("\n");
	printf("具体进程信息调度信息:\n");
	printf("进程名  到达时间  运行时间  开始时间  结束时间  优先级  周转时间  带权周转时间\n");
	for(k=0;k<num;k++){
		f1=p[k].end_time - p[k].come_time; 
		turn_round_time += f1; 
		w += (f1 / p[k].need_time);
		s1 = (float)p[k].need_time;
		s2 = f1;

		printf("%4s",p[k].name);
		printf("%10.2f",p[k].come_time);
		printf("%10d",p[k].need_time);
		printf("%10.2f",p[k].start_time);
		printf("%10.2f",p[k].end_time);
		printf("%10d",p[k].super);
		printf("%10.2f",f1);
		printf("%10.2f",s2 / s1);
		printf("\n");
	}
	printf("平均周转时间=%5.2f\n",turn_round_time/num);
	printf("平均带权周转时间=%5.2f\n",w/num);
}

/* 短进程优先 */
void sjff(int counter){
	float tmp_time = 0;
	int i=0,j=1;
	int num_schedul, tmp_counter;/* 正在被调度执行的进程编号和已经调度完成的进程个数*/
	float run_time;
	run_time = (float)p[i].need_time;
	/* 从到达时间最早且相同的进程中查找第一个被调度的进程 */
	while((j<counter)&&(p[i].come_time==p[j].come_time)){
		if(p[j].need_time<p[i].need_time){
			run_time = (float)p[j].need_time;
			i=j;
		}
		j++;
	}
	/* 对第一个被调度的进程求相应的参数	*/
	num_schedul = i;
	p[num_schedul].start_time = p[num_schedul].come_time;
	p[num_schedul].end_time = p[num_schedul].start_time + p[num_schedul].need_time;
	p[num_schedul].run_flag = 1;
	tmp_time = p[num_schedul].end_time;
	p[num_schedul].order = 1;
	tmp_counter = 1;
	/* 循环查找下一个被调度的进程，直到所有的tasks[j].run_flag ==1*/
	while(tmp_counter<counter){
		for(j=0;j<counter;j++){
			if((p[j].come_time<=tmp_time)&&(!p[j].run_flag)){
				run_time=(float)p[j].need_time;
				num_schedul = j;
				break;
			}
		}
		/*	找到到“目前”为止,最短的进程，即run_time最小的进程 */
		for(j=0;j<counter;j++){
			if((p[j].come_time<=tmp_time)&&(!p[j].run_flag)){
				if(p[j].need_time<run_time){
					run_time=(float)p[j].need_time;
					num_schedul=j;
				}
			}
		}
		/* 对找到的下一个被调度的进程求相应的参数	*/
		p[num_schedul].start_time=tmp_time;
		p[num_schedul].end_time=p[num_schedul].start_time + p[num_schedul].need_time;
		p[num_schedul].run_flag=1;
		tmp_time=p[num_schedul].end_time;
		tmp_counter++;
		p[num_schedul].order=tmp_counter;
	}
}

/* 主函数 */
int main(){
	int counter = 0;
	printf("\n");
	printf("<<----------******短进程优先调度算法******---------->>");
	counter = input();
	sjff(counter);
	print(counter);
	return 0;
}

短进程优先调度–有优先级 运行结果

进程调度综合算法

包括先来先服务调度，短进程优先调度，优先级调度，响应比高优先调度

#include
#define MAX 10

struct task_struct{
	char name[10];	/* 进程名称 */
	int number;	/* 进程编号 */
	float come_time;			/* 到 达 时 间 */
	float run_begin_time;		/* 开始运行时间	*/
	float run_time;	/* 运行时间 */
	float run_end_time;		/* 运行结束时间	*/ 
	int priority;	/* 优先级 */
	int order;	/* 运行次序 */
	int run_flag;	/* 调度标志 */
}tasks[MAX];

int counter; /* 实际进程个数	*/ 
int fcfs();		/* 先来先服务 */ 
int ps();	/* 优先级调度 */
int sjf();	/* 短作业优先  */
int hrrn();	/* 响应比高优先	*/ 
int pinput(); /*  进程参数输入	*/
int poutput(); /*  调度结果输出	*/

void main()
{
	int option; 
	pinput();
	printf(" 请选择调度算法(0~4):");
	printf("1. 先来先服务:");
	printf("2. 优先级调度:"); 
	printf(" 3. 短作业优先:");
	printf(" 4. 响应比高优先:"); 
	printf(" 0. 退 出:");
	scanf("%d",&option);
	switch (option){ 
	case 0:
		printf(" 运行结束\n");
		break;
	case 1:
		printf(" 对进程按先来先服务调度\n");
		fcfs();
		poutput();
		break;
	case 2:
		printf(" 对进程按优先级调度\n");
		ps();
		poutput();
		break;
	case 3:
		printf(" 对进程按短作业优先调度\n");
		sjf();	
		poutput();
		break;
	case 4:
		printf(" 对进程按响应比高优先调度\n");
		hrrn();
		poutput();
		break;
	}
}

/*	FCFS  非抢占式先来先服务*/
/*
	该程序段默认进程已经按到达先后顺序排成了队列 
	如果考虑输入为乱序，
	还需要根据come_time对进程进行排队，形成一个先来后到的队列	
*/
int fcfs() {
	float time_temp=0; int i;
	int number_schedul; time_temp=tasks[0].come_time;
	for(i=0;i<counter;i++){
		tasks[i].run_begin_time=time_temp; tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time; tasks[i].run_flag=1;
		time_temp=tasks[i].run_end_time; number_schedul=i; tasks[number_schedul].order=i+1;
	}
	return 0;
}

/* 非抢占式优先级调度 */
/* 
	默认tasks[0]是最早到达的进程，进程已按到达先后顺序排成了队列	
*/ 
int ps(){
	float temp_time=0; int i=0,j;
	int number_schedul,temp_counter; /* 正在被调度执行的进程编号和已经调度完成的进程个数	*/ 
	int max_priority;
	max_priority=tasks[i].priority; j=1;

	/*	从到达时间最早且相同的进程中遍历，查找第一个被调度的进程	*/
	while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))/* 寻找到达时间相同优先级最高的进程 */
	{
		if (tasks[j].priority>tasks[i].priority){
			max_priority=tasks[j].priority; i=j;
		}
		j++;
	}

	/* 对第一个被调度的进程求相应的参数	*/ 
	number_schedul=i;
	tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time; tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
	tasks[number_schedul].run_flag=1; temp_time=tasks[number_schedul].run_end_time; tasks[number_schedul].order=1;
	temp_counter=1;

	/* 循环查找下一个被调度的进程，直到所有的	tasks[j].run_flag ==1 */ 
	while (temp_counter<counter){
		max_priority=0; 
		for(j=0;j<counter;j++){ 
			if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)){
				if (tasks[j].priority>max_priority){
					max_priority=tasks[j].priority; number_schedul=j;
				}
			}
		}
	/* 对找到的下一个被调度的进程求相应的参数	*/ 
	tasks[number_schedul].run_begin_time=temp_time;
	tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
	tasks[number_schedul].run_flag=1;
	temp_time=tasks[number_schedul].run_end_time; temp_counter++; 
	tasks[number_schedul].order=temp_counter;
	}
	return 0;
}
 
/*  非抢占式短作业优先 */ 
/*
	默认tasks[0] 是最早到达的进程,进程已按到达先后顺序排成了队列
*/
int sjf(){
	float temp_time=0; 
	int i=0,j;
	int number_schedul,temp_counter; /* 正在被调度执行的进程编号和已经调度完成的进程个数*/
	float run_time; /*  借助该局部变量可以帮助找到执行时间	run_time 最短进程 */ 
	run_time=tasks[i].run_time;
	j=1;
	/* 从到达时间最早且相同的进程中查找第一个被调度的进程 */ 
	while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time)){
		if (tasks[j].run_time<tasks[i].run_time){
			run_time=tasks[j].run_time; 
			i=j;
		}
		j++;
	}
	/* 对第一个被调度的进程求相应的参数	*/ 
	number_schedul=i;
	tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time;
	tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
	tasks[number_schedul].run_flag=1; temp_time=tasks[number_schedul].run_end_time; tasks[number_schedul].order=1;
	temp_counter=1;
	/* 循环查找下一个被调度的进程，直到所有的tasks[j].run_flag ==1*/ 
	while (temp_counter<counter){		/* 找到在上一个进程执行期间（到“目前”为止）到达时间最晚的一个进程	*/ 
		for(j=0;j<counter;j++){
			if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)){ 
				run_time=tasks[j].run_time;number_schedul=j;
				break;
			}
		}
		/*	找到到“目前”为止，最短的进程，即	run_time	最小的进程 */ 
		for(j=0;j<counter;j++){ 
			if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)){

				if(tasks[j].run_time<run_time){
					run_time=tasks[j].run_time; 
					number_schedul=j;
				}
			}
		}
		/* 对找到的下一个被调度的进程求相应的参数	*/ 
		tasks[number_schedul].run_begin_time=temp_time;
		tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
		tasks[number_schedul].run_flag=1;
		temp_time=tasks[number_schedul].run_end_time; temp_counter++; 
		tasks[number_schedul].order=temp_counter;
	}
	return 0;
}

/* 非抢占式响应比高优先 */
/*
	默认tasks[0] 是最早到达的进程，进程已按到达先后顺序排成了队列
*/
int hrrn(){ 
	int j,number_schedul,temp_counter;
	float temp_time,respond_rate,max_respond_rate;
	/* 
		第一个进程被调度，系统刚开始运行时，同时到达的进程响应比都为0(按该程序所采用的等待时间 /运行时间这个公式算)
		因此按队列顺序必然是第一个进程最先被调度
	*/ 
	tasks[0].run_begin_time=tasks[0].come_time;
	tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time; 
	temp_time=tasks[0].run_end_time;
	tasks[0].run_flag=1; 
	tasks[0].order=1; 
	temp_counter=1;
	/* 调度其他进程	*/ 
	while(temp_counter<counter){
		max_respond_rate=0;
		/* 找响应比高的进程	*/ 
		for(j=1;j<counter;j++){
			if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)){ 
				respond_rate=(temp_time-tasks[j].come_time)/tasks[j].run_time; 
				if (respond_rate>max_respond_rate){
					max_respond_rate=respond_rate;
					number_schedul=j;
				}
			}
		}
		tasks[number_schedul].run_begin_time=temp_time;
		tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
		temp_time=tasks[number_schedul].run_end_time;
		tasks[number_schedul].run_flag=1; 
		temp_counter+=1; tasks[number_schedul].order=temp_counter;
	}
	return 0;
}

/*  进程参数输入	*/
int pinput(){ 
	int i;
	printf("please input the 进程数:"); scanf("%d",&counter);
	for(i=0;i<counter;i++){ 
		printf("******************************************\n"); 
		printf("please input the process of %d th :\n",i+1);
		printf("please input the 进程名:"); 
		scanf("%s",tasks[i].name); 
		printf("please input 进程编号:"); 
		scanf("%d",&tasks[i].number); 
		printf("please input the 到达时间:"); 
		scanf("%f",&tasks[i].come_time);
		printf("please input the 运行时间:"); 
		scanf("%f",&tasks[i].run_time); 
		printf("please input the 优先级:"); 
		scanf("%d",&tasks[i].priority); 
		tasks[i].run_begin_time=0;
		tasks[i].run_end_time=0;
		tasks[i].order=0;
		tasks[i].run_flag=0;
	}
	return 0;
}

/* 调度结果输出	*/
int poutput() {
	int i;
	float turn_round_time=0,f1,w=0;
	float s1=0;
	float s2=0;
	for(i=0;i<counter;i++){
		f1=tasks[i].run_end_time-tasks[i].come_time; 
		turn_round_time+=f1; w+=(f1/tasks[i].run_time);
		s1=tasks[i].run_time;
		s2=f1;
		printf("进程名\t进程编号\t到达时间\t运行时间\t运行开始时间\t运行结束时间\n");
		printf(" %s\t%d\t%.2f\t%.2f\t%.2f\t%.2f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time);
		printf("优先级\torder\t周转时间\t带权周转时间\n");
		printf("%d\t%d\t%.2f\t%.2f\n",tasks[i].priority,tasks[i].order, f1,s2/s1);
	}
	printf("平均周转时间=%5.2f\n",turn_round_time/counter);
	printf("平均带权周转时间=%5.2f\n",w/counter);
	return 0;
}

进程调度综合算法 运行结果

参考

操作系统进程调度模拟算法实现（C语言版）
短进程（作业）优先调度算法对五个进程进行调度。（C/C++）