计算机操作系统：实验1【进程调度】

计算机操作系统：实验1【进程调度】

一、前言

本次博客我们将学习有关操作系统实验的内容，本学期一共有三次实验，这次是第一次实验，本次实验我们需要使用C/C++或者JAVA实现进程调度，实验较难，而且本人不太熟练C/C++，所以上网翻阅然后总结一下。

二、实验目的

进程是操作系统最重要的概念之一，进程调度是操作系统内核的重要功能，本实验要求用C语言编写一个进程调度模拟程序，使用优先级或时间片轮转法实现进程调度。本实验可加深对进程调度算法的理解。

三、实验环境

Turbo C 2.0/3.0或VC++6.0

我所使用的编译器是：Embarcadero Dev-C++

四、实验内容

1. 设计有5个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
2. 模拟调度程序可任选两种调度算法之一实现。
3. 程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。

五、实验步骤

1、理解本实验中关于两种调度算法的说明。

• 优先级算法

  （1）PCB的结构：

  Id
  Span
  Used
  Need
  Satus
  Next

  优先级算法中，设PCB的结构如上图所示，其中各数据项的含义如下：

  Id：进程标识符号，取值1—5。

  Prior：优先级，随机产生，范围1—5。

  Used：目前已占用的CPU时间数，初值为0；当该进程被调用执行时，每执行一个时间片，Used加1。

  Need：进程尚需的CPU时间数，初值表示该进程需要运行的总时间，取值范围为5—10。并随机产生，每运行一个时间片need减1；need为0则进程结束。

  Status：进程状态R（运行），J（就绪），F（完成）；初始时都处于就绪状态。

  Next：指向就绪队列中下一个进程的PCB的指针。

  （2）初始状态及就绪队列组织：

  5个进程初始都处于就绪状态，进程标识1—5，used初值都为0。各进程的优先级随机产生，范围1—5。处于就绪状态的进程，用队列加以组织，队列按优先级由高到低依次排列，队首指针设为head，队尾指针设为tail。

  （3）调度原则以及运行时间的处理：

  正在执行的进程每执行一个时间片，其优先级减1（允许优先级为负）。进程调度将在以下情况发生：当正在运行的程序其优先级小于就绪队列队首进程的优先级时。程序中进程的运行时间以逻辑时间片为单位。

• 时间片轮转算法

  （1）PCB的结构：

  轮转法中，设PCB的结构如右图所示，其中各数据项的含义如下：

  Id
  Span
  Used
  Need
  Satus
  Next

  Id：进程标识符号，取值1—5。

  Span：在某一轮中，分配给先运行进程的时间片数，取值1—3。

  Used：现运行进程在本轮执行过程已用的时间片数。

  Need：进程尚需的CPU时间数，初值表示该进程需要运行的总时间，

  取值范围5—10。并随机产生，每运行一个时间片need减1；need为0则进程结束。

  Status：进程状态R（运行），J（就绪），F（完成）；初始时所有进程处于就绪状态。

  Next：指向就绪队列中下一个进程的PCB的指针。

  （2）初始状态及就绪队列组织：

  Span、Used在每轮开始时赋初值，Used初值值为0，Span初值要求随机产生。

  （3）调度原则：

  当一个进程被调度程序执行时，每经过一个时间片，Need减1，Used加1，如果Need为0，表示该进程结束，如果Need不为0，并且Used小于本轮Span值，则该进程可继续运行，若Need不为0，且Used等于Span值，则该进程本轮运行时间已到，应调度下一个队首进程运行。

2、根据调度算法的说明，画出相应的程序流程图

• 先到先服务（FCFS）

• 最短作业优先（SJF）非抢占式

  

3、按照程序流程图，用C/C++语言编程并实现

