作业调度实验
本次实验一共用到了两个封装的类。
一个是作业的类，Job，其中的属性包括每个作业的编号、名字、提交时间、运行时间、开始时间、结束时间、等待时间、周转时间和表示是否已经执行过的布尔变量。
int num;//编号
string name;//名字
string submitTime;//提交时间
int runTime;//运行时间
string beginTime;//开始时间
string endTime;//结束时间
int waitTime;//等待时间
int responseTime;//周转时间
bool exed;//是否已经执行过
由于在实现的过程中，需要多次对Job作业进行排序操作，而考虑到使用STL::math库的sort()函数可以在O(logn)的时间复杂度实现排序，希望能够这样实现。所以，需要给Job定义比较函数。
由于进行比较的方式不同，实验中主要用到了三个用于作业比较的函数。
-
operator<() 重载“<”运算符的比较函数
用来将作业按照运行时间排序（如果运行时间相等默认返回true）。
friend bool operator<(const Job& x, const Job& y) {
if (x.runTime == y.runTime)
return true;
return x.runTime > y.runTime;
}
-
cmp_submitTime()
按照提交时间排序，如果提交时间相同，则按照运行时间排序。
bool cmp_submitTime(Job& x, Job& y) {
if (x.submitTime == y.submitTime)
return x.runTime < y.runTime;//如果提交时间相同则按照运行时间排序
return x.submitTime < y.submitTime;
}
-
cmp_turnaroundTime()
按照响应时间倒序排序（如果运行时间相等默认返回false）。倒序是为了能够在调用时，配合STL::vector库的push_back和pop_back操作进行元素的插入和删除。
bool cmp_responseTime(Job& x, Job& y) {//按照响应时间排序的倒序
if (x.responseTime == y.responseTime)
return false;
return x.responseTime > y.responseTime;
}
第二个类，作业调度的函数封装类，jobScheduling类。
其中包括了一些作业数组jobs，还包括作业数、平均周转时间。
Job jobs[MAXJOBNUM];//作业数组
int jobSize;//作业数
int avg_responseTime;//平均周转时间
考虑对于样例输入（如下所示），对时间点的表示形如“小时:分钟”，对时间长度的表示是分钟数，需要进行不同类型的时间描述的转换。
1 JA 02:40 20
2 JB 02:50 30
3 JC 02:55 10
4 JD 03:00 24
5 JE 03:05 6
定义addTime()函数，对string类型的时间点加上一段int类型的分钟数。
string jobScheduling::addTime(string now, int time) {
int hour = (now[0] - '0') * 10 + now[1] - '0';
int minute = (now[3] - '0') * 10 + now[4] - '0';
minute += time;
while (minute >= 60) {
hour += 1;
minute -= 60;
}
string res = "";
res = res + char((hour / 10) + '0') + char(hour % 10 + '0');
res = res + ':';
res = res + char((minute / 10) + '0') + char(minute % 10 + '0');
return res;
}
除此之外，还有输入和输出函数，和三种不同的作业调度算法的实现函数。，在input函数中，会进行变量的初始化操作，并且构建jobs数组进行作业的存储。在output函数中，进行平均周转时间的计算。
下面介绍三种作业调度算法的实现函数。
- FCFSschedule()
FCFS是一种先进先服务的作业调度算法。
我们使用nowTime变量存储当前时间，用sumWaitTime变量存储当前累计运行时间。依据运行时间大小，将jobs数组进行排序。每一次执行更靠前的能够运行的作业。
void jobScheduling::FCFSschedule() {
sort(jobs, jobs + jobSize, cmp_submitTime);//将作业按照提交时间排序
string nowTime = jobs[0].submitTime;//当前时间
int sumWaitTime = 0;//累计运行时间
Job sortedJobs[MAXJOBNUM];//作业调度顺序
int pos = 0;
for (int i = 0; i < jobSize; i++) {
Job nowJob = jobs[i];
nowJob.beginTime = nowTime;
nowJob.endTime = addTime(nowTime, nowJob.runTime);
nowJob.waitTime = sumWaitTime;
nowJob.responseTime = nowJob.runTime + sumWaitTime;
sortedJobs[pos++] = nowJob;
nowTime = addTime(nowTime, nowJob.runTime);
sumWaitTime += nowJob.runTime;
}
for (int i = 0; i < jobSize; i++)
jobs[i] = sortedJobs[i];
}
- SJFschedule()
SJF是一种根据作业所需的运行时间进行调度的作业调度算法。
我们使用nowTime变量存储当前时间，用sumWaitTime变量存储当前累计运行时间。同时，使用cnt表示当前已经执行的作业的个数。作业调度的结束条件是当前全部作业都已经完成。
对于每一个当前时间，将在其之前的所有作业放入就绪队列，使用STL::priority_queue的优先队列存储。如果就绪队列中有作业可以进行，就进行队首作业（运行时间最短的作业），如果没有，则运行当前没有运行的作业中第一个到达的作业，即排序过的jobs中第一个没有执行过的作业。
void jobScheduling::SJFschedule() {
for (int i = 0; i < jobSize; i++)
jobs[i].exed = false;
sort(jobs, jobs + jobSize, cmp_submitTime);//将作业按照提交时间排序
priority_queue<Job> que;//优先队列
Job sortedJobs[MAXJOBNUM];//作业调度顺序
int cnt = 0;//计数
int pos = 0;
string nowTime = jobs[0].submitTime;
jobs[0].exed = true;
int sumWaitTime = 0;
que.push(jobs[0]);
while (cnt < jobSize) {//停止条件是全部作业已经完成
for (int i = 0; i < jobSize; i++) {
if (!jobs[i].exed) {//将当前时间之前的所有作业放入就绪队列
if (jobs[i].submitTime <= nowTime) {
jobs[i].exed = true;
que.push(jobs[i]);
}
else
break;//作业已经排序，如果当前作业的提交时间在当前时间之后，其之后作业的提交时间也一定在当前时间之后
}
}
Job nowJob;
if (que.empty()) {//并未执行完所有的作业，但当前时间没有已经提交的作业
for (int i = 0; i < jobSize; i++)
if (!jobs[i].exed) {
jobs[i].exed = true;
nowJob = jobs[i];
break;
}
}
else {
nowJob = que.top();
que.pop();
}
nowJob.beginTime = nowTime;
nowJob.endTime = addTime(nowTime, nowJob.runTime);
nowJob.waitTime = sumWaitTime;
nowJob.responseTime = sumWaitTime + nowJob.runTime;
sortedJobs[pos++] = nowJob;
nowTime = addTime(nowTime, nowJob.runTime);
sumWaitTime += nowJob.runTime;
cnt++;
}
for (int i = 0; i < jobSize; i++)
jobs[i] = sortedJobs[i];
}
- PSAschedule()
PSA是一种基于优先级（紧迫程度）进行调度的作业调度算法。
我们使用nowTime变量存储当前时间，用sumWaitTime变量存储当前累计运行时间。同时，使用cnt表示当前已经执行的作业的个数。作业调度的结束条件是当前全部作业都已经完成。
在每一个作业执行之后，都需要更新响应时间。并且对于STL::vector模拟实现的就绪队列进行重新排序，并且将可以执行的作业放入就绪队列中。如果就绪队列中有作业可以进行，就进行队首作业（运行时间最短的作业），如果没有，则运行当前没有运行的作业中第一个到达的作业，即排序过的jobs中第一个没有执行过的作业。
void jobScheduling::PSAschedule() {
for (int i = 0; i < jobSize; i++)
jobs[i].exed = false;
sort(jobs, jobs + jobSize, cmp_submitTime);
vector<Job> vec;//模拟队列
Job sortedJobs[MAXJOBNUM];
int cnt = 0;
int pos = 0;
string nowTime = jobs[0].submitTime;
int sumWaitTime = 0;
while (cnt < jobSize) {
for (int i = 0; i < jobSize; i++) {//更新响应时间
jobs[i].waitTime = sumWaitTime;
jobs[i].responseTime = sumWaitTime + jobs[i].runTime;
if (!jobs[i].exed && jobs[i].submitTime <= nowTime) {
vec.push_back(jobs[i]);
jobs[i].exed = true;
}
}
sort(vec.begin(), vec.end(), cmp_responseTime);//倒序
Job nowJob;
if (vec.empty()) {
for (int i = 0; i < jobSize; i++)//并未执行完所有的作业，但当前时间没有已经提交的作业
if (!jobs[i].exed) {
nowJob = jobs[i];
break;
}
}
else {
nowJob = vec.back();
vec.pop_back();
}
nowJob.beginTime = nowTime;
nowJob.endTime = addTime(nowTime, nowJob.runTime);
nowJob.waitTime = sumWaitTime;
nowJob.responseTime = sumWaitTime + nowJob.runTime;
sortedJobs[pos++] = nowJob;
nowTime = addTime(nowTime, nowJob.runTime);
sumWaitTime += nowJob.runTime;
cnt++;
}
for (int i = 0; i < jobSize; i++)
jobs[i] = sortedJobs[i];
}
在这里，分别使用priority_queue和vector实现SJF和PSA算法中的就绪队列。两种方法的实现的功能类似，只是priority_queue的比较函数需要重载运算符，而两种算法需要对作业进行的比较是不同作业属性的比较，所以不能两次使用priority_queue。要注意，vector在自己实现增删元素时只能对最后的元素进行操作，所以需要倒序存储。
完整的程序代码如下：
#pragma warning (disable:4996)
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#include <queue>
#define inf 0X3f3f3f3f
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int MAXJOBNUM = 50;
/*
作业信息：
1 JA 02:40 20
2 JB 02:50 30
3 JC 02:55 10
4 JD 03:00 24
5 JE 03:05 6
*/
class Job {
public:
int num;//编号
string name;//名字
string submitTime;//提交时间
int runTime;//运行时间
string beginTime;//开始时间
string endTime;//结束时间
int waitTime;//等待时间
int responseTime;//周转时间
bool exed;//是否已经执行过
friend bool operator<(const Job& x, const Job& y) {
if (x.runTime == y.runTime)
return true;
return x.runTime > y.runTime;
}
};
bool cmp_submitTime(Job& x, Job& y) {
if (x.submitTime == y.submitTime)
return x.runTime < y.runTime;//如果提交时间相同则按照运行时间排序
return x.submitTime < y.submitTime;
}
bool cmp_responseTime(Job& x, Job& y) {//按照响应时间排序的倒序
if (x.responseTime == y.responseTime)
return false;
return x.responseTime > y.responseTime;
}
class jobScheduling {
private:
Job jobs[MAXJOBNUM];//作业数组
int jobSize;//作业数
int avg_responseTime;//平均周转时间
public:
void input();
void output();
string addTime(string, int);
void FCFSschedule();
void SJFschedule();
void PSAschedule();
};
void jobScheduling::input() {
cout << "请输入作业信息（Ctrl+Z 表示输入结束）\n";
cout << "作业编号 | 作业名称 | 提交时间 | 要求服务运行时间\n";
jobSize = 0;
avg_responseTime = 0;
Job tmp;
while (cin >> tmp.num >> tmp.name >> tmp.submitTime >> tmp.runTime) {
jobs[jobSize++] = tmp;
}
}
void jobScheduling::output() {
avg_responseTime = 0;
cout << "【作业调度信息】\n";
cout << "作业编号 | 作业名称 | 提交时间 | 要求服务运行时间 | 开始时间 | 完成时间 | 等待时间 | 周转时间\n";
for (int i = 0; i < jobSize; i++) {
cout.setf(ios::left);
avg_responseTime += jobs[i].responseTime;
cout << " " << setw(10) << jobs[i].num << setw(8) << jobs[i].name << setw(15) << jobs[i].submitTime << setw(15) << jobs[i].runTime;
cout << setw(12) << jobs[i].beginTime << setw(12) << jobs[i].endTime << setw(12) << jobs[i].waitTime << jobs[i].responseTime << endl;
}
cout << "平均周转时间：" << avg_responseTime / jobSize << endl;
}
string jobScheduling::addTime(string now, int time) {
int hour = (now[0] - '0') * 10 + now[1] - '0';
int minute = (now[3] - '0') * 10 + now[4] - '0';
minute += time;
while (minute >= 60) {
hour += 1;
minute -= 60;
}
string res = "";
res = res + char((hour / 10) + '0') + char(hour % 10 + '0');
res = res + ':';
res = res + char((minute / 10) + '0') + char(minute % 10 + '0');
return res;
}
void jobScheduling::FCFSschedule() {
sort(jobs, jobs + jobSize, cmp_submitTime);//将作业按照提交时间排序
string nowTime = jobs[0].submitTime;//当前时间
int sumWaitTime = 0;//累计运行时间
Job sortedJobs[MAXJOBNUM];//作业调度顺序
int pos = 0;
for (int i = 0; i < jobSize; i++) {
Job nowJob = jobs[i];
nowJob.beginTime = nowTime;
nowJob.endTime = addTime(nowTime, nowJob.runTime);
nowJob.waitTime = sumWaitTime;
nowJob.responseTime = nowJob.runTime + sumWaitTime;
sortedJobs[pos++] = nowJob;
nowTime = addTime(nowTime, nowJob.runTime);
sumWaitTime += nowJob.runTime;
}
for (int i = 0; i < jobSize; i++)
jobs[i] = sortedJobs[i];
}
void jobScheduling::SJFschedule() {
for (int i = 0; i < jobSize; i++)
jobs[i].exed = false;
sort(jobs, jobs + jobSize, cmp_submitTime);//将作业按照提交时间排序
priority_queue<Job> que;//优先队列
Job sortedJobs[MAXJOBNUM];//作业调度顺序
int cnt = 0;//计数
int pos = 0;
string nowTime = jobs[0].submitTime;
jobs[0].exed = true;
int sumWaitTime = 0;
que.push(jobs[0]);
while (cnt < jobSize) {//停止条件是全部作业已经完成
for (int i = 0; i < jobSize; i++) {
if (!jobs[i].exed) {//将当前时间之前的所有作业放入就绪队列
if (jobs[i].submitTime <= nowTime) {
jobs[i].exed = true;
que.push(jobs[i]);
}
else
break;//作业已经排序，如果当前作业的提交时间在当前时间之后，其之后作业的提交时间也一定在当前时间之后
}
}
Job nowJob;
if (que.empty()) {//并未执行完所有的作业，但当前时间没有已经提交的作业
for (int i = 0; i < jobSize; i++)
if (!jobs[i].exed) {
jobs[i].exed = true;
nowJob = jobs[i];
break;
}
}
else {
nowJob = que.top();
que.pop();
}
nowJob.beginTime = nowTime;
nowJob.endTime = addTime(nowTime, nowJob.runTime);
nowJob.waitTime = sumWaitTime;
nowJob.responseTime = sumWaitTime + nowJob.runTime;
sortedJobs[pos++] = nowJob;
nowTime = addTime(nowTime, nowJob.runTime);
sumWaitTime += nowJob.runTime;
cnt++;
}
for (int i = 0; i < jobSize; i++)
jobs[i] = sortedJobs[i];
}
void jobScheduling::PSAschedule() {
for (int i = 0; i < jobSize; i++)
jobs[i].exed = false;
sort(jobs, jobs + jobSize, cmp_submitTime);
vector<Job> vec;//模拟队列
Job sortedJobs[MAXJOBNUM];
int cnt = 0;
int pos = 0;
string nowTime = jobs[0].submitTime;
int sumWaitTime = 0;
while (cnt < jobSize) {
for (int i = 0; i < jobSize; i++) {//更新响应时间
jobs[i].waitTime = sumWaitTime;
jobs[i].responseTime = sumWaitTime + jobs[i].runTime;
if (!jobs[i].exed && jobs[i].submitTime <= nowTime) {
vec.push_back(jobs[i]);
jobs[i].exed = true;
}
}
sort(vec.begin(), vec.end(), cmp_responseTime);//倒序
Job nowJob;
if (vec.empty()) {
for (int i = 0; i < jobSize; i++)//并未执行完所有的作业，但当前时间没有已经提交的作业
if (!jobs[i].exed) {
nowJob = jobs[i];
break;
}
}
else {
nowJob = vec.back();
vec.pop_back();
}
nowJob.beginTime = nowTime;
nowJob.endTime = addTime(nowTime, nowJob.runTime);
nowJob.waitTime = sumWaitTime;
nowJob.responseTime = sumWaitTime + nowJob.runTime;
sortedJobs[pos++] = nowJob;
nowTime = addTime(nowTime, nowJob.runTime);
sumWaitTime += nowJob.runTime;
cnt++;
}
for (int i = 0; i < jobSize; i++)
jobs[i] = sortedJobs[i];
}
int main() {
jobScheduling jobschedule;
jobschedule.input();
printf("FSFC：\n");
jobschedule.FCFSschedule();
jobschedule.output();
printf("SJF：\n");
jobschedule.SJFschedule();
jobschedule.output();
printf("PSA：\n");
jobschedule.PSAschedule();
jobschedule.output();
return 0;
}
831
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
