操作系统-进程调度实验报告

这篇具有很好参考价值的文章主要介绍了操作系统-进程调度实验报告。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1．实现四种不同及进程调度算法：

先来先服务、时间片轮转调、优先级调度以及短作业优先调度算法。

2．通过实验理解有关进程控制块，进程队列等的概念。

1.运行素材中的代码，观察其执行结果是否正确？各个调度算法的功能是否完善？如果没有，则完善。

2. 按照下表输入3个作业信息，输出使用不同调度算法的结果。

3. 在现有三个调度算法的基础上，进一步实现短作业优先调度

ProcessID	arrivetime	servicetime	priority:
1	1	9	2
2	4	6	3
3	6	3	1

参数表格2

ProcessID	arrivetime	servicetime	priority:
1	1	2	2
2	7	2	4
3	5	7	1
4	9	1	3

说明：

主程序中从键盘得到进程的数量，创建PCB，调用layout（）函数显示选择界面。
Layout（）函数中选择相应的算法并调用相关函数如：FCFS()，最后打印。

一设计有N个进程并发的调度算法

进程调度算法：每个进程有一个进程控制块（PCD）表示。进程控制块下包含：进程ID，优先级，到达时间，需要运行时间等。

二在linux系统上输入程序，调试，编译

三设计输入数据，选择不同的进程调度算法，打印执行结果

四根据实验要求，填写实验报告

-----贴几张调用算法图，加自己写的一些简单分析

选择FSFS算法结果

操作系统-进程调度实验报告

结果分析：调用先来先服务算法，1号进程先来于是先执行1号，处理机开始时间是1，加上1号服务时间于是结束为10；2号进程来的时间为4，比3号早，于是先执行2号，执行完后时间为16,；最后执行3号，执行完时间为19.

2-调用timesegment算法结果

操作系统-进程调度实验报告

2-结果分析：调用时间片轮转算法，本例中设置时间片长度为3,1号进程先来，时间为1时候开始，先执行3，然后2来，再执行3，然后3已结到了，再执行3，此时为10,3号进程执行完毕。之后1号和2号轮流执行一个时间片的时间，最后2号执行完为16,1号执行完为19.

3-调用priority算法结果

操作系统-进程调度实验报告

3-实验结果分析：调用优先级非抢占式进程算法，1号进程先来，于是先执行1号，从1开始，执行9, 1号结束后为10，之后2号进程的优先级比3号高，执行完2号后为16；之后执行3号，结果为19.

4-调用SJF算法结果

操作系统-进程调度实验报告文章来源地址https://www.toymoban.com/news/detail-462992.html

4-结果分析：调用非抢占式短作业优先算法，一号进程先来，执行完后为10；然后比较2号和3号，3号的运行时间短，先执行3号，执行完为13,；最后执行完2号，执行完为19.

参考代码：

#include<stdio.h>
#include<malloc.h>
#include <stdbool.h>
#include<stdlib.h>
#define max 50

struct PCB
{
	int name;
	int arrivetime; //到达时间
	int servicetime; //服务时间
	//int starttime[max]; //开始时间
    int finishtime; //完成/结束时间
    int turntime; //周转时间
    int average_turntime; //带权周转时间
	int sign; //标志进程是否完成
	int remain_time; //剩余时间
	int priority;  //优先级
}pcb[max];

void init(int n)  //初始化
{ int i;
	for(i=0;i<n;i++)
	{
		pcb[i].arrivetime=0; 
		pcb[i].servicetime=0; 
	    //pcb[i].starttime=0; 
	    pcb[i].finishtime=0; 
	    pcb[i].turntime=0;
	    pcb[i].average_turntime=0;
		pcb[i].remain_time=0;
		pcb[i].sign=0;
		pcb[i].priority=0;
	}
}
void creat(int n) //创建PCB
{
	int i;
	for(i=1;i<=n;i++)
	{
		printf("\n%d:\n input the information of process\n input processID:",i);
		scanf("%d",&pcb[i].name);
		printf("input the arrivetime:");
		scanf("%d",&pcb[i].arrivetime);
		printf("input the servicetime:");
		scanf("%d",&pcb[i].servicetime);
		printf("input the priority:");
		scanf("%d",&pcb[i].priority);
		pcb[i].remain_time=pcb[i].servicetime;  //初始化剩余时间为服务时间
	}
}

