实验三 进程调度模拟程序--操作系统

一.    目的和要求

1.1.           实验目的

用高级语言完成一个进程调度程序,以加深对进程的概念及进程调度算法的理解。

1.2.           实验要求

1.2.1例题:设计一个有 N个进程并发执行的进程调度模拟程序。

进程调度算法:采用最高优先级优先的调度算法(即把处理机分配给优先级最高的进程)和先来先服务(若优先级相同)算法。

(1).  每个进程有一个进程控制块(PCB)表示。进程控制块包含如下信息:进程名、优先级、到达时间、需要运行时间、已用CPU时间、进程状态等等。

(2).  进程的优先级及需要的运行时间可以事先人为地指定,进程的运行时间以时间片为单位进行计算。

(3).  每个进程的状态可以是就绪 r(ready)、运行R(Running)、或完成F(Finished)三种状态之一。

(4).  就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。

(5).  如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待调度。

(6).  每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB,以便进行检查。   

(7).  重复以上过程,直到所要进程都完成为止。

思考:作业调度与进程调度的不同?

1.2.2实验题A:编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对N(N不小于5)个进程进行调度。

“最高优先级优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

(1). 静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。

(2). 动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定规则修改优先数。例如:在进程获得一次CPU后就将其优先数减少1,并且进程等待的时间超过某一时限(2个时间片时间)时增加其优先数等。
  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<time.h>
  4 #include<string.h>
  5 struct Pcb{
  6     int id;            //识别码
  7     char* pname;    //进程名
  8     int priority;   //优先级
  9     int arrtime;    //到达时间
 10     int reqtime;    //运行时间
 11     int usetime;    //使用CPU时间
 12     char* statio;    //进程的状态
 13 
 14 }   Pcb[24];
 15 int systime=0;
 16 
 17 
 18 //优先级排序
 19 void sort(int n ,int first)
 20 {
 21     int i,j; 
 22     struct Pcb temp;
 23     for(i=first;i<n;i++) 
 24     for(j=i+1;j<=n;j++) 
 25     if(Pcb[i].priority<Pcb[j].priority) //根据优先级排序
 26     { 
 27        temp=Pcb[i]; 
 28        Pcb[i]=Pcb[j]; 
 29        Pcb[j]=temp; 
 30     } 
 31 
 32 }
 33 
 34 void putresult(int n){
 35     int i;
 36 
 37 printf("
id 进程名  进程优先级  进程到达时间 进程使用CPU时间  进程运行时间 进程状态
");
 38     for(i=1; i<=n; i++)
 39     {
 40        printf("%d%5s%10d%12d%12d%15d%17s
",Pcb[i].id,Pcb[i].pname,
 41                                       Pcb[i].priority,Pcb[i].arrtime,
 42                                       Pcb[i].usetime,Pcb[i].reqtime,Pcb[i].statio);
 43     }
 44 
 45 
 46 }
 47 
 48 
 49 //伪随机数的产生数据
 50 int Pseudo_random_number()
 51 {
 52     int i,n;
 53     srand((unsigned)time(0));  //参数seed是rand()的种子,用来初始化rand()的起始值。
 54     //输入进程数
 55     n=rand()%5+2;        
 56     for(i=1; i<=n; i++)
 57     {    //唯一识别码
 58         Pcb[i].id=i;
 59         //进程名
 60         Pcb[i].pname="pcb";
 61         //进程优先级
 62         Pcb[i].priority=rand()%9+1;
 63         //进程到达时间
 64         Pcb[i].arrtime=rand()%29+1;
 65         //进程运行完成所需时间
 66         Pcb[i].reqtime=rand()%7+1;
 67         //进程使用CPU时间
 68         Pcb[i].usetime=0;
 69         //进程状态
 70         Pcb[i].statio="ready";
 71 
 72     }
 73     putresult(n);
 74    
 75     return n;
 76 
 77 }
 78 
 79 
 80 //判断是否有运行结束的程序
 81 
 82 int drop(int n ){
 83     int i=0;
 84     for(i=0;i<n;i++)
 85     {
 86         if(strcmp(Pcb[i].statio,"Finish")==0)
 87         {
 88         return i;
 89         }
 90     }
 91     
 92     return  100;
 93 
 94 }
 95 
 96 
 97 //进行CPU调用
 98 void CPURun(int n)
 99 {    int i;
100     
101         for(i=1;i<=n;i++)
102         {
103         while(Pcb[i].reqtime!=0){
104             Pcb[i].priority-=1;  //运行一次后,优先级-1
105             Pcb[i].reqtime-=1;    //运行一次后,所需时间-1
106             Pcb[i].usetime+=1;       //运行一次后,运行时间+1
107             Pcb[i].statio="Runing";     //运行一次后,运行状态为Running        
108             
109             if(Pcb[i].reqtime==0){    
110                 Pcb[i].statio="Finish";
111                 putresult(n);
112             
113             }
114             sort(n,i);
115             putresult(n);
116             
117         }        
118             
119         }
120     
121         
122     
123     
124 
125     
126 
127 }
128 
129 
130 
131 main()
132 {
133 printf("				随机产生进程
");
134 int n=Pseudo_random_number();
135   printf("			进程的个数为%d
",n);
136     sort(n,1);
137 printf("			进行优先级的排序
");
138 
139 putresult(n);
140 CPURun(n);
141 
142 return 0;
143 }

  



原文地址:https://www.cnblogs.com/zlcan/p/5487734.html