《操作系统原理》实验一:进程调度

操作系统原理实验—进程调度实验报告

一、目的与要求

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

（2）按照实验题目要求独立地、正确地完成实验内容（编写、调试算法程序，提交程序清单及相关实验数据与运行结果，完成个人实验报告）。

（3）2020年6月5日以前提交本次实验报告（含实验所有电子文档和纸质报告，实验相关文件打包以 学号-姓名-实验1.rar 为名命名，实验报名以 学号-姓名-实验1为文件名，由学习委员以班为单位统一打包提交）。

2 实验内容或题目

（1）设计有5个或5个以上进程并发执行的模拟调度程序，每个程序由一个PCB表示。

（2）模拟调度程序可任选两种调度算法之一实现，也可实验两个或两个以上调度算法。

（3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。

（4）本次实验内容（项目）的详细说明以及要求请参见实验指导书。

3 实验步骤与源程序

1. 算法原理

时间片轮转调度算法

1) 时间片轮转算法的思想是，让队列中运行的每个进程都可以得到平等的运行时间片，然后对队列进行循环直到所有进程执行完毕。

2) 对于时间片大小的选取是十分重要的，既不能太大，如果太大的话会导致短进程无法作业运行，如果时间片太小的话效率又会减小很多。所以对于时间片来讲要根据进程的大小选择合理的时间片

3) 进程的切换机制体现出了时间片轮转算法的特点。若一个进程在时间片还没结束时就已完成，就将它从队列中移除。若一个进程在时间片结束时还没运行完成，等待下次运行。

4) 本次实验的时间片轮转算法采用c语言对算法进行模拟，采用的时间片为3直到系统需要的时间片都小于0结束

优先级调度算法

1） 由于时间的轮转算法，无法对进程的紧急情况进行区分。因此又提出了优先级调度算法，从而解决进程优先级的问题。

2） 进程优先级的确定同样重要，进程优先级可以分为静态优先级和动态优先部，静优先级是在通程创建里初期就被确定的值，此后不再更改。动态优先级指进程在创建时被赋子一个初值，此后其值会所进程的推进或等待时间的增加而改变。

3） 本次实验的优先级调度算法采用C语言对算法进行模拟，优先级选择初始化随机数据1-5，当need满足的时候将进程优先级设置为-100。

2. 程序流程图

时间片轮转算法执行流程图：

优先级调度算法执行流程图：

3. 程序代码及注释

/**

时间的轮转算法！！！

*/

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <time.h>

#define spand 3//设置时间片长度为3

typedef struct pcd

{

int id;//进程ID

int span;//运行进程的时间片数

int used;//已用的时间片数

int need;//进程需要运行的时间

char status;//进程状态

struct PCB *next;

} PCB;

PCB *head,p[5],t[5];

//打印

void print()

{

int i,temp;

printf("---------------------------------\n");

printf("ID \t span\tused\tneed\tstatus\n");

for(i=0; i < 5; i++)

{

printf("%d\t%d\t%d\t%d\t%c\n",p[i].id,p[i].span,p[i].used,p[i].need,p[i].status);

}

}

//初始化进程队列

void inputprocess()

{

int i;

srand(time(0));//为随机数产生种子；

for(i = 0; i < 5; i++)

{

p[i].id = i + 1;

p[i].span= 3;

p[i].used=0;

p[i].need=5+rand()%6;//为总的时间片产生5-10的整数

p[i].status='J';

}

head = p;

printf("开始进程的状态：\n");

print();//打印进程状态

}

//时间的轮转算法

void runprocess()

