C++模拟作业调度算法(先来先服务算法、短作业优先和响应比高者优先算法)

事先说明:

本代码为原创,转载请附原博地址。

代码可以运行,但是运算结果并不知道对错(感觉第三个有问题),凌晨两点写的,大脑并不清醒,欢迎交流修改。

如果我的老师查重的时候看到这篇,请你看一下交作业时间和博客时间来确定这是我本人写的~

理论部分:

简单地说一下吧,毕竟书上应该都有。

先来先服务算法,就非常简单地按照作业到达先后进行计算。

短作业优先算法,是在作业到达的基础上,如果有多个作业都已经到达,选择运行时间短的作业先计算。

响应比高者优先算法,也是在作业到达的基础上,如果有多个作业都已经到达,计算他们的优先级,优先级高的作业先计算。

优先级=1+(等待时间 / 要求服务时间)

代码:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
using namespace std;
struct zy//每个作业
{
	int gettime;//到达时间
	int runtime;//运行时间
	int k;//标记有没有被用过(用于第二个算法)
	int y;//优先级(第三个算法)
};
bool cmp(zy a, zy b)//按照到达时间进行排序
{
	return a.gettime < b.gettime;
}
bool cmp2(zy a, zy b)//按照运行时间进行排序
{
	return a.runtime < b.runtime;
}
bool cmp3(zy a, zy b)//按照优先级排序
{
	return a.y > b.y;
}
int main()
{
	/*输入数据*/
	int n;
	cout << "请输入有几组:";
	cin >> n;
	zy z[100];
	cout << "输入每个作业的到达时间和运行时间" << endl;
	for (int i = 0; i < n; i++)
	{
		cin >> z[i].gettime >> z[i].runtime;
		z[i].k = 0;
	}

	int overtime[100];//结束时间
	int starttime[100];//开始时间
	int zhouzhuan[100];//周转时间
	double dq[100];//带权周转时间

	/*先来先服务算法*/
	sort(z, z + n, cmp);
	for (int i = 0; i < n; i++)
	{
		if(i==0)starttime[i] = z[i].gettime;
		else starttime[i] = z[i].gettime + overtime[i - 1];
		overtime[i] = starttime[i] + z[i].runtime;
		zhouzhuan[i] = overtime[i] - z[i].gettime;
		dq[i] = zhouzhuan[i]*1.0 / z[i].runtime;
	}
	double T=0, W=0;
	for (int i = 0; i < n; i++)
	{
		T = T + zhouzhuan[i];
		W = W + dq[i];
	}
	T = T / n*1.0;
	W = W / n*1.0;
	cout << "先来先服务算法的平均时间是: " << T << " 带权平均周转时间是:" << W << endl;

	/*短作业优先算法*/
	memset(overtime, 0, sizeof(overtime));
	memset(starttime, 0, sizeof(starttime));
	memset(zhouzhuan, 0, sizeof(zhouzhuan));
	memset(dq, 0, sizeof(dq));
	T = 0, W = 0;
	sort(z, z + n, cmp);
	for (int i = 0; i < n; i++)
	{
		if (i == 0) {
			starttime[i] = z[i].gettime;
			overtime[i] = starttime[i] + z[i].runtime;
			zhouzhuan[i] = overtime[i] - z[i].gettime;
			dq[i] = zhouzhuan[i]*1.0 / z[i].runtime;
			z[i].k = 1;
		}
		else {
			for (int j = 0; j < n; j++)//找最短时间的作业
			{
				if (z[j].k == 0 && z[j].gettime <= overtime[i - 1]) {//如果没有使用过且在结束时间内
					starttime[i] = z[j].gettime;
					overtime[i] = starttime[i] + z[j].runtime;
					zhouzhuan[i] = overtime[i] - z[i].gettime;
					dq[i] = zhouzhuan[i]*1.0 / z[j].runtime;
					z[j].k = 1;
					break;
				}
			}
		}
		sort(z, z + n, cmp2);
	}
	for (int i = 0; i < n; i++)
	{
		T = T + zhouzhuan[i];
		W = W + dq[i];
	}
	T = T / n*1.0;
	W = W / n*1.0;
	cout << "短作业优先算法的平均时间是: " << T << " 带权平均周转时间是:" << W << endl;

	/*高响应比优先算法*/
	memset(overtime, 0, sizeof(overtime));
	memset(starttime, 0, sizeof(starttime));
	memset(zhouzhuan, 0, sizeof(zhouzhuan));
	memset(dq, 0, sizeof(dq));
	T = 0, W = 0;
	sort(z, z + n, cmp);
	for (int i = 0; i < n; i++)
	{
		if (i == 0) {
			starttime[i] = z[i].gettime;
			overtime[i] = starttime[i] + z[i].runtime;
			zhouzhuan[i] = overtime[i] - z[i].gettime;
			dq[i] = zhouzhuan[i] * 1.0 / z[i].runtime;
		}
		else {
			int g;//标记最后一个在上一个结束时间内的作业
			for (int j = i; j < n; j++)
			{
				if (z[j].gettime <= overtime[i])g = j;
				else break;
			}
			if (g - i == 1) {//只有一个作业可执行
				starttime[i] = z[i].gettime + overtime[i - 1];
				overtime[i] = starttime[i] + z[i].runtime;
				zhouzhuan[i] = overtime[i] - z[i].gettime;
				dq[i] = zhouzhuan[i] * 1.0 / z[i].runtime;
			}
			else {//需要计算优先级
				for (int j = i; j <= g; j++)
				{
					z[j].y = 1 + (overtime[i - 1] - z[j].gettime) / z[j].runtime;
				}
				sort(z+i, z + g, cmp3);
				starttime[i] = z[i].gettime + overtime[i - 1];
				overtime[i] = starttime[i] + z[i].runtime;
				zhouzhuan[i] = overtime[i] - z[i].gettime;
				dq[i] = zhouzhuan[i] * 1.0 / z[i].runtime;
			}
		}
	}
	for (int i = 0; i < n; i++)
	{
		T = T + zhouzhuan[i];
		W = W + dq[i];
	}
	T = T / n*1.0;
	W = W / n*1.0;
	cout << "高响应比优先算法的平均时间是: " << T << " 带权平均周转时间是:" << W << endl;
	system("pause");
	return 0;
}

