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

实验三 进程调度模拟程序

     专业：商业软件工程     班级：商软2班     姓名：甘佳萍     学号：201406114207

一.    目的和要求

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个时间片时间）时增加其优先数等。

(3). （**）进程的优先数及需要的运行时间可以事先人为地指定，（也可以由随机数产生）。

(4). （**）在进行模拟调度过程可以创建（增加）进程，其到达时间为进程输入的时间。

0．

 

1.2.3实验题B：编写并调试一个模拟的进程调度程序，采用“基于时间片轮转法”调度算法对N（N不小于5）个进程进行调度。 “轮转法”有简单轮转法、多级反馈队列调度算法。

(1). 简单轮转法的基本思想是：所有就绪进程按 FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片长度相同。如果运行进程用完它的时间片后还未完成，就把它送回到就绪队列的末尾，把处理机重新分配给队首的进程。直至所有的进程运行完毕。（此调度算法是否有优先级？）

 (2). 多级反馈队列调度算法的基本思想是：

将就绪队列分为N级（N＝3～5），每个就绪队列优先数不同并且分配给不同的时间片：队列级别越高，优先数越低，时间片越长；级别越小，优先数越高，时间片越短。

系统从第一级调度，当第一级为空时，系统转向第二级队列，.....当处于运行态的进程用完一个时间片，若未完成则放弃CPU，进入下一级队列。

当进程第一次就绪时，进入第一级队列。

(3). （**）考虑进程的阻塞状态B（Blocked）增加阻塞队列。进程的是否阻塞和阻塞的时间由产生的“随机数”确定（阻塞的频率和时间长度要较为合理）。注意进程只有处于运行状态才可能转换成阻塞状态，进程只有处于就绪状态才可以转换成运行状态。

 

二.    实验内容

根据指定的实验课题：A（1），A（2），B（1）和B（2）

完成设计、编码和调试工作，完成实验报告。

注：带**号的条目表示选做内容。

 

三、        实验方法、步骤及结果测试

 1.      源程序名：压缩包文件（rar或zip）中源程序名yy.c

可执行程序名：yy.exe

 2.      原理分析及流程图

主要总体设计问题。

(包括存储结构，主要算法，关键函数的实现等)

存储结构：

typedef struct process  
{    
    char name[10];                      //进程名   
    int priority;                       //优先数,priority=-1000; 表示进程调度已完成 
    Time ReachTime;                     //到达时间,这里按照录入系统时的先后顺序，从0依次增加   
    Time NeedTime;                     //需要运行时间   
    Time UsedTime;                     //已用时间，是指当前该进程已用的时间   
    char state;                        //进程状态，就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一
}PCB;                                //进程控制块

主要算法：

关键函数：

void menu()
void AddProcess() 
void sort()  
void print() 
void attemper() 
void main() 

 3.      主要程序段及其解释：

实现主要功能的程序段，重要的是程序的注释解释。        

源程序:

#include <stdio.h> 

#define Time int 
#define Max 100   

typedef struct process  
{    
    char name[10];                      //进程名   
    int priority;                       //优先数,priority=-1000; 表示进程调度已完成 
    Time ReachTime;                     //到达时间,这里按照录入系统时的先后顺序，从0依次增加   
    Time NeedTime;                     //需要运行时间   
    Time UsedTime;                     //已用时间，是指当前该进程已用的时间   
    char state;                        //进程状态，就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一
}PCB;                                //进程控制块

int n;                               //标示进程的总数 
PCB pcb[Max];  
int pTime;                          //时间片大小 

//菜单
void menu()
{
    printf("\n                 |*************** 进程调度 *************|\n");
    printf("                 |======================================|\n");
    printf("                 |     0.进程调度结束，并退出           |\n");
    printf("                 |     1.增加进程并调度进程             |\n");
    printf("                 |     2.打印进程                       |\n");
    printf("                 |======================================|\n");
}

