先来先服务FCFS和短作业优先SJF进程调度算法

最新推荐文章于 2024-10-10 15:28:42 发布

流年若逝

最新推荐文章于 2024-10-10 15:28:42 发布

阅读量3.2k

点赞数 5

分类专栏：操作系统

本文链接：https://blog.csdn.net/wyf2017/article/details/79893551

版权

操作系统专栏收录该内容

9 篇文章 1 订阅

订阅专栏

【实验题目】：先来先服务FCFS和短作业优先SJF进程调度算法

【实验目的】

通过这次实验，加深对进程概念的理解，进一步掌握进程状态的转变、进程调度的策略及对系统性能的评价方法。

【实验内容】

问题描述：

设计程序模拟进程的先来先服务FCFS和短作业优先SJF调度过程。假设有n个进程分别在T₁, … ,T_n时刻到达系统，它们需要的服务时间分别为S₁, … ,S_n。分别采用先来先服务FCFS和短作业优先SJF进程调度算法进行调度，计算每个进程的完成时间，周转时间和带权周转时间，并且统计n个进程的平均周转时间和平均带权周转时间。

程序要求如下：

1）进程个数n；每个进程的到达时间T₁, … ,T_n和服务时间S₁, … ,S_n；选择算法1-FCFS，2-SJF。

2）要求采用先来先服务FCFS和短作业优先SJF分别调度进程运行，计算每个进程的周转时间，带权周转时间，并且计算所有进程的平均周转时间，带权平均周转时间；

3）输出：要求模拟整个调度过程，输出每个时刻的进程运行状态，如“时刻3：进程B开始运行”等等；

4）输出：要求输出计算出来的每个进程的周转时间，带权周转时间，所有进程的平均周转时间，带权平均周转时间。

实现提示：

用C++语言实现提示：

1）程序中进程调度时间变量描述如下：

staticint MaxNum=100;

int ArrivalTime[MaxNum];

int ServiceTime[MaxNum];

int FinishTime[MaxNum];

int WholeTime[MaxNum];

double WeightWholeTime[MaxNum];

double AverageWT_FCFS,AverageWT_SJF;

double AverageWWT_FCFS,AverageWWT_SJF;

2）进程调度的实现过程如下：

Ø 变量初始化；

Ø 接收用户输入n，T₁, … ,T_n，S₁,… ,S_n；算法选择1-FCFS，2-SJF；

Ø 按照选择算法进行进程调度，计算进程的完成时间、周转时间和带权周转时间；

Ø 计算所有进程的平均周转时间和平均带权周转时间；

Ø 按格式输出调度结果。

实验要求：

1)上机前认真复习FCFS和SJF进程调度调度算法，熟悉进程调度的执行过程；

2)上机时独立编程、调试程序；

3)根据具体实验要求，完成好实验报告（包括实验的目的、内容、要求、源程序、实例运行结果截图）。

【源程序】

头文件FCFS.h

#include<iostream>
#define MaxNum 100

struct Process_struct{
	int  Number;                 //进程编号
	char Name[MaxNum];           //进程名称
    int  ArrivalTime;    //到达时间
	int  ServiceTime;    //开始运行时间
	int  FinishTime;     //运行结束时间
	int  WholeTime;      //运行时间
    int run_flag;        //调度标志
	int order;           //运行次序
	double  WeightWholeTime;        //周转时间
	double AverageWT_FCFS,AverageWT_SJF;    //平均周转时间
    double AverageWWT_FCFS,AverageWWT_SJF;  //平均带权周转时间
}Process[MaxNum];

int N;    //实际进程个数
int FCFS();   //先来先服务

int FCFS(){      //先来先服务算法
	int i;
	int temp_time=0;    //当前时间
	temp_time=Process[0].ArrivalTime;
	for(i=0;i<N;i++)               
	{
		Process[i].ServiceTime=temp_time;
		Process[i].FinishTime=Process[i].ServiceTime+Process[i].WholeTime;
		Process[i].run_flag=1;``
        temp_time=Process[i].FinishTime;
		 Process[i].order=i+1;
	}return 0;
}

头文件SJF.h

#include<iostream>

int SJF();    //短作业优先