void FCFS(int n) //先来先服务
{
	int starttime;
	printf("input the start time：\n");
	scanf("%d",&starttime);
	if(starttime>=pcb[1].arrivetime)
	{
		pcb[1].finishtime=pcb[1].servicetime+starttime;
	}
	else
	{
		pcb[1].finishtime=pcb[1].arrivetime+ pcb[1].servicetime;
	}
         int i;
         pcb[1].turntime=pcb[1].finishtime-pcb[1].arrivetime;
	pcb[1].average_turntime=pcb[1].turntime/pcb[1].servicetime;
	for(i=1;i<n;i++)
	{
		if(pcb[i].finishtime>pcb[i+1].arrivetime)
		pcb[i+1].finishtime=pcb[i].finishtime+pcb[i+1].servicetime;
		else
			pcb[i+1].finishtime=pcb[i+1].arrivetime+pcb[i+1].servicetime;
		pcb[i+1].turntime=pcb[i+1].finishtime-pcb[i+1].arrivetime;
		pcb[i+1].average_turntime=pcb[i+1].turntime/pcb[i+1].servicetime;
	}
}

void print_FCFS(int n)
{
		//printf("ProcessID, arrivetime\t Servicetime\t finishtime\t turntime\t:,,%s\t%d\t%d\t%d\t%d\t%d\t"); //进程名,到达时间,服务时间,完成时间,周转时间,周转时间
	printf("process ID  arrivetime servicetime finishtime turntime , averageturntime  .\n");
         int i;
	for(i=1;i<=n;i++)
	{
		printf("%d  ,%d  ,%d  ,%d  ,%d  ,%d  ",pcb[i].name  ,pcb[i].arrivetime  ,pcb[i].servicetime  ,pcb[i].finishtime  ,pcb[i].turntime  ,pcb[i].average_turntime);
		printf("\n");
	}

}
void time_segment(int n) //时间片轮转
{
	int i,j;
	int T;   //时间片
	int flag=1;   //就绪队列中是否还有进程,0为没进程，1为有进程
	//int time=pcb[0].arrivetime;   //当前的时间
	int time=0;
	int sum=0;   //已经完成的进程数

	//按各进程的arrivetime进行升序排列
	for(i=1;i<=n;i++)
	for(j=i+1;j<=n;j++)  
	{
		if(pcb[j].arrivetime<pcb[i].arrivetime)
		{
			pcb[0]=pcb[j];
			pcb[j]=pcb[i];
			pcb[i]=pcb[0];	
		}
	}
	// 新加上的
	time=pcb[1].arrivetime;
	    //printf("output the sort result:\n");
		//for(i=1;i<=n;i++)    //检查排序是否正确
     	//printf("%d\t",pcb[i].name);
	printf("input the slicetime:\n");
	scanf("%d",&T);
	//printf("\n running processID runtime resttime finishtime\n”) //  开始运行时间   运行时间   剩余服务时间   结束时间

	while(sum<n) 
	{
		flag=0;   //当前就绪队列中没有进程
		int i;
                for(i=1;i<=n;i++)
		{
          //标志进程是否完成
			if(pcb[i].sign==1) continue; //表示该进程已完成
			else
			{


	           //没有完成的进程需要的时间大于一个时间片
				if(pcb[i].remain_time > T)
				{
					flag=1;
				if(time<pcb[i].arrivetime)
				time=pcb[i].arrivetime;
				else{
				time=time+T;
				}	
					
                 // remain是剩余时间
					pcb[i].remain_time=pcb[i].remain_time-T;
          
					//printf("%10d%16d%12d%12d%12d\n",pcb[i].name,time-T,T,pcb[i].remain_time,time);
				}

				//没有完成的进程需要的时间小于或等于一个时间片
				else if(pcb[i].remain_time <= T)
				{
					flag=1;  //加入就绪队列
					if(time<pcb[i].arrivetime)
				time=pcb[i].arrivetime;
					time=time+pcb[i].remain_time;
					pcb[i].finishtime=time;
                    pcb[i].sign=1;
					//printf("%10d%16d%12d%12d%12d\n",pcb[i].name,time-pcb[i].remain_time,pcb[i].servicetime,0,time); 
		 	        pcb[i].remain_time=0;
				}
				
				if(pcb[i].sign==1) sum++;
			}

		}//for


	if(flag==0&&sum<n)   // 还有没执行的进程，且没进入就就绪队列 
	{
        int i;
	for(i=1;i<=n;i++)
	if(pcb[i].sign==0) {time=pcb[i].arrivetime;break;}
	}


	}//while

}
void print_time(int n)
{       int i;
	for(i=0;i<n;i++)
	{
	printf("\n processID servicetime finishtime\n");  //进程名   服务时间   完成时间
	printf("%6d%10d%10d",pcb[i+1].name,pcb[i+1].servicetime,pcb[i+1].finishtime);
	printf("\n");
	}
}

