OS第二次实验---进程调度算法的实现

一、实验目的

  在采用多道程序设计的系统中，往往有多个进程同时处于就绪状态。当就绪进程个数大于处理器个数时，就必须按照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度，加深了解处理器调度的工作。

二、实验原理与内容

1. 实验原理

（1） 先来先服务
按照作业到达时间确定。进程的优先级按作业的到达时间以此排队，使得到达时间早的作业具有较高的优先级。
（2） 静态优先级算法
按照用户给出的优先级进行依次排队，使用户规定的优先级高的作业，具有较高的优先级。
（3） 静态时间片轮转法
将处理的进程按照时间顺序进行排队，规定一段执行时间该时间称为时间片。当该进程用完这一时间片时，系统将它送至就绪队列队尾，又把处理机分配给下一进程，再执行同样大小的时间片。这样，就绪队列中的所有进程，就可以依次轮流获得一个时间片的处理时间，然后系统又回到队列的开始部分。如此不断循环。

2.实验内容

  设计一个程序,根据不同的调度算法模拟操作系统对进程的调度。
  先来先到算法；静态优先级算法；静态时间片轮转算法

二、实验过程

  实验代码如下：

#include 
#include 
#include 
#include 
#include 
 
using namespace std;

struct text
{
	int num;				//进程数
	char text[100];				//进程名称
	double arr[100];				//到达时间
	double pri[100];				//优先级
	double revser[100];				//服务时间
	double str[100];				//开始时间
	double finsh[100];			//结束时间
	double turn[100];			//周转时间
	double weight_turn[100]	;			//带权周转时间
	double last[100];		//剩余时间 
	double ser_last[100]; 
}TEX;

void input()		//输入
{	
	int i;
	printf("输入进程数量\n");
	scanf("%d",&TEX.num);
	printf("输入进程名称，到达时间，服务时间，优先级\n");
	for(i = 0; i < TEX.num ; i++ )
	{
		cin>>TEX.text[i];
		cin>>TEX.arr[i];
		cin>>TEX.revser[i];		
		cin>>TEX.pri[i];
	}
	
}

void output(int i)
{
	cout<<"进程名称\t到达时间\t服务时间\t优先级\t开始时间\t结束时间\t周转时间\t带权周转时间\n";
	cout<<TEX.text[i]<<"\t\t"<<TEX.arr[i]<<"\t\t"<<TEX.revser[i]<<"\t\t"<<TEX.pri[i]<<"\t"<<TEX.str[i]<<"\t\t"<<TEX.finsh[i]<<"\t\t"<<TEX.turn[i]<<"\t\t"<<TEX.weight_turn[i]<<"\n";	
}

void output1(int i)
{
	cout<<"进程名称\t到达时间\t已服务时间\t剩余时间\n";
	cout<<TEX.text[i]<<"\t\t"<<TEX.arr[i]<<"\t\t"<<TEX.ser_last[i]<<"\t\t"<<TEX.last[i]<<"\n";	
}

void output2(int i)
{
	cout<<"正在运行的程序:  ";
	cout<<TEX.text[i]<<"\n";	
}

void FCFS()		//先来先到
{
	int i,j;
	double start;
	double end; 
	double point;
	input();
	start = 0;
	end = 0;
	for(i = 0 ; i < 100 ; i++)
	{
		for(j = 0 ; j < TEX.num ; j++)
		{
			if(TEX.arr[j] == i)
			{
				if(end <= TEX.arr[j])      //下个进程到达预计 
				{
					start = TEX.arr[j];
					end = start + TEX.revser[j];
				}
				else
				{
					start = end;
					end = TEX.revser[j] + start;
				}
				TEX.str[j] = start;
				TEX.finsh[j] = end;
				TEX.turn[j] = 	TEX.finsh[j] - TEX.arr[j];
				TEX.weight_turn[j] = TEX.turn[j]/TEX.revser[j];
				output(j);
			}
		}
	}
}												

