前言
开始把存的东西往csdn上丢..一、 题目要求
设RQ(就绪队列)分为RQ1和RQ2,RQ1采用轮转法,时间q=7.RQ1>RQ2,RQ2采用短进程优先调度算法。测试数据如下:RQ1: P1-P5, RQ2: P6-P10
进程 P1 P2 P3 P4 P5 P6 P7 P8 P9 P10
运行时间 16 11 14 13 15 21 18 10 7 14
已等待时间6 5 4 3 2 1 2 3 4 5
(RQ1,RQ2最好从文件中读)
输出进程的周转时间。
二、 程序功能及设计思路
需求分析:
1、 RQ1中的五个进程使用轮转法进行调度。
2、 RQ2中的五个进程使用短进程优先调度算法进行调度。
3、 RQ1,RQ2的读取来自文件。
4、 输出进程的周转时间
所以设计的程序功能必须含有轮转法和短进程优先调度算法。
设计思路:因为RQ具有进程名,运行时间,已等待时间等信息,所以采取vector来存储RQ。
而轮转法需要对已等待时间进行比较,选择等待队列中等待时间最长的进行轮转,所以从文件中读取RQ1后,将RQ1根据等待时间进行降序排列。然后开始进行轮转法,记录如果需等待时间大于时间片,进程一个周期减少一个时间片,如果小于则直接消耗完需等待时间,并将该进程从就绪队列中剔除。为了输出进程的周转时间,需采取客观的系统时间记录每个进程的开始时间和结束时间,两者相减得到的结果便是进程的周转时间。
短进程优先调度算法相比就比较简单,排序后直接根据从小到大的运行时间调度,且进程的周转时间就等于进程的已等待时间。
三、数据结构及算法设计
(1)设计:数据结构
因为进程具有进程名,所需时间,已等待时间,周转时间,运行次数,第一次开始运行时间等性质,所以采用了结构体(struct PCB)来构造。同时为了利用其信息进行排序等操作,选择了PCB类型的vector的容器。
struct PCB {
string name;//进程名
int needtime;//所需时间
int waittime;//已等待时间
int turn;//周转时间
int count=0; //运行次数
int endtime=0; //结束时间
int first_starttime=0;//第一次开始运行时间(用来计算周转时间)
int starttime=0; //开始运行时间
};
vectorRQ1;
vectorRQ2;
(2)算法设计
读取就绪队列
void createRQ() {
ifstream infile("RQ1.txt");
string s1; int need, wait,turntime;
if (infile) {
while (!infile.eof()) {
infile >> s1 >> need >> wait>>turntime;
PCB rq1;
rq1.name = s1;
rq1.needtime = need;
rq1.waittime = wait;
rq1.turn = turntime;
RQ1.push_back(rq1);
}
}
}
轮转法
void round_robin() {
createRQ();
int tag = 5;
for (int i = 1; i <= RQ1.size() - 1; i++) {
for (int j = 1; j < RQ1.size() - i; j++) {
if (RQ1[j - 1].waittime < RQ1[j].waittime) { //等待时间较长的应先进入轮转
PCB a;
a.turn = RQ1[j - 1].turn;
a.needtime = RQ1[j - 1].needtime;
a.name = RQ1[j - 1].name;
a.waittime = RQ1[j - 1].waittime;//用a暂存前者
RQ1[j - 1].turn = RQ1[j].turn;
RQ1[j - 1].needtime = RQ1[j].needtime;
RQ1[j - 1].name = RQ1[j].name;
RQ1[j - 1].waittime = RQ1[j].waittime;//用后者覆盖前者
RQ1[j].turn = a.turn;
RQ1[j].needtime = a.needtime;
RQ1[j].name = a.name;
RQ1[j].waittime = a.waittime;//完成交换
}
}//RQ1.size()=6
}
RQ1.erase(RQ1.begin() + 5);
int q = 7;//时间片
int over = 0;
int size = RQ1.size();
while (over!=size)
{
int num = 0;
vector<PCB>::iterator p = RQ1.begin();
p->starttime = clock;
if (p->needtime > q)//
{
clock =clock+ q;
p->needtime =p->needtime- q;
;
(p->count)++;
if (p->count == 1)
{
p->first_starttime = p->starttime;//记录第一次开始运行的时间
}
PCB temp;
temp = *RQ1.begin();
RQ1.erase(RQ1.begin());
p = RQ1.begin();
RQ1.push_back(temp);//插入到尾部
}
if(p->needtime<=7)
{
clock =clock+ p->needtime;
p->endtime = clock;//记录结束时间
(p->count)++;
cout << "进程"<<p->name<<"的周转时间 : " << p->endtime - p->first_starttime << endl;
p->needtime = 0;
PCB temp;
temp = *RQ1.begin();
RQ1.erase(RQ1.begin());
p = RQ1.begin();
over++;
}
}
cout << endl;
}
短进程优先调度算法
for (size_t i = 1; i <=RQ2.size() - 1; i++) {
for (size_t j = 1; j < RQ2.size() - i; j++) {
if (RQ2[j - 1].needtime > RQ2[j].needtime) { //前者比后者大
PCB a;
a.needtime = RQ2[j - 1].needtime;
a.name = RQ2[j - 1].name;
a.waittime =RQ2[j - 1].waittime;//用a暂存前者
RQ2[j - 1].needtime = RQ2[j].needtime;
RQ2[j - 1].name = RQ2[j].name;
RQ2[j - 1].waittime = RQ2[j].waittime;//用后者覆盖前者
RQ2[j].needtime = a.needtime;
RQ2[j].name = a.name;
RQ2[j].waittime = a.waittime;//完成交换
}
}
}//冒泡排序
for (int i = 0; i < RQ2.size()-1; i++) {
cout << "进程" << RQ2[i].name << "的周转时间为" << RQ2[i].needtime << endl;
}