{

int i=0;

while(p[0].need > 0 ||p[1].need > 0||p[2].need > 0||p[3].need > 0||p[4].need > 0)//当需求有一个未被满足时进程继续执行

{

p[i%5].used += 3;

p[i%5].need -= 3;

p[i%5].status = 'R';

if(p[i%5].need <= 0)//如果进程已被满足调用下一个进程

{

p[i%5].status='F';

i++;

}

else if(p[i%5].need <= 0 && p[(i%5)+1].need <= 0)//如果连续两个进程已被满足调用下一个进程

{

p[i%5].status='F';

i++;

}

else if(p[i%5].need <= 0 && p[(i%5)+1].need <= 0 && p[(i%5)+2].need <= 0)//如果连续三个进程已被满足调用下一个进程

{

p[i%5].status='F';

i++;

}

else if(p[i%5].need <= 0 && p[(i%5)+1].need <= 0 && p[(i%5)+2].need <= 0 && p[(i%5)+3].need <= 0)////如果连续三个进程已被满足调用下一个进程

{

p[i%5].status='F';

i++;

}

print();//打印进程状态

if(p[i%5].status=='R')//如果本次进程执行完毕将程序由运行状态置为就绪状态

{

p[i%5].status = 'J';

}

i++;

}

}

int main(void)

{

inputprocess();

runprocess();

return 0;

}

/**

优先级调度算法

*/

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

typedef struct pcd

{

int id;//进程ID

int prior;//进程优先级

int used;//已使用时间

int need;//还需时间

char status;//进程状态

} PCB;

PCB *head,p[5],a[5];

//将每次进程调度的结果打印在屏幕上

void print()

{

int i,temp;

printf("---------------------------------\n");

printf("ID \t prior\tused\tneed\tstatus\n");

for(i=0; i < 5; i++)

{

printf("%d\t%d\t%d\t%d\t%c\n",p[i].id,p[i].prior,p[i].used,p[i].need,p[i].status);

}

}

//根据进程的优先级进行排序为下一次进程调度做准备

void sort()

{

int i,j;

//PCB temp;

for(i=0; i < 5; i++)

{

for(j = 0; j <4-i;j++)

{

if(p[j].prior <p[j+1].prior)

{

PCB temp = p[j];

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

p[j+1] = temp;

}

}

}

}

//初始化进程队列

void inputprocess()

{

int i;

for(i = 0; i < 5; i++)

{

p[i].id = i + 1;

p[i].prior = rand()%5+1;//随机生成1-5的整数

p[i].used = 0;

p[i].need = 5+rand()%6;//为总的时间片产生5-10的整数

p[i].status = 'W';

}

sort();//按优先级排序

head = p;

printf("开始进程的状态：\n");

print();//打印进程状态

}

//按最高优先级调度进程队列

void runprocess()

{

PCB *p1 = NULL;

do{

p1 = head;

head = p+1;

printf("***%d***%d***\n",p1->prior,head->prior);

while((p1->need > 0)&&(p1->prior >= head->prior))//如果p1的需求数大于0并且 当前进程的优先级大于等于它下面一个进程的优先级

{

p1->need--;

p1->prior--;

p1->used++;

p1->status='R';

print();

}

if(p1->need == 0)//如果当前进程的需求为0时将优先级置为-100说明该进程运行完毕

{

p1->prior = -100;

p1->status = 'F';

}

else//否则将该进程置为等待状态为下一次运行做准备

{

p1->status='W';

}

sort();

head = p;

}

while(head->prior != -100);

print();//显示最后各个进程的状态

printf("--------------------------\n");

printf("所有进程全部完成！！！");

}

int main()

{

inputprocess();//调用初始化进程自定义函数

runprocess();//调用调度程序的函数

return(1);

}

4 测试数据与实验结果（可以抓图粘贴）

1. 时间的轮转算法测试数据及结果：

直到全部need小于等于0时所有进程运行完成

2.优先级调度算法测试数据及结果：

5 结果分析与实验体会

本次实验使用了时间片轮转算法与优先级调度算法并用C语言进行算法进程模拟。使我对C语言编写有了更加深刻的理解，同时对两个算法的原理也有了更加深刻的理解。使我以后对操作系统的调度算法能够运用的更加熟练。

6.分析与思考

1、逻辑时间片该如何实现?

答:系统将所有的就绪进程按先来先服务算法的原则，排成- 一个队列，每次调度时，系队列首进程，并让其执行一一个时间片。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序根据这个请求停止该进程的运行，将它送到就绪队列的末尾，再把处理机分给就绪队列中

新的队首进程，同时让它也执行一一个时间片。

2、如果不使用指针操作，是否也可以使用数组实现进程就绪队列的组织?

答:可以