void CIS()		//固定优先级
{
	int i,j;
	double start;
	double end; 
	double point;
	input();
	start = 0;
	end = 0;
	for(i = 0 ; i < 100 ; i++)
	{
		for(j = 0 ; j < TEX.num ; j++)
		{
			if(TEX.pri[j] == i)
			{
				if(end <= TEX.arr[j])		  //下个进程到达预计 
				{
					start = TEX.arr[j];
					end = start + TEX.revser[j];
				}
				else
				{
					start = end;
					end = TEX.revser[j] + start;
				}
				TEX.str[j] = start;
				TEX.finsh[j] = end;
				TEX.turn[j] = 	TEX.finsh[j] - TEX.arr[j];
				TEX.weight_turn[j] = TEX.turn[j]/TEX.revser[j];
				output(j);
			}
		}
	}
} 

void FCFSS()		//时间片
{
	int time=3;
	int i,j,k,m,n,o;
	double start;
	double end; 
	int point;
	double a_arr[100];
	input();
	start = 0;
	end = 0;
	k = 0;
	for(i = 0 ; i < 100 ; i++)		//进程排序 
	{
		for(j = 0 ; j < TEX.num ; j++)
		{
			if(TEX.arr[j] == i)
			{
				a_arr[k] = j;
				k++;
			}
		}
	}
	k=0;o=0;n=TEX.num;point=a_arr[0];start=TEX.arr[point];end=start;m=point;			//数据初始化 
	
	for(i=0;i<TEX.num;i++)
	{
		TEX.last[i]=TEX.revser[i];
	 }
	 
	  
	for(i = 0 ; i < 500 ; i++)
	{
		output2(m);
		if(i<TEX.num)		//接受进程 
		{
			TEX.str[m]=start;
			TEX.last[m]=TEX.revser[m];
		}
		
		if(TEX.last[m]<=3)			//进程判断 
		{
			TEX.finsh[m]=start+TEX.last[m];
			TEX.ser_last[m]=TEX.ser_last[m]+TEX.last[m];
			TEX.last[m]=0;
			for(j=0;j<n-o;j++)
			{
					a_arr[o+j]=a_arr[o+j+1]; 

			}
			output1(m);
			n--;
			o--;
		}
		
				start=start+3;		//时间加3 
				
		if(TEX.last[m]>3)
		{
			TEX.ser_last[m]=TEX.ser_last[m]+3;
			TEX.last[m]=TEX.last[m]-3;
			TEX.finsh[m]=TEX.str[m]+3;
		}
		
		for(k=0;k<n;k++)		//打印 
		{
			point=a_arr[k];
			output1(point);
		}
		cout<<n;
		cout<<"\n"<<"\n";
		o++;
		if(o==n)
		{
			o=0; 
		}
		m=a_arr[o];
		if(n==0)
		{
			break; 
		}
	}
	for(i=0;i<TEX.num;i++)		//打印 
	{
		output(i);
	}
	
}

int main()
{
	int a;
	cout<<"请选择服务："<<endl<<"1.先来先服务算法"<<endl<<"2.静态优先级服务算法"<<endl<<"3.静态时间片轮转"<<endl<<"4.退出"<<endl;
	while(a<4)
	{
		cout<<"please input serve:";
		cin>>a;
		switch(a)
		{
		 	case(1):FCFS();break;
		 	case(2):CIS();break;
		 	case(3):FCFSS();break;
			default:break;		 		
		}
	} 

  *程序运行结果如下：
（1）先来先服务算法

（2）静态优先级算法

（3）时间片轮转法

四、实验总结

  本次实验了解了多道进程的处理过程，进一步感受了CPU的运行，有利于我们更好的了解操作系统。

五、实验体会及改进建议

  加强对算法及数据结构的了解，在实验过程中对于数据结构的不熟悉，导致我在实验过程中出现了很多问题。