进程调度试验.docx

进程调度试验.docx

《进程调度试验.docx》由会员分享，可在线阅读，更多相关《进程调度试验.docx（20页珍藏版）》请在冰豆网上搜索。

进程调度试验

一.实习题目：

 设计一个按优先数调度算法实现处理器调度的程序。

二.实习目的：

 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

三．问题分析：

（1）假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：

进程名

指针

要求运行时间

优先数

状态

其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。

指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。

要求运行时间——假设进程需要运行的单位时间数。

优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态——可假设有两种状态，“就绪”状态和“结束”状态。

五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。

（2）在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列。

用一单元指出队首进程，用指针指出队列的连接情况。

例：

 队首标志

        K2   

K1

P1

 K2

P2

 K3

P3

 K4

P4

 K5

P5

0

K4

K5

K3

K1

2

3

1

2

4

1

5

3

4

2

R

R

R

R

R

PCB1

PCB2

PCB3

PCB4

PCB5

（4）处理器调度总是选队首进程运行。

采用动态改变优先数的办法，进程每运行一次优先数就减“1”。

由于本实习是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：

优先数-1

要求运行时间-1

来模拟进程的一次运行。

提醒注意的是：

在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。

在这里省去了这些工作。

（5）进程运行一次后，若要求运行时间¹0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。

（6）若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。

（7）在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。

（8）为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

四．编程模拟实现：

 通过上面的问题分析后，编程实现不是一个很难的问题。

 我们可以根据以上的内容从而定义一个队列，然后定义两个对象，一个用来保存就绪的进程，一个用来保存结束的进程!

然后根据以上的思路来进行操作，当用来保存就绪进程的队列为空时，循环结束，也就是说完成了所有进程的调度。

由于这个调度需要考虑进程的优先级数，所以我们可以用一个优先队列来保存就绪进程，每次对队首元素进行操作。

具体实现见源程序以及注释说明。

所用数据结构：

优先队列，优先的排序准则为各进程的优先级。

优先队列的实现方法：

直接调用STL中的标准模版库#include的优先队列priority_queue；

实现的难点：

虽然可以直接调用STL中的优先队列，无需自己写优先队列的实现类，大大简化了编程的工作量，然而如何确定优先队列的优先准则是个难点。

由于队列中的元素是一个自定义类的对象PCB，需对对象中的priority数据成员进行优先排序，不能直接简单的调用，通过查阅STL中的相关资料发现，要实现这个功能需自己编写优先准则函数，我们可以写一个包含排序准则的仿函数的类PCBSortCriterion来实现。

符号说明：

PCB：

进程类，包含进程的名字（name），运行时间（runtime），优先级（priority），状态（state），指针（next）等五个数据程序和一个方法print（）用来输出打印。

为了简化，将数据成员和方法都设置为public。

PCBSortCriterion：

包含一个仿函数的方法的排序准则类；

number：

为测试中要建立的进程个数；

pcb：

为一个PCB的数组用来保存就绪进程

p1：

为一个PCB的数组用来保存已经结束的进程

p：

为一个PCB型的变量，用来保存队首元素

pQueue：

为以PCBSortCriterion为排序准则的优先队列

q：

优先队列pQueue的一个对象，对这个队列进行主操作

temp：

优先队列pQueue的一个对象，是q的一个拷贝对象，作为实现打印输出的一个中间变量

n：

进程执行的次数  

m：

完成进程的个数

五．源程序以及注释：

#include

#include//调用STL中的优先队列

usingnamespacestd;

//定义一个PCB进程类

classPCB

{

public:

      charname[10];//进程的名字

      intruntime;//该进程的运行时间

      intpriority;//该进程的优先级

      charstate;//该进程的状态

      PCB*next;//指向下个进程的指针

      voidprint（）const//输出进程的信息

      {

            cout<<"（name="<

       <<",priority="<

      }

};

classPCBSortCriterion{//优先队列的优先准则类

public:

      booloperator（）（constPCB&p1,constPCB&p2）const//仿函数确定优先准则，从大到小

      {

            return（p1.priority

      }

};