int SJF(){       //短作业优先算法
	int temp_time=0;    //当期那时间
	int i=0,j;
	int number_schedul,temp_counter;      //进程编号，当前已执行进程个数
	float run_time;
	run_time=Process[i].WholeTime;
	j=1;
	while((j<N)&&(Process[i].ArrivalTime==Process[j].ArrivalTime))    //判断是否有两个进程同时到达
	{
		if(Process[j].WholeTime<Process[i].WholeTime)
		{
			run_time=Process[i].WholeTime;
			i=j;
		}
		j++;
	}
	//查找下一个被调度的进程
		//对找到的下一个被调度的进程求相应的参数
	number_schedul=i;
	Process[number_schedul].ServiceTime=Process[number_schedul].ArrivalTime;
	Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime+Process[number_schedul].WholeTime;
	Process[number_schedul].run_flag=1;
	temp_time=Process[number_schedul].FinishTime;
    Process[number_schedul].order=1;
	temp_counter=1;
	while(temp_counter<N)
	{
		for(j=0;j<N;j++)
		{
			if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag))
			{
				run_time=Process[j].WholeTime;
				number_schedul=j;
				break;
			}
		}
		for(j=0;j<N;j++)
		{
			if((Process[j].ArrivalTime<=temp_time)&&(!Process[j].run_flag))
				if(Process[j].WholeTime<run_time)
				{
					run_time=Process[j].WholeTime;
					number_schedul=j;
				}
		}
		//查找下一个被调度的进程
		//对找到的下一个被调度的进程求相应的参数
		Process[number_schedul].ServiceTime=temp_time;
		Process[number_schedul].FinishTime=Process[number_schedul].ServiceTime+Process[number_schedul].WholeTime;
		Process[number_schedul].run_flag=1;
		temp_time=Process[number_schedul].FinishTime;
		temp_counter++;
		Process[number_schedul].order=temp_counter;
	}return 0;
}

主程序Main.cpp

#include<iostream>
#include "FCFS.h"
#include "SJF.h"
using namespace std;

int Pinput();  //进程参数输入
int Poutput();   //调度结果输出

void main()
{
	int option;
	Pinput();
	printf("请选择算法:\n");
	printf("1.先来先服务\n");
	printf("2.短作业优先\n");
	printf("0.退出\n");
	scanf("%d",&option);
	switch(option)
	{
	case 0:
		printf("运行结束。\n");
		break;
	case 1:
		printf("对进程用先来先服务调度。\n\n");
		FCFS();
		Poutput();
		break;
	case 2:
		printf("对进程用短作业优先调度。\n\n");
	    SJF();
		Poutput();
		break;
	}
}

int Pinput()   //进程参数输入
{
	int i;
	printf("please input the process number:\n");
	scanf("%d",&N);
	for(i=0;i<N;i++)
	{
		printf("***************************************\n");
		printf("please input the process of %d th:\n",i+1);
		printf("please input the name:\n");
		scanf("%s",Process[i].Name);
        printf("please input the ArrvialTime:\n");
		scanf("%d",&Process[i].ArrivalTime);
		printf("please input the WholeTime:\n");
		scanf("%d",&Process[i].WholeTime);
		Process[i].ServiceTime=0;
		Process[i].FinishTime=0;
		Process[i].WeightWholeTime=0;
		Process[i].order=0;
		Process[i].run_flag=0;
	}return 0;
}

int Poutput()   //调度结果输出
{
	int i;
	float turn_round_time=0,f1,w=0;
	printf("进程名称 到达时间 运行时间 开始运行时间 结束时间 执行顺序 周转时间 带权周转时间\n");
	for(i=0;i<N;i++)
	{
		Process[i].WeightWholeTime=Process[i].FinishTime-Process[i].ArrivalTime;
		f1=Process[i].WeightWholeTime/Process[i].WholeTime;
		turn_round_time+=Process[i].WeightWholeTime;
		w+=f1;
		printf("时刻%d:进程%s开始运行。",Process[i].ServiceTime,Process[i].Name);
		printf(" %s  , %d , %d , %d , %d , %d , %f , %f \n",Process[i].Name,Process[i].ArrivalTime,Process[i].WholeTime,Process[i].ServiceTime,Process[i].FinishTime,Process[i].order,Process[i].WeightWholeTime,f1);
	}
	printf("average_turn_round_timer=%f\n",turn_round_time/N);
	printf("weight_average_turn_round_timer=%f\n",w/N);
	return 0;
}

【实例运行结果截图】

进程名 A B C D E

到达时间 0 1 2 3 4