• FCFS

  CPU 调度算法先来先服务 ( FCFS )，也称为先进先出 ( FIFO )，按照进程在就绪队列中的排队顺序将 CPU 分配给进程。

  FCFS使用非抢占式调度，这意味着一旦将 CPU 分配给进程，它就会一直分配给该进程，直到它没有被终止或可能被 I/O 中断中断。

  #include <stdio.h>
  int main()
  {
      int pid[15];
      int bt[15];
      int n;
      printf("输入进程数: ");
      scanf("%d",&n);
   
      printf("输入所有进程的进程ID: ");
      for(int i=0;i<n;i++)
      {
          scanf("%d",&pid[i]);
      }
   
      printf("输入所有进程的突发时间: ");
      for(int i=0;i<n;i++)
      {
          scanf("%d",&bt[i]);
      }
   
      int i, wt[n];
      wt[0]=0;
   
      //用于计算每个进程的等待时间
      for(i=1; i<n; i++)
      {
          wt[i]= bt[i-1]+ wt[i-1];
      }
   
      printf("进程ID     突发时间     等待时间     周转时间\n");
      float twt=0.0;
      float tat= 0.0;
      for(i=0; i<n; i++)
      {
          printf("%d\t\t", pid[i]);
          printf("%d\t\t", bt[i]);
          printf("%d\t\t", wt[i]);
   
          //计算和打印每个过程的周转时间
          printf("%d\t\t", bt[i]+wt[i]);
          printf("\n");
   
          //用于计算总等待时间
          twt += wt[i];
   
          //用于计算总周转时间
          tat += (wt[i]+bt[i]);
      }
      float att,awt;
   
      //用于计算平均等待时间
      awt = twt/n;
   
      //用于计算平均周转时间
      att = tat/n;
      printf("平均等待时间= %f\n",awt);
      printf("平均周转时间= %f",att);
  }
  

  它运行的结果是：

• SJF

  CPU调度算法最短作业优先（SJF），根据执行时间最短的进程为进程分配CPU。

  SJF使用抢占式和非抢占式调度。SJF 的抢先版本称为SRTF（最短剩余时间优先）。这里我们将讨论SJF，即非抢占式调度。

  #include<stdio.h>
  int main()
  {
      int bt[20],p[20],wt[20],tat[20],i,j,n,total=0,totalT=0,pos,temp;
      float avg_wt,avg_tat;
      printf("输入进程数:");
      scanf("%d",&n);
   
      printf("\n输入突发时间:\n");
      for(i=0;i<n;i++)
      {
          printf("p%d:",i+1);
          scanf("%d",&bt[i]);
          p[i]=i+1;
      }
   
      //突发时间排序
      for(i=0;i<n;i++)
      {
          pos=i;
          for(j=i+1;j<n;j++)
          {
              if(bt[j]<bt[pos])
                  pos=j;
          }
   
          temp=bt[i];
          bt[i]=bt[pos];
          bt[pos]=temp;
   
          temp=p[i];
          p[i]=p[pos];
          p[pos]=temp;
      }
   
      wt[0]=0;
   
      //查找所有进程的等待时间
      for(i=1;i<n;i++)
      {
          wt[i]=0;
          for(j=0;j<i;j++)
               //通过添加所有先前已完成流程的突发时间来实现单个等待时间
              wt[i]+=bt[j];
   
          //总等待时间
          total+=wt[i];   
      }
   
      //平均等待时间
      avg_wt=(float)total/n;  
   
      printf("\n进程ID\t 突发时间 \t等待时间\t周转时间");
      for(i=0;i<n;i++)
      {
          //各个流程的周转时间
          tat[i]=bt[i]+wt[i]; 
   
          //总周转时间
          totalT+=tat[i];      
          printf("\np%d\t %d\t\t %d\t\t%d",p[i],bt[i],wt[i],tat[i]);
      }
   
      //平均周转时间
      avg_tat=(float)totalT/n;     
      printf("\n\n平均等待时间=%f",avg_wt);
      printf("\n平均周转时间=%f",avg_tat);
  }
  

  它运行的结果是：

  

六、最后我想说

目前来说基本达到了实验要求，网上还有很多更加详细的代码，大家可以自行取看看，我自己也还需要琢磨琢磨。