多级队列调度算法

1.题目

多级队列调度算法
设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
实现描述：

 typedef  struct  tag_pcb
    {
char name[8];
          int need;//须运行的时间
          int turn;//周转时间(周转时间=完成时间-到达时间)
          struct  tag_pcb  *next;
     }PCB(进程控制块);
PCB  * RQ1,*RQ2，*Finish;
int clock=0;  //时钟
main()
{
输入RQ1；
          输入RQ2；（最好从文件读入）
          while（ＲＱ１！＝ＮＵＬＬ）
       ｛
从RQ1中选取一进程Pi准备运行；
               计算其运行的时间t;
               clock+=t;  //表示Pi运行t;
               if (Pi完成）  计算其turn;
               否则   Pi加入到队尾；
          }
          while（ＲＱ2!＝ＮＵＬＬ）
          {
从RQ2中选取一进程Pi准备运行；
               clock+=Pi.need;
               计算Pi的turn;
          }
          输出进程的周转时间；
}

2.程序设计

• 首先在头文件里面包含list.h，使得程序可以使用链表的各个操作函数。然后就是设立一个进程信息结构体，其中包括进程名字、须运行时间、开始运行时间等进程信息，接着就是利用list RQ1和list RQ2声明两个就绪队列RQ1和RQ2，并设置系统时间和轮转法的时间片。接着就是RQ1和RQ2的初始化，由于两者基本一样，所以只介绍RQ1的：首先初始化已知的进程信息，然后利用for循环以及RQ1.push_back(project1)依次将所有属于该队列的进程信息输入至链表，并cout部分进程信息。
• 然后就是轮转法的定义：首先调用函数CreateRQ1()创建队列，初始化时钟之后当RQ1不空时，PCB* p=&RQ1.front();//指向第一个元素，先输出进程部分信息，当进程执行时间大于时间片时，调整系统时间、程序还需时间、程序已执行时间以及执行次数，而执行次数主要目的是用来设立进程最初开始执行时间(p->count)++;if (p->count == 1){p->first_starttime = p->starttime;}，然后再输出执行次数以及已执行时间，由于该进程还未执行完成，所以利用RQ1.push_back(RQ1.front());RQ1.pop_front()首先将其插入至队列尾部，然后再删除头结点；若进程所需时间小与等于时间片，则进行各个进程信息的更新之后直接利用RQ1.pop_front();//删除头结点，至此，轮转法算法结束。
• 接下来就是短进程优先算法：同样的先创建队列，当！RQ2.empty()时，std::
  list::iterator q=RQ2.begin();//迭代器iterator提供一种访问对象容器中的元素，返回第一个元素的迭代器，然后利用循环for (std::list::iterator p = RQ2.begin();p != RQ2.end();++p) 找到最短预计执行时间的进程，找到之后再对进程的部分信息更新，然后由于该进程已执行完，所以直接利用RQ2.erase(q)从队列删除结点q，短进程优先算法结束。
• 程序最后在main函数里面直接依次调用RR();//轮转法、SPPSM();//短进程优先调度法即可，整个程序结束。

3.测试结果

4.源码

/*操作系统实验一  多级队列调度算法　 
设RQ(就绪队列)分为Q1 > RQ2，RQ2采用短进程优先调度算法。
测试数据如下：RQRQ1和RQ2，RQ1采用轮转法，时间q = 7.
R1: 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 */

#include
#include//包含双向链表的各个操作函数
using namespace std;

struct PCB//进程信息
{
	int name;           //进程名字
	int needtime;       //须运行时间
	int starttime;      //开始运行时间
	int endtime;        //结束时间
	int first_starttime;//第一次开始运行时间(用来计算周转时间)
	int runtime;        //已经运行时间
	int waittime;       //已等待时间
	int count;          //运行次数
};

list<PCB> RQ1;
list<PCB> RQ2;
int clock;       //系统时间
int capacity = 7;//时间片

