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

最新推荐文章于 2024-08-30 20:45:45 发布
最新推荐文章于 2024-08-30 20:45:45 发布
阅读量7.5k 收藏 117
点赞数 15
分类专栏： 进程调度 文章标签： c语言 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44924407/article/details/109553035
版权

目录

实验内容

实验目的

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

实验内容

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

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

进程名到达时间运行时间优先级
A032
B161
C243
D254
E225

实验代码

参考源码

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#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 <stdlib.h>
#include <stdio.h>
 
//定义一个结构体：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<stdio.h>
#include<stdlib.h>
#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<stdio.h>
#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++）

♡来年秋风起♡
关注
  • 15
    点赞
  • 踩
  • 117
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
操作系统进程调度模拟算法（C实现）
CHOCOLATE
07-03 4535
1、“先来先服务”调度算法 编程思路： 对各进程按照到达时间进行排序，挑选最先到达的进程一次性执行完毕，判断是否所有进程都被调度，若是则结束，否则返回挑选最先到达的进程一次性执行完毕步骤，继续执行后续程序。按照进程进入的先后次序来分配处理器。先进入就绪队列的进程优先被挑选，运行进程一旦占有处理器将一直运行下去，直到运行结束或者被阻塞，这是非抢占式调度。 代码如下： //排序: 按照进程的arrivetime（从小到大）对pcb数组中的N个进程进行排序 void sort(pcb *p, int N)
操作系统-------进程调度算法(C++实现)
M_GSir的博客
11-10 6591
(1)    优先数法 进程就绪队列按优先数大小从高到低排列，链首进程首先投入运行。进程每执行一次，进程需要的时间片数减1、该进程的优先数减3。这样，该进程如果在一个时间片中没有完成，其优先数降低一级。接着仍是用该进程降低一级后的优先数与就绪队列中链首进程的优先数进行比较，如果仍是该进程的优先数高或相同，便让该进程继续执行；否则，调度就绪队列的链首进程投入运行。原运行过的进程按其现行优先数大小插
计算机操作系统进程调度算法模拟
06-11
进程调度算法模拟。通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。 （1） 用C、C++、Java语言编程实现对5个进程采用动态优先权调度算法进行调度的过程。数据如下： 5个进程的到达时刻和服务时间见下表，忽略I/O以及其它开销时间，使用动态优先权算法进行调度，优先权初始值为100，请输出各个进程的完成时刻、周转时间、带权周转时间。 进程 到达时刻 服务时间 A 0 3 B 2 6 C 4 4 D 6 5 E 8 2 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段（用不到的字段可以不定义）。  进程标识数ID。  进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。  进程已占用CPU时间CPUTIME。  进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。  进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。  进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。  进程状态STATE。  队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则：  进程在就绪队列中呆一个时间片，优先数增加1。  进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 （5）分析程序运行的结果，谈一下自己的认识。
进程调度模拟程序
weixin_30896825的博客
05-14 2796
1. 目的和要求 1.1. 实验目的 用高级语言完成一个进程调度程序，以加深对进程的概念及进程调度算法的理解。 1.2. 实验要求 1.2.1例题：设计一个有 N个进程并发执行的进程调度模拟程序。 进程调度算法：采用最高优先级优先的调度算法（即把处理机分配给优先级最高的进程）和先来先服务（若优先级相同）算法。 (1). 每个进程有一个进程...
操作系统进程调度模拟算法
05-09
实验内容： 进程调度模拟程序：假设有10个进程需要在CPU上执行，分别用：  先进先出调度算法；  基于优先数的调度算法；  最短执行时间调度算法 确定这10个进程在CPU上的执行过程。要求每次进程调度时在屏幕上显示：  当前执行进程；  就绪队列；  等待队列 实验目的： 1）掌握处理机调度及其实现； 2）掌握进程状态及其状态转换； 3）掌握进程控制块PCB及其作用。 实验要求： 1） 创建10个进程的PCB，每个PCB包括：进程名、进程状态、优先级（1~10）、需要在处理机上执行的时间（ms）、队列指针等； 2） 初始化10个PCB（产生随机数0或1，分别表示进程处于就绪态或等待态）； 3） 根据调度算法选择一个就绪进程在CPU上执行； 4） 在进程执行过程中，产生随机数0或1，该随机数为1时，将等待队列中的第一个PCB加入就绪队列的对尾； 5） 在进程执行过程中，产生一个随机数，表示执行进程能在处理机上执行的时间，如果随机时间大于总需要的时间，则执行完成。如果小于，则从总时间中减去执行时间。 6） 如果执行进程没有执行完成。则产生随机数0或1，当该随机数为0时，将执行进程加入就绪队列对尾；否则，将执行进程加入等待队列对尾； 7） 一直到就绪队列为空，程序执行结束。
计算机操作系统进程调度模拟实现的算法
01-08
这个软件时采用c++实现，在通过cygwin实现的计算机操作系统进程调度模拟实现的算法
编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度 “简单轮转法调度算法”
05-31
1.编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对五个进程进行调度。 2、用“简单轮转法调度算法”实现第一题
操作系统课程设计大作业C++进程调度算法的模拟实现源码.zip
06-17
操作系统课程设计大作业C++进程调度算法的模拟实现源码，实现了 动态优先级、先来先服务、时间片轮转 三个算法 安装教程 下载到本地，然后直接用VS打开运行即可 操作系统课程设计大作业C++进程调度算法的模拟实现...
操作系统实验一报告【使用C语言/C++实现时间片轮转调度算法】
02-27
### 操作系统实验一报告——使用C语言/C++实现时间片轮转调度算法 #### 实验背景与目的 本实验旨在通过编程实践的方式，加深学生对于操作系统中的进程调度机制及其核心算法之一——时间片轮转（Round Robin, RR）...
操作系统进程调度C++代码实现
05-25
轮转算法调度进程的模拟过程 。 内容 1.在第 1 3 部分基础上扩展； 2.支持 FCFS 、短 作业优先以及时间片调度算法。 3.能够较方便地查看调度过程及平均周转时间、平均带权周转时 间。 4.支持优先权调度算法与其它...
模拟的进程调度程序，采用“最高优先数优先”调度算法
12-12
编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对进程进行调度。（做了简单的界面）
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码.zip
06-17
课程设计大作业C++模拟操作系统进程调度FCFS和SJF算法实现源码 问题描述 设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T1, … ,Tn时刻到达系统，它们需要的服务时间分别为S1, … ,...
基于C++实现的操作系统进程调度可视化与模拟源码+实验报告.zip
08-21
基于C++实现的操作系统进程调度可视化与模拟源码+实验报告.zip 1、该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、...
操作系统处理器调度算法及其特点
鹿鸣晚
10-10 2840
在操作系统中存在多种调度算法，其中有的调度算法适用于作业调度，有的调度算法适用于进程调度，有的调度算法两者都适用。下面介绍几种常用的调度算法。 1、先来先服务调度算法（FCFS） 定义：FCFS调度算法是一种最简单的算法，该算法既可用于作业调度也可用于进程调度，其基本思想是按照进程进入就绪队列的先后次序来分配 处理器。 FCFS调度算法属于不可剥夺算法。从表面上看，它对所有作业都是公平的，但若一个长作业先到达系统，就会使后面许多短作业等待很长时间，因此它不能作为分时系统和实时系统的主要调度策略。...
单处理机进程调度c语言,[操作系统]实现单处理机下的进程调度程序
weixin_30676351的博客
05-23 2004
problem实验内容：编写一个单处理机下的进程调度程序，模拟操作系统对进程的调度。要求：能够创建指定数量的进程，每个进程由一个进程控制块表示。实现先来先服务调度算法：进程到达时间可由进程创建时间表示。实现短作业优先调度算法：可指定进程要求的运行时间。(说明：对不可剥夺的短作业优先算法，当作业运行时间相等时，优先调度进程号小的进程执行；对可剥夺式的短作业优先算法，即选最短剩余时间的进程进行运行，在...
操作系统进程调度算法 C++
qq_31605553的博客
12-01 2044
操作系统 进程调度
【计算机操作系统】进程调度算法的 C++ 实现（附源码）
Coder Yang
06-11 6434
文章目录一、实验目的二、实验内容2.1 优先权法和轮转法2.2 算法描述三、流程图3.1 优先权法3.2 轮转法四、实验要求五、设计思想5.1 总体思想5.2 数据结构5.3 关键代码解析六、代码实现七、源码地址 一、实验目的   多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。 二、实验内容 2.1 优先权法和轮转法 简化假设 1）进程为计算型的（无I/O） 2）进程状态
C语言典型例题56
最新发布
2302_77517102的博客
08-30 957
将范围为100~200的不能被3整除的数输出。
C/C++实现进程调度：优先级与轮转算法模拟
本课程设计旨在通过编程模拟两种基本的进程调度算法：优先级算法和时间片轮转算法，以帮助学生深入理解进程调度的概念和过程。以下是这些算法的详细说明： 1. **优先级算法**： - **进程控制块PCB（Process ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值