计算机操作系统：实验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的结构：

• 优先级算法中，设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：进程标识符号，取值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>intmain()
{
intpid[15];
intbt[15];
intn;
printf("输入进程数: ");
scanf("%d",&n);
printf("输入所有进程的进程ID: ");
for(inti=0;i<n;i++)
    {
scanf("%d",&pid[i]);
    }
printf("输入所有进程的突发时间: ");
for(inti=0;i<n;i++)
    {
scanf("%d",&bt[i]);
    }
inti, wt[n];
wt[0]=0;
//用于计算每个进程的等待时间for(i=1; i<n; i++)
    {
wt[i]=bt[i-1]+wt[i-1];
    }
printf("进程ID     突发时间     等待时间     周转时间\n");
floattwt=0.0;
floattat=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]);
    }
floatatt,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>intmain()
{
intbt[20],p[20],wt[20],tat[20],i,j,n,total=0,totalT=0,pos,temp;
floatavg_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);
}

• 它运行的结果是：
  

六、最后我想说

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