zoukankan      html  css  js  c++  java
  • 实验三

      

    实验一、进程调度模拟程序

    专业网络工程  姓名胡洁如  学号201306114125

    一、        实验目的

     

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

    二、        实验内容和要求

        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).  重复以上过程,直到所要进程都完成为止。

    (8). 动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定规则修改优先数。例如:在进程获得一次CPU后就将其优先数减少1,并且进程等待的时间超过某一时限(2个时间片时间)时增加其优先数等。

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

     

    源程序名:进程调度.cpp

    1. 1.      原理分析及流程图

                           

    1. 2.      主要程序段及其解释:

    看提交的代码

      1 #include<stdio.h>
      2 #include<stdlib.h>
      3 #include <conio.h>
      4 #include <string.h>
      5 
      6 struct Process { 
      7     //定义作业控制块PCB  
      8     char name[10];        //进程名
      9     int value;        //进程优先级    
     10     int r_time;        //进程到达时间   
     11     int m_time;        //进程所需的运行时间
     12     int usecputime;     //已用CPU时间
     13        char condition[20];       //状态
     14        int waitcount;//等待的时间片次数
     15 }; 
     16 struct Process PCB[24]={0};
     17 
     18 
     19 int Intput(Process *PCB,int n);/*初始化*/
     20 void output(Process *PCB,int n);
     21 void suanfa(Process *PCB,int n,int onetime);//主算法
     22 int isfinshed(Process *PCB,int n);//判断是否全部作业都调度完成
     23 int Find(Process *PCB,int n,int runtime);//找最高优先级且没运行完的进程
     24 int main(){
     25     int n=0;
     26     
     27     int onetime;
     28     n=Intput(PCB,n);
     29     
     30     printf("请输入一个时间片的时间:");
     31     scanf("%d",&onetime);
     32     
     33     suanfa(PCB,n,onetime);
     34     printf("\n");
     35     return 0;
     36 }
     37 
     38 void suanfa(Process *PCB,int n,int onetime)//主算法
     39 {
     40     int k=0;
     41     int i=0;
     42     int runtime=0;
     43     output(PCB, n);
     44     do{
     45         
     46         k=Find(PCB, n,runtime);
     47         PCB[k].value--;
     48         
     49         PCB[k].usecputime++;
     50         
     51         if(PCB[k].value<0)
     52         {
     53             
     54             PCB[k].value=0;
     55         }
     56         if(PCB[k].usecputime*onetime>=PCB[k].m_time)
     57         {strcpy(PCB[k].condition,"finished");}
     58         for(i=0;i<n;i++)
     59         {
     60             if(i==k)
     61             {
     62                 PCB[i].waitcount=0;
     63             }
     64             if(i!=k&&PCB[i].r_time<=runtime&&PCB[i].condition[0]!='f')
     65             {
     66                 PCB[i].waitcount++;
     67                 if(PCB[i].waitcount==2)
     68                 {
     69                     PCB[i].value++;
     70                     PCB[i].waitcount=0;
     71                 }
     72             }
     73         }
     74         output(PCB, n);
     75         runtime++;
     76     }while(isfinshed(PCB, n)!=1);
     77     
     78 }
     79 
     80 int isfinshed(Process *PCB,int n)//判断是否全部作业都调度完成
     81 {
     82     int count=0;
     83     int i=0;
     84     for(;i<n;i++)
     85     {
     86         if(PCB[i].condition[0]=='f')
     87             count++;
     88     }
     89     if(count==n)
     90     {
     91         return 1;
     92     }
     93     return 0;
     94 }
     95 int Find(Process *PCB,int n,int runtime)//找最高优先级且没运行完的进程
     96 {
     97     int i=0;
     98     
     99     int MAX=0;
    100     int k=0;
    101     for(;i<n;i++)
    102     {
    103         if(PCB[i].r_time<=runtime&&PCB[i].condition[0]=='r'&&PCB[i].value>MAX)
    104         {
    105             MAX=PCB[i].value;
    106             k=i;
    107         }
    108         
    109     }
    110     return k;
    111     
    112 }
    113 int Intput(Process *PCB,int n)/*初始化*/
    114 {
    115     int i;
    116     printf("请输入进程数:");
    117     scanf("%d",&n);
    118     for(i=0;i<n;i++)
    119     {
    120         printf("请输入第%d个进程名:\n",i+1);
    121         scanf("%s",&PCB[i].name);
    122         
    123         printf("请输入第%d个进程的优先级:\n",i+1);
    124         scanf("%d",&PCB[i].value);
    125         
    126         printf("请输入第%d个进程的到达时间:\n",i+1);
    127         scanf("%d",&PCB[i].r_time);
    128         printf("请输入第%d个进程的需要运行时间:\n",i+1);
    129         scanf("%d",&PCB[i].m_time);
    130         
    131         strcpy(PCB[i].condition,"ready");
    132         PCB[i].usecputime=0;
    133         PCB[i].waitcount=0;
    134     }
    135     
    136     return n;
    137 }
    138 
    139 void output(Process *PCB,int n)
    140 {
    141     int i;
    142     printf("\n  ——————————————————————————————");
    143     printf("\n各个进程的情况");
    144     printf("\n进程名"); 
    145           printf("  进程优先级");
    146           printf("  进程到达时间");
    147           printf("  进程所需的运行时间");
    148           printf("  已用CPU时间");
    149           printf("  状态");
    150           
    151           
    152           
    153           for(i=0;i<n;i++)
    154           {
    155               
    156               printf("\n%s",PCB[i].name);
    157               printf("        %d",PCB[i].value);
    158               printf("              %d",PCB[i].r_time);
    159               printf("                %d",PCB[i].m_time);
    160               printf("                 %d",PCB[i].usecputime);
    161               printf("          %s",PCB[i].condition);
    162               
    163               
    164           }
    165           
    166 }
    1. 3.      运行结果及分析

     

     

     结果符合预期

     

    四、        实验总结

    每次做写代码都是先把基本的东西先写出来,比如输入跟输出等基本简单的东西,然后在写出调度算法。只要明白这个调度算法的原理,实现起来就不是很难。

     

     

     

     

     

     

     

     

  • 相关阅读:
    数据结构选讲深入理解红黑树(Red Black Tree)
    [CLRS][CH 15.2] 动态规划之矩阵链乘法
    数据结构选讲树的旋转(Rotation)
    数据结构选讲二叉查找树(Binary Search Tree)
    [SICP][CH 2.2] 层次性数据和闭包性质
    [CLRS][CH 15.3] 动态规划基础
    数据结构选讲234树(234 Tree)
    IEnumerable与IEnumerator
    你日常所做的事情,决定你将永远成为什么样的人
    c#中正则表达中特殊字符的转义!
  • 原文地址:https://www.cnblogs.com/jieru/p/4519529.html
Copyright © 2011-2022 走看看