操作系统 实验五 进程的调度

实验目的：

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

实验内容：

①实现FCFS算法：根据进程的到达时间的先后次序来完成对若干进程的调度。

②实现SJF算法：根据当前时间已经到达进程的需要运行时间选取其中时间最小的进程最先运行。

③实现时间片轮转算法：首先要求确定时间片的大小，依据进程的到达时间依次加入队列，每次分配一个时间片大小的时间，如果没有完成参与下一次的竞争，当最后需要一个小于等于时间片的时间时本进程完成，同时退出队列。

④计算每种算法调度后，系统的平均周转时间和平均带权周转时间。

算法实现：

void FCFS()
{
		int				i;
		float			sumT = 0.0;
		float			sumW = 0.0;
		float			last ;
		process[0].start = process[0].arrive;
		process[0].finish = process[0].start + process[0].service;
		
		last = process[0].finish;

		i = 1;
		while(i != N)
		{
				if(process[i].arrive > last)
						last = process[i].arrive;
				process[i].start = last;
				process[i].finish = last + process[i].service;
				last += process[i].service;
				i++;
		}
		
		for(i = 0 ; i < N; i++)
		{
				process[i].T = process[i].finish - process[i].arrive;
				process[i].W = process[i].T / (float)process[i].service;
				sumT += process[i].T;
				sumW += process[i].W;
		}
		FCFS_T = sumT / N;
		FCFS_W = sumW / N;
}


int getmin(float t)
{
		int				i;
		int				addr = -1;
		float			min=10000.0;

		for(i = 0 ; i < N ; i++)
		{
				if(process[i].state == 0 && process[i].service < min 
						&& process[i].arrive <= t)
				{
						addr = i;
						min = process[i].service;
				}
		}

		process[addr].finish = t + process[addr].service;

		return addr;
}
void SJF()
{
		int				i;
		float			sumT = 0.0;
		float			sumW = 0.0;

		process[0].finish = process[0].arrive + process[0].service;
		process[0].state  = 1;
		
		int				addr = 0;
		int				sign = 0; 
		float			last = process[0].finish;

		while(sign != N-1)
		{
				addr = getmin(last);
				if(addr == -1)
				{
						last = process[getmin(1000)].arrive;
						continue;
				}
				process[addr].start = last;
				process[addr].state = 1;
				last = process[addr].finish;
				sign++;
		}

		for(i = 0 ; i < N; i++)
		{
				process[i].T = process[i].finish - process[i].arrive;
				process[i].W = process[i].T / (float)process[i].service;
				sumT += process[i].T;
				sumW += process[i].W;
		}

		SJF_T = sumT / N;
		SJF_W = sumW / N;
}

void RR()
{
		int				i = 0;
		int				j;
		int				t = process[0].arrive;
		float			sumT = 0.0;
		float			sumW = 0.0;
		for(j = 0 ; j < N ; j++)
		{
				process[j].state = 0;
				process[j].start = -1;
				process[j].left = process[j].service;
		}
		process[0].start = t;
		while(1)
		{
				for(j = 0 ; j < N ; j++)
						if(process[(i+j)% N].state == 0 && t >= process[(i+j)% N].arrive)
								break;
				i = (i+j)% N;

				if( process[i].state == 1)
				{
						break;
				}

				if(process[i].start == -1)
						process[i].start = t;

				for(j = 0 ; j < min(process[i].left,q) ; j++)
						cout < q)
				{	
						t += q;
						process[i].left -= q;
				}
				else
				{
						t += process[i].left;
						process[i].left = 0;
						process[i].finish = t;
						process[i].state = 1;
				}
				i = (++i) %N;
		}

		for(i = 0 ; i < N ; i++)
		{
				process[i].T = process[i].finish - process[i].arrive;
				process[i].W = process[i].T / (float)process[i].service;
				sumT += process[i].T;
				sumW += process[i].W;
		}

		RR_T = sumT / N;
		RR_W = sumW / N; 
}