实验二进程调度模拟程序1.0

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了实验二进程调度模拟程序1.0相关的知识,希望对你有一定的参考价值。

实验二、进程调度模拟程序1.0

一、    实验目的

用C语言模拟进程调度程序,以加深对进程的概念及进程调度算法的理解。

二、    实验内容及要求

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

进程调度算法:

(1)  先来先服务调度算法,即按作业到达的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。

(2)  优先级调度算法,为每个作业设置一个优先级,调度之前先比较各作业的优先级,优先数高者优先调度,若优先级相同则用先来先服务算法。

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

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

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

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

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

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

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

三、    实验方法及结果测试

(1)先来先服务调度算法:

#include<stdio.h>

#include<stdlib.h>

 

typedef struct PCB {

    char name[30];//进程名称

    float arriveTime;//到达时间

    float serveTime;//服务时间

    float finishTime;//完成时间

} FCFS;

 

struct PCB a[100];

 

struct PCB *sortArriveTime(struct PCB a[],int n);//到达时间冒泡排序

void Fcfs(struct PCB a[],int n);//FCFS算法

 

//按到达时间进行冒泡排序

struct PCB *sortArriveTime(struct PCB a[],int n) {

    int i,j;

    struct PCB t;

    int flag;

    for(i=1; i<n; i++) {

       flag=0;

       for(j=0; j<n-i; j++) {

           if(a[j].arriveTime>a[j+1].arriveTime) { //将到达时间短的交换到前边

              t=a[j];

              a[j]=a[j+1];

              a[j+1]=t;

              flag=1;//交换

           }

       }

       if(flag=0) { //如果一趟排序中没发生任何交换,则排序结束

           break;

       }

    }

    return a;//返回排序后进程数组

}

 

//先来先服务算法

void Fcfs(struct PCB a[],int n) {

    int i;

    a[0].finishTime=a[0].arriveTime+a[0].serveTime;//完成时间=到达时间+服务时间

    for(i=1; i<n; i++) {

       if(a[i].arriveTime<a[i-1].finishTime) { //当前到达时间在上一个作业结束时间之前

           a[i].finishTime=a[i-1].finishTime+a[i].serveTime;//完成时间=上一个完成时间+服务时间

       } else {

           a[i].finishTime=a[i].arriveTime+a[i].serveTime;

       }

    }

    printf("进程名称\\t到达时间\\t服务时间\\t完成时间\\t\\n");

    for(i=0; i<n; i++) {

       printf(" %s\\t",a[i].name);

       printf("\\t%f",a[i].arriveTime);

       printf("\\t%f",a[i].serveTime);

       printf("\\t%f",a[i].finishTime);

       printf("\\n");

    }

}

 

main() {

    int n,i;

    printf("\\n            *************进程调度算法(先来先服务算法)************\\n\\n");

    printf("请输入进程数目:");

    scanf("%d",&n);

    printf("\\n");

    for(i=0; i<n; i++) {

       printf("第%d个进程的名称:",i+1);

       scanf("%s",&a[i].name);

       printf("第%d个进程的到达时间:",i+1);

       scanf("%f",&a[i].arriveTime);

       printf("第%d个进程的服务时间:",i+1);

       scanf("%f",&a[i].serveTime);

       printf("\\n");

    }

    sortArriveTime(a,n);//冒泡排序

    Fcfs(a,n);//先来先服务算法

}

测试结果:

技术分享

(2)优先级调度算法:

#include<stdio.h>

#include<stdlib.h>

#define MAX 100

/*定义进程结构体*/

typedef struct pcb {

    char name[30];//进程名称

    int priority ;//进程优先数

    int serveTime;//进程到达时间

    int cpuTime;//进程占用CPU时间

    char state;//进程状态

} PCB;

 

Input(PCB p[MAX],int n) {

    int i;

    for(i=0; i<n; i++) {

       printf("第%d个进程的名称:",i+1);

       scanf("%s",&p[i].name);

       printf("第%d个进程的优先数:",i+1);

       scanf("%d",&p[i].priority);

       printf("第%d个进程的服务时间:",i+1);

       scanf("%d",&p[i].serveTime);

       p[i].state=‘W‘;

       p[i].cpuTime=0;

       printf("\\n");

    }

}

 

Output(PCB p[MAX],int n) {

    int i;

    printf("进程名称\\t优先级数\\t服务时间\\t当前时间\\t进程状态\\n");

    for(i=0; i<n; i++) {

       printf(" %s\\t",p[i].name);

       printf("\\t%d\\t",p[i].priority);

       printf("\\t%d\\t",p[i].serveTime);

       printf("\\t%d\\t",p[i].cpuTime);

       printf("\\t%c\\t",p[i].state);

       printf("\\n");

    }

}

 

PrioritySort(PCB p[MAX],int n) {

    int m=0,i=0,j ;

    PCB temp;

    m = n;

    for(i = 1 ; i < n ; i++) {

       m = m - 1 ;

       for(j = 0 ; j < m ; j ++) {

           if(p[j].priority < p[j+1].priority) {

              temp = p[j];

              p[j] = p[j+1];

              p[j+1] = temp ;

           }

       }

    }

}

 

Run(PCB p[MAX] , int n) {

    int i ,j ;

    int m=0;

    for(i = 0 ; i < n ; i ++) {

       m = p[i].serveTime+m;

    }

    for(i = 0 ; i < n ; i ++) {

       for(j = 0 ; j < m ; j ++) {

           printf("请按回车键继续运行......!\\n");

           getchar();

           p[i].priority--;

           p[i].cpuTime++;

           p[i].serveTime--;

           p[i].state=‘R‘;

           PrioritySort(p,n);

           Output(p,n);

           if(p[i].serveTime!=0) {

              p[i].state=‘R‘;

           } else {

              p[i].state=‘F‘;

              printf("********第%d个进程的运行完成!********\\n",i+1);

              break;

           }

       }

    }

}

 

End(PCB p[MAX] , int n) {

    int i ,j ;

    for(i = 0 ; i < n ; i ++) {

       if(p[i].serveTime==0){

           p[i].state=‘F‘;

       }

    }

    Output(p,n);

    printf("********进程调度结束!********\\n",i+1);

}

 

main() {

    PCB p[MAX];

    int n,i;

    printf("\\n            *************进程调度算法(优先级调度算法)************\\n\\n");

    printf("请输入进程数目:");

    scanf("%d",&n);

    printf("\\n");

    Input(p,n);

    PrioritySort(p,n);

    Output(p,n);

    getchar();

    Run(p,n);

    End(p,n);

}

测试结果:

技术分享

 

技术分享

技术分享

四、    实验总结

1、总的来说,进程调度理解起来并不难,反而挺简单,但用程序语言模拟其过程就有点困难了;

2、虽说这两个进程调度算法可以算是简单模拟出效果,但其中还有很多需要改进。

以上是关于实验二进程调度模拟程序1.0的主要内容,如果未能解决你的问题,请参考以下文章

实验三进程调度模拟程序

实验三进程调度模拟程序2.0

实验三进程调度模拟程序2.0

实验三 进程调度模拟程序2.0

操作系统实验二(调度算法模拟-先进先出-时间片轮转法-优先服务调度算法)

实验三