intmain（）{

   cout<<"\t**********************************"<

   cout<<"\t***欢迎使用本系统进行进程调度!

　***"<

   cout<<"\t***      ----学号：

20040810503　　***"<

   cout<<"\t***      ----计科五班：

段翼真***"<

   cout<<"\t***      ----时间:

 2007.1.22***"<

   cout<<"\t**********************************"<

      intnumber;//进程数

      cout<<"请输入你要建立的进程数:

"<

      cin>>number;

      PCB*pcb=newPCB[number];//一个PCB的数组用来保存就绪进程

      PCB*p1=newPCB[number];//一个PCB的数组用来保存已经结束的进程

      cout<

      PCBp;//一个PCB型的变量，用来保存队首元素

     inti;

      for（i=0;i<=number-1;i++）//建立进程信息

      {

            cout<<"请输入pcb["<

"<

       cout<<"以（name,runtime,state（初始为R）,priority）格式输入!

"<

            cin>>pcb[i].name;

            cin>>pcb[i].runtime;

            cin>>pcb[i].state;

            cin>>pcb[i].priority;

            cout<

      }

      typedefpriority_queue,PCBSortCriterion>pQueue;//以//PCBSortCriterion为

//优先准则的优先队列

      pQueueq,//优先队列pQueue的一个对象，对这个队列进行主操作

          temp;//优先队列pQueue的一个对象，是q的一个拷贝对象，作为实现打印输出//的一个中间变量

      for（intj=0;j<=number-1;j++）//将进程入队建立优先队列

      {

            q.push（pcb[j]）;

      }

 //输出进程控制块的初始状态信息

      cout<<"进程控制块的初始状态信息为:

"<

      temp=q;

      while（!

temp.empty（））

                  {

                        p=temp.top（）;

                        p.print（）;

                        temp.pop（）;

                  }

                  cout<

 intn=0,//进程执行的次数  

    m=0;//完成进程的个数

      while（!

q.empty（））//对进程进行调度

      {

            cout<<"第"<<++n<<"次运行";

           p=q.top（）;

               cout<

"<

                  p.runtime-=1;

                  p.priority-=1;

                  q.pop（）;

            if（p.runtime!

=0）//表明该进程还未执行完，继续入队进行操作

            {    

                  q.push（p）;

            }

            else{//表明该进程已经执行完，设置其状态为Z，并将其保存到p1中

            p.state='Z';

                p1[m++]=p;

              }

                  cout<<"运行后的状态为:

"<

                  //打印出运行后的进程状态

                  temp=q;//拷贝输出队列

                  while（!

temp.empty（））

                  {

                        p=temp.top（）;

                        p.print（）;

                        temp.pop（）;

                  }

                  if（m>0）//输出完成的进程的信息

                        for（i=0;i<=m-1;i++）

                              p1[i].print（）;

                  cout<

                  cout<

      }

      cout<<"恭喜你！

你的进程已经调度完毕！

"<

      system（"pause"）;

      return0;

}

七：

运行结果测试：

       **********************************

       ***欢迎使用本系统进行进程调度!

***

       ***      ----学号：

20040810503***

       ***      ----计科五班：

段翼真***

       ***      ----时间:

 2007.1.22***

       **********************************

请输入你要建立的进程数:

5

请输入pcb[0]的信息!

以（name,runtime,state（初始为R）,priority）格式输入!

p15R1

请输入pcb[1]的信息!

以（name,runtime,state（初始为R）,priority）格式输入!

p26R2

请输入pcb[2]的信息!

以（name,runtime,state（初始为R）,priority）格式输入!

p34R3

请输入pcb[3]的信息!

以（name,runtime,state（初始为R）,priority）格式输入!

p47R4

请输入pcb[4]的信息!

以（name,runtime,state（初始为R）,priority）格式输入!

p52R5

进程控制块的初始状态信息为:

（name=p5,runtime=2,state=R,priority=5）

（name=p4,runtime=7,state=R,priority=4）

（name=p3,runtime=4,state=R,priority=3）

（name=p2,runtime=6,state=R,priority=2）

（name=p1,runtime=5,state=R,priority=1）

第1次运行p5!

运行后的状态为:

（name=p4,runtime=7,state=R,priority=4）

（name=p5,runtime=1,state=R,priority=4）

（name=p3,runtime=4,state=R,priority=3）

（name=p2,runtime=6,state=R,priority=2）

（name=p1,runtime=5,state=R,priority=1）