运行结果:

相关推荐
1. 实验目的 调度的实质是操作系统按照某种预定的策略来分配资源。进程调度的目的是分配CPU资源。由于进程调度程序执行的频率很高,因此调度算法的好坏直接影响到操作系统的性能。本实验的目的是编程模拟实现几种常用的进程调度算法,通过对几组进程分别使用不同的调度算法,计算进程的平均周转时间和平均带权周转时间,比较各种算法的性能优劣。 2. 实验原理 [1]. 进程调度算法描述 进程调度算法包括服务调度算法、最作业时间优先(抢占式和非抢占式)、最高响应调度算法4种。(每个人必须做FCFS,然后在后面的三种中任选一种,即每个人必须做2种调度算法模拟。) [2]. 衡量算法性能的参数 计算进程的平均周转时间和平均带权周转时间。 3. 实验内容 (1)编程实现本实验的程序,要求: [1]. 建立进程的进程控制块,进程控制块至少包括: a) 进程名称; b) 进程需要执行时间; c) 进入就绪队列时间; d) 进程执行开始时间 e) 进程执行结束时间 [2]. 编程实现调度算法。 [3]. 进程及相关信息的输入。这些信息可以直接从键盘上输入,也可以从文件读取。 [4]. 时间片与时间流逝的模拟。本实验需要对算法的执行计时,程序应该提供计算时间的方法。一种最简单的方法是使用键盘,比如每敲一次空格代表一个时间片的流逝。另一种方法是使用系统时钟。 [5]. 一组进程序列执行完毕,打印出结果信息。程序需要计算出每个进程的开始执行时间、结束时间、周转时间和带权周转时间,并为整个进程序列计算平均周转时间和平均带权周转时间。程序将计算结果按一定的格式显示在计算机屏幕上或输出到文件中。打印出进程调度顺序图。 [6]. 实现数据在磁盘文件上的存取功能。 (2)对下列就绪进程序列分别使用上面的几种算法进行调度,计算每种算法下的平均周转时间和平均带权周转时间。 进程号 到达时间 要求执行时间 0 0 1 1 1 35 2 2 10 3 3 5 4 6 9 5 7 21 6 9 35 7 11 23 8 12 42 9 13 1 10 14 7 11 20 5 12 23 3 13 24 22 14 25 31
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页