void AddProcess() 
{     
    char ch; 
     do 
     {            
         printf("\n请输入进程名:");          
         scanf("%s",pcb[n].name);           
         printf("请输入进程的优先级:");          
         scanf("%d",&pcb[n].priority);           
         printf("请输入进程需要的时间:");          
         scanf("%d",&pcb[n].NeedTime);         
         pcb[n].ReachTime=n;          
         pcb[n].UsedTime=0;         
         pcb[n].state='W';          
         n++;        
         printf("您还要继续增加进程吗,是(Y/y),否(N/n):");          
         do        
         {            
             ch=getchar();        
         } while(ch!='Y'&&ch!='N'&&ch!='y'&&ch!='n');         
     }while (ch=='Y'||ch=='y');
     }  // 排序函数，将最先运行的进程放在最先即pcb[0] 

void sort()  
{                                     //用冒泡排序     
    int i,j;     
    PCB temp;                                       
    //先按到达时间排序  
    for (i=0;i<n-1;i++)  
    {    
        for (j=n-2;j>=i;j--)   
        {     
            if (pcb[j+1].ReachTime<pcb[j].ReachTime)    
            {      
                temp=pcb[j];      
                pcb[j]=pcb[j+1];     
                pcb[j+1]=temp; 
            }   
        }  
    
    }                                       //再按优先级进行排序  
    for (i=0;i<n-1;i++)  
    {    
        for (j=n-2;j>=i;j--)   
        {     
            if (pcb[j+1].priority>pcb[j].priority)    
            { 
                temp=pcb[j];      
                pcb[j]=pcb[j+1];     
                pcb[j+1]=temp;    
            }   
        }  
    }   
    if (pcb[0].state!='F')  
    {    
        pcb[0].state='R';                //将优先级最高的状态置为运行  
    } 
}    

void print()                             //打印 
{      
    int i;     
    sort();   
    printf("\n  进程名    优先级   到达时间  需要时间  已用时间  进程状态 \n");   
    for (i=0;i<n;i++)    
    {  
        printf("%8s%8d%8d%10d%10d%10c\n",pcb[i].name,pcb[i].priority,pcb[i].ReachTime,pcb[i].NeedTime,pcb[i].UsedTime,pcb[i].state); 
    } 
}  

void attemper()                           //调度   
{           
    do{      
        if ((pcb[0].NeedTime-pcb[0].UsedTime)>pTime)     
        {           
            pcb[0].UsedTime+=pTime;       //已用时间加时间片         
            pcb[0].priority--;            //优先级减一
            pcb[0].state='W';     
        }        
        else     
        {       
            pcb[0].UsedTime=pcb[0].NeedTime;//已用时间等于需要时间         
            pcb[0].priority=-1000;         //优先级置为零          
            pcb[0].state='F';             //完成进程，将状态置为完成     
        }         
        print();     
    }while(pcb[0].state!='F'); 
}  

void main() 
{   
    int i;
        n=0;                                 //初始化进程数为0     
    printf("请设置当前进程的时间片大小:");     
    scanf("%d",&pTime);     
    while(1)
    {
     menu();
        printf("\t请选择输入 (0~2):  ");
        scanf("%d",&i);
    
           switch(i)/*根据输入的i值不同选择相应操作*/
        {
            case 1 :           
            AddProcess();     
            print();     
            attemper();     
              break ;
            case 2 :
                 print();break ;
            case 0:
              return;    
       }
    }
}

4.      运行结果及分析

一般必须配运行结果截图，结果是否符合预期及其分析。

   （截图需根据实际，截取有代表性的测试例子）

运行结果：

 

四、        实验总结

     总之，编写进程调度模拟程序的过程有（如解决实际问题）。从解决实际问题的角度，我们可以这样来看：首先要了解这个问题的基本要求，即输入、输出、完成从输入到输出的要求是什么；其次，从问题的要害入手，从前到后的解决问题的每个方面，即从输入开始入手，着重考虑如何从输入导出输出。在这个过程中，可确定所需的变量、数组、函数，然后确定处理的过程－－算法。可得出最后的结论，进而完成程序的编写。经过这次实验，我对进程调度有了深一步的了解，同时也初步了解了进程调度模拟程序的工作原理。总的来说这个实验不是很难，还有这个实验很有趣。