void Priority(int n)
{
	int i,j;
	int time = pcb[1].arrivetime;
	//按各进程的arrivetime进行升序排列,最早到达的进程先执行
	for(i=1;i<=n;i++)
	for(j=i+1;j<=n;j++)  
	{
		if(pcb[j].arrivetime < pcb[i].arrivetime)
		{
			pcb[0]=pcb[j];
			pcb[j]=pcb[i];
			pcb[i]=pcb[0];	
		}
	}
	
	    //printf("output the sort result: \n"); //输出排序结果
	    //for(i=1;i<=n;i++)    //检查排序是否正确
     	//printf("%d\t",pcb[i].name);

	printf("\n processID runtime priority fihishtime \n");//进程名   服务时间   优先级  完成时间
	//先到达的进程第一个执行
	if(i=1)
	{
		pcb[i].finishtime=pcb[i].arrivetime + pcb[i].servicetime;
		time =pcb[i].arrivetime + pcb[i].servicetime;
		printf("%6d%10d%10d%10d",pcb[i].name,pcb[i].servicetime,pcb[i].priority,pcb[i].finishtime);
		printf("\n");
		//测试第一个进程输出正确
	/*	printf("output the first process:\n");//输出第一个程序的
		printf("processID arrivetime finishtime\n");//名称  到达时间  完成时间
		printf("%4d%8d%8d",pcb[i].name,pcb[i].arrivetime,pcb[i].finishtime);
		printf("\n"); */
		i++; 
	}
	
	

/*
	//按各进程的priority进行降序排列,优先级最高的进程先执行
	for(i=2;i<=n;i++)
	for(j=i+1;j<=n;j++)  
	{
		if(pcb[j].priority > pcb[i].priority)
		{
			pcb[0]=pcb[j];
			pcb[j]=pcb[i];
			pcb[i]=pcb[0];	
		}
	}
	
	for(i=2;i<=n;i++)
	{
		time = time + pcb[i].servicetime;
		pcb[i].finishtime = time;
		printf("%6d%10d%10d%10d",pcb[i].name,pcb[i].servicetime,pcb[i].priority,pcb[i].finishtime);
		printf("\n");
	}//for
	
*/

int num=2;
	for(i=2;i<=n;i++)
	{
//按各进程的priority进行降序排列,优先级最高的进程先执行

	for(i=num;i<=n;i++)
	for(j=i+1;j<=n;j++)  
	{
		if(pcb[j].priority > pcb[i].priority)
		{
			pcb[0]=pcb[j];
			pcb[j]=pcb[i];
			pcb[i]=pcb[0];	
		}
	}
//在优先级调整后判断此时最先到达的进程号
for(i=num;i<=n;i++)
	for(j=i+1;j<=n;j++)  
	{
		if(pcb[j].arrivetime< pcb[i].arrivetime)
		{
			pcb[0]=pcb[j];
			pcb[j]=pcb[i];
			pcb[i]=pcb[0];	
		}
	}




i=num;
  if(time<pcb[i].arrivetime)
{
  time=pcb[i].arrivetime;
pcb[i].finishtime = time+pcb[i].servicetime;
}
else
{
time = time + pcb[i].servicetime;
pcb[i].finishtime = time;
}
printf("%6d%10d%10d%10d",pcb[i].name,pcb[i].servicetime,pcb[i].priority,pcb[i].finishtime);
printf("\n");
time=pcb[i].finishtime;

num++;
	}//for

}//void