void CreateRQ1()//创建队列RQ1(以队列为结构创建)
{
	int name1[5] = { 1,2,3,4,5 };
	int needtime1[5] = { 16,11,14,13,15 };
	int waittime1[5] = { 6,5,4,3,2 };

	for (int i = 0;i < 5;i++)
	{
		PCB project1;
		project1.name = name1[i];
		project1.waittime = waittime1[i];
		project1.needtime = needtime1[i];
		project1.runtime = 0;
		project1.count = 0;
		project1.endtime = 0;
		project1.first_starttime = 0;
		project1.starttime = 0;
		RQ1.push_back(project1);//放进链表
		cout << "创建进程 : p"<<project1.name<<"\t"<<"执行所需时间 : "<<project1.needtime<<endl;
	}
}

void CreateRQ2()//创建队列RQ2(以链表为结构创建)
{
	int name2[5] = { 6,7,8,9,10 };
	int needtime2[5] = { 21,18,10,7,14 };
	int waittime2[5] = { 1,2,3,4,5 };

	for (int i = 0;i < 5;i++)
	{
		PCB project2;
		project2.name = name2[i];
		project2.waittime = waittime2[i];
		project2.needtime = needtime2[i];
		project2.runtime = 0;
		project2.count = 0;
		project2.endtime = 0;
		project2.first_starttime = 0;
		project2.starttime = 0;
		RQ2.push_back(project2);
		cout << "创建进程 : p" << project2.name << "\t" << "执行所需时间 : " << project2.needtime << endl;
	}
}

void RR()//轮转法(round-robin)
{
	cout << "***********轮转法***********"<<endl;
	CreateRQ1();
	clock = 0;
	while (!RQ1.empty())
	{
		PCB* p = &RQ1.front();//指向第一个元素
		p->starttime = clock;
		cout << "进程 : p" << p->name << "\t" << "执行还需时间 : "
			<< p->needtime << "\t" << "开始执行时间 : " << p->starttime <<"\t";
		if (p->needtime > capacity)
		{
			clock += capacity;
			p->needtime -= capacity;
			p->runtime += capacity;
			(p->count)++;
			if (p->count == 1)
			{
				p->first_starttime = p->starttime;
			}
			cout << "执行次数 ：" << p->count << "\t" << "已执行时间 : " << p->runtime << endl;
			RQ1.push_back(RQ1.front());//首先插入头结点到尾部
			RQ1.pop_front();           //然后把头结点删除
		}
		else
		{
			p->runtime += p->needtime;
			clock += p->needtime;
			p->endtime = clock;
			(p->count)++;
			cout << "执行次数 : " << p->count << "\t" << "已执行时间 : " << p->runtime
				<< "\t" << "结束时间 : " << p->endtime <<"\t"<< "周转时间 : " 
				<< p->endtime - p->first_starttime <<"\t"<< "执行完毕" <<endl;
			p->needtime = 0;
			RQ1.pop_front();//删除头结点
		}
	}
	cout << endl;
}

void SPPSM()//短进程优先调度法(short process priority scheduling method)
{
	cout << "*******短进程优先调度法*******"<<endl;
	CreateRQ2();
	clock = 0;
	while (!RQ2.empty())
	{
		std::list<PCB>::iterator q = RQ2.begin();
		//迭代器iterator提供一种访问对象容器中的元素，返回第一个元素的迭代器
		for (std::list<PCB>::iterator p = RQ2.begin();p != RQ2.end();++p)
		{    //找到最短预计执行时间的进程
			if (p->needtime < q->needtime)
			{
				q = p;
			}
		}
		q->starttime = clock;
		q->endtime = clock + q->needtime;
		clock = q->endtime;
		cout<< "进程 : p" << q->name << "\t" << "执行所需时间 : " << q->needtime << "\t"
			<< "开始执行时间 : " << q->starttime << "\t" << "结束时间 : " 
			<< q->endtime <<"\t"<<"周转时间 : "<< q->endtime - q->starttime<<endl;
		RQ2.erase(q);//删除节点q
	}
}

int main(void)
{
	RR();//轮转法
	SPPSM();//短进程优先调度法
	return 0;
}