第2次运行p4!

运行后的状态为:

（name=p5,runtime=1,state=R,priority=4）

（name=p3,runtime=4,state=R,priority=3）

（name=p4,runtime=6,state=R,priority=3）

（name=p2,runtime=6,state=R,priority=2）

（name=p1,runtime=5,state=R,priority=1）

第3次运行p5!

运行后的状态为:

（name=p3,runtime=4,state=R,priority=3）

（name=p4,runtime=6,state=R,priority=3）

（name=p2,runtime=6,state=R,priority=2）

（name=p1,runtime=5,state=R,priority=1）

（name=p5,runtime=0,state=Z,priority=3）

第4次运行p3!

运行后的状态为:

（name=p4,runtime=6,state=R,priority=3）

（name=p2,runtime=6,state=R,priority=2）

（name=p3,runtime=3,state=R,priority=2）

（name=p1,runtime=5,state=R,priority=1）

（name=p5,runtime=0,state=Z,priority=3）

第5次运行p4!

运行后的状态为:

（name=p2,runtime=6,state=R,priority=2）

（name=p3,runtime=3,state=R,priority=2）

（name=p4,runtime=5,state=R,priority=2）

（name=p1,runtime=5,state=R,priority=1）

（name=p5,runtime=0,state=Z,priority=3）

第6次运行p2!

运行后的状态为:

（name=p3,runtime=3,state=R,priority=2）

（name=p4,runtime=5,state=R,priority=2）

（name=p2,runtime=5,state=R,priority=1）

（name=p1,runtime=5,state=R,priority=1）

（name=p5,runtime=0,state=Z,priority=3）

第7次运行p3!

运行后的状态为:

（name=p4,runtime=5,state=R,priority=2）

（name=p1,runtime=5,state=R,priority=1）

（name=p2,runtime=5,state=R,priority=1）

（name=p3,runtime=2,state=R,priority=1）

（name=p5,runtime=0,state=Z,priority=3）

第8次运行p4!

运行后的状态为:

（name=p1,runtime=5,state=R,priority=1）

（name=p3,runtime=2,state=R,priority=1）

（name=p2,runtime=5,state=R,priority=1）

（name=p4,runtime=4,state=R,priority=1）

（name=p5,runtime=0,state=Z,priority=3）

第9次运行p1!

运行后的状态为:

（name=p3,runtime=2,state=R,priority=1）

（name=p4,runtime=4,state=R,priority=1）

（name=p2,runtime=5,state=R,priority=1）

（name=p1,runtime=4,state=R,priority=0）

（name=p5,runtime=0,state=Z,priority=3）

第10次运行p3!

运行后的状态为:

（name=p4,runtime=4,state=R,priority=1）

（name=p2,runtime=5,state=R,priority=1）

（name=p3,runtime=1,state=R,priority=0）

（name=p1,runtime=4,state=R,priority=0）

（name=p5,runtime=0,state=Z,priority=3）

第11次运行p4!

运行后的状态为:

（name=p2,runtime=5,state=R,priority=1）

（name=p1,runtime=4,state=R,priority=0）

（name=p3,runtime=1,state=R,priority=0）

（name=p4,runtime=3,state=R,priority=0）

（name=p5,runtime=0,state=Z,priority=3）

第12次运行p2!

运行后的状态为:

（name=p1,runtime=4,state=R,priority=0）

（name=p4,runtime=3,state=R,priority=0）

（name=p3,runtime=1,state=R,priority=0）

（name=p2,runtime=4,state=R,priority=0）

（name=p5,runtime=0,state=Z,priority=3）

第13次运行p1!

运行后的状态为:

（name=p4,runtime=3,state=R,priority=0）

（name=p2,runtime=4,state=R,priority=0）

（name=p3,runtime=1,state=R,priority=0）

（name=p1,runtime=3,state=R,priority=-1）

（name=p5,runtime=0,state=Z,priority=3）

第14次运行p4!

运行后的状态为:

（name=p2,runtime=4,state=R,priority=0）

（name=p3,runtime=1,state=R,priority=0）

（name=p4,runtime=2,state=R,priority=-1）

（name=p1,runtime=3,state=R,priority=-1）

（name=p5,runtime=0,state=Z,priority=3）

第15次运行p2!