void SJF(int n)
{
int i,j;
	int time = pcb[1].arrivetime;
	//按各进程的arrivetime进行升序排列,最早到达的进程先执行
	for(i=1;i<=n;i++)
	for(j=i+1;j<=n;j++)  
	{
		if(pcb[j].arrivetime < pcb[i].arrivetime)
		{
			pcb[0]=pcb[j];
			pcb[j]=pcb[i];
			pcb[i]=pcb[0];	
		}
	}
	
	    

	printf("\n processID runtime priority fihishtime \n");//进程名   服务时间   优先级  完成时间
	//先到达的进程第一个执行
	if(i=1)
	{
		pcb[i].finishtime=pcb[i].arrivetime + pcb[i].servicetime;
		time =pcb[i].arrivetime + pcb[i].servicetime;
		printf("%6d%10d%10d%10d",pcb[i].name,pcb[i].servicetime,pcb[i].priority,pcb[i].finishtime);
		printf("\n");
		
	
		i++; 
	}
	
	



int num=2;
	for(i=2;i<=n;i++)
	{
//按各进程的servicetime进行降序排列

	for(i=num;i<=n;i++)
	for(j=i+1;j<=n;j++)  
	{
		if(pcb[j].servicetime < pcb[i].servicetime)
		{
			pcb[0]=pcb[j];
			pcb[j]=pcb[i];
			pcb[i]=pcb[0];	
		}
	}
	if(pcb[num-1].finishtime<pcb[num].arrivetime)
	{
//在优先级调整后判断此时最先到达的进程号
for(i=num;i<=n;i++)
	for(j=i+1;j<=n;j++)  
	{
		if(pcb[j].arrivetime< pcb[i].arrivetime)
		{
			pcb[0]=pcb[j];
			pcb[j]=pcb[i];
			pcb[i]=pcb[0];	
		}
	}
	}




i=num;
  if(time<pcb[i].arrivetime)
{
  time=pcb[i].arrivetime;
pcb[i].finishtime = time+pcb[i].servicetime;
}
else
{
time = time + pcb[i].servicetime;
pcb[i].finishtime = time;
}
printf("%6d%10d%10d%10d",pcb[i].name,pcb[i].servicetime,pcb[i].priority,pcb[i].finishtime);
printf("\n");
time=pcb[i].finishtime;

num++;
	}//for


}

void layout(int n) 
{

while(true)
{
	int ch=0;
	printf("\t\t************schedule algorithm************\n");
	printf("\t\t1.FSFS\n");
	printf("\t\t2.timesegment\n");
	printf("\t\t3.priority\n");
	printf("\t\t4.SJF\n");
	printf("\t\t5表示退出\n");
	printf(" choose the algorithm:\n");
	scanf("%10d",&ch);
	switch(ch)
	{
	case 1:
		    FCFS(n);
		    print_FCFS(n); break;
	case 2:
		    time_segment(n);
		    print_time(n); break;
	case 3:
		    Priority(n); break;
        case 4:
		    SJF(n); break;
	case 5:     exit(0);	    
	default:printf("enter error data!\n");
	//P:int类型的变量,case后面不要加''
	}
}
}

int main()
{ 
	int n;
	printf("input the number of process\n");
	scanf("%d",&n);
	init(n);
	creat(n);
	layout(n);
	//FCFS(n);
	//print_FCFS(n);
	//time_segment(n);
	//print_time(n);
	//Priority(n);
	return 0;
}

到了这里，关于操作系统-进程调度实验报告的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！