处理机调度实验报告

计算机与信息技术学院综合性、设计性实验报告
专业：计算机科学与技术年级/班级：08级计科二班 2010—2011学年第一学期
课程名称计算机操作系统指导教师
本组成员
学号姓名
实验地点实验时间
项目名称进程管理实验类型综合性
一、实验目的和要求
通过使用不同的算法来实现进程调度，运用优先级调度的时间片轮转算法、先后顺序的时间片轮转调度算法和先来先服务算法来模拟进程调度的过程，加深对进程概念和进程调度过程的理解。

在Linux下用C语言编程模拟优先级和时间片轮转进程调度算法。

为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程情况显示出来。

二、实验仪器或设备
配有linux操作系统的微型计算机一台
三、总体设计（设计原理、设计方案及流程等）
首先，用交互式的过程来动态模拟进程的调度过程。

通过输入数字来按特定的算法模拟处理机调度过程。

输入1时，按优先级调度的时间片轮转算法模拟进程调度；输入2时，按先后顺序的时间片轮转调度算法模拟进程调度；输入3时，按先来先服务算法模拟进程调度；输入4时，退出程序；输入其他数字时，会显示信息“YOU HAVE NOT CHOOSE ANY ALGORITHM!”并退出程序。

其次，为进程的信息存放和进程的状态设置必要的数据结构来存放。

进程的信息包括进程名、已经执行的cpu时间、还需要的cpu时间、进程所处的状态和在进程队列中指向此进程的下一个进程的指针。

这些是上述三个算法都要用到的。

还有一些信息是某个算法所特有的，如优先级时间片轮转算法需要用到进程优先级，先后顺序的时间片轮转需要用到得到执行的时间片的个数（有的是2个cpu为一个时间片，有的是1个cpu为一个时间片），先来先服务的算法需要用到进程到来时间。

特别说明，为了便于描述进程所处的状态，将进程的状态用枚举类型来存放。

最后，执行合适的算法来实现基础调度过程。

四、实验步骤（包括主要步骤、代码分析等）
实验分4次完成
第1次：完成程序的主框架设计，进行调试，验证其正确性；）
第2次：详细设计，进行调试，验证其正确性；
第3次：进行整体调试；
第4次：验证其设计的正确性，完成实验报告。

代码分析：
#include <stdio.h>
#include <stdlib.h>
#define P_NUM 5
#define P_TIME 50
enum state{
ready, // 准备好
execute,//执行
block,//阻塞
finish//结束
};
struct pcbb{
char name[4];
int cometime; //进程到来时间
int priority; //数越大优先级越高
int cputime; //已占用CPU的时间，也就是该处理机开始工作的时间
int needtime; //执行时间
int count; //得到的时间片的次数
enum state process;
struct pcbb *next;
} ;
typedef struct pcbb pcb;
void display_menu(){
printf("CHOOSE THE ALGORITHM:\n");
printf("1 PRIORITY\n");
printf("2 ROUNDROBIN\n");
printf("3 FIRST COME FISET SERVER\n");
printf("4 EXIT\n");
}
pcb* get_process(){//输入各个进程，并组合成链队列处理,返回队头指针pcb *q;int i = 0;
pcb *p; //队头指针
pcb *t; //队尾指针
printf("input name and time\n");
while (i < P_NUM){
q=(pcb *)malloc(sizeof(pcb));
scanf("%s",q->name);
scanf("%d",&q->needtime);
q->cputime = 0; //cputime初始化为0
q->priority = P_TIME - q->needtime;//所需要的时间越少优先级越高
q->process = ready;//process的状态初始化为ready
q->next = NULL;
if(i==0){ //队列中的第一个
p = q;
t = q;//队尾指针也要处理
}
else{//插入到队列尾
t->next = q;
t = q;
}
i++;
}
return p;
}
void free_process(pcb *p){
pcb *q;
while(p!= NULL){//队列不空时，处理队头
q = p;
p = p->next;
free(q);
}
}
void display(pcb *p){
printf("name cputime needtime priority state\n");
while(p){
printf("%s",p->name);
printf(" ");
printf("%d",p->cputime);
printf(" ");
printf("%d",p->needtime);
printf(" ");
printf("%d",p->priority);
printf(" ");
switch(p->process){
case ready:printf("ready\n");break;
case execute:printf("execute\n"); break;
case block:printf("block\n"); break;
case finish:printf("finish\n"); break;
}
p = p->next;
}
}
int process_finish(pcb *q){//判断队列中有没有进程，没有返回1，有返回0 int b = 1;
while(q){
b=b&&q->needtime==0;
q=q->next;
}
return b;
}
void cpuexe(pcb *q){//cputime指已经执行的时间，needtime指还需要的时间pcb *tr = q;
int tp = 0;
while(q){
if (q->process!=finish){//时间片到，修改上次执行的进程的状态q->process = ready;
if(q->needtime==0){
q->process = finish;
}
}
if(tp<q->priority&&q->process!=finish){
//让tr指向优先级最高的未完成的进程
tp = q->priority;
tr = q;
}
q = q->next;
}
if(tr->needtime!=0){//执行tr所指向的进程
tr->priority -=3; //每执行一次优先级降低三个单位
tr->needtime --;//进程还需要的时间减去1
tr->process = execute;//状态为执行
tr->cputime++;//进程的已经执行的时间加上1
}
}
void priority_cal(){
pcb *p;int cpu;
p = get_process();//输入各个进程，并组合成链队列处理,返回队头指针printf("输出各个进程的初始化信息：\n");
display(p);
cpu = 0;//表示当前执行的cpu时间
while(!process_finish(p)){ //就绪队列中还有进程
cpu++;
printf("cputime:%d\n",cpu);
cpuexe(p); //选择优先级最高的进程执行一个时间单位
display(p); //每调度一次就显示次
sleep(2);
}
free_process(p); //释放所有进程
printf("All processes have finished\n");
}
pcb *get_process_round(){
pcb *q;
pcb *p; //头指针
pcb *t; //尾指针
int i = 0;
printf("input name and time\n");
while (i<P_NUM){
q=(pcb *)malloc(sizeof(pcb));
scanf("%s",q->name);
scanf("%d",&q->needtime);
q->cputime = 0;
q->count = 0;
q->process = ready;
q->next = NULL;
if(i==0){
p = q;
t = q;
}
else{
t->next = q;
t = q;
}
i++;
}
return p;
}
void cpu_round(pcb *q){
if(q->needtime==1)
q->cputime++;
else
q->cputime +=2;
q->needtime -=2;
if(q->needtime<0){
q->needtime = 0;
}
q->count++;
q->process = execute;
}
pcb *get_next(pcb *k,pcb *head){
pcb *t;
t = k;
do{
t =t->next;
}while ( t && t->process == finish);
if(t == NULL){
t = head;
//k是刚刚被执行的节点,如果t->next=k,所明就绪队列除了k和t以外都
//已结束,按照时间片轮转算法,该t执行
while(t->next!=k && t->process == finish){
t = t->next;
}
}
return t;
}
void set_state(pcb *p){
pcb *q;
q=p;
while(q){
if(q->needtime == 0){
q->process = finish;
}
if(q->process == execute){
q->process = ready;
}
q = q->next;
}
}
void display_round(pcb *p){//显示各个进程的信息
pcb *q;
q=p;
printf("name cputime needtime count state\n");
while(q){
printf("%s",q->name);
printf(" ");
printf("%d",q->cputime);
printf(" ");
printf("%d",q->needtime);
printf(" ");
printf("%d",q->count);
printf(" ");
switch(q->process){
case ready:printf("ready\n");break;
case execute:printf("execute\n"); break;
case block:printf("block\n"); break;
case finish:printf("finish\n"); break;
}
q = q->next;
}
}
void round_cal(){
pcb *p;
pcb *r;int cpu;
p = get_process_round();//输入各个进程，并组成链队列,返回队头指针printf("输出各个进程的初始化信息：\n");
display_round(p);
cpu = 0;
r=p;
while(!process_finish(p)){ //就绪队列中还有进程
if(r->needtime==1)
cpu+=1;
else //如果需要的时间长度大于等于2
cpu+=2; //时间片长度是2
cpu_round(r);
r = get_next(r,p); //获得下一个需要执行的进程
printf("cputime:%d\n",cpu);
display_round(p); //每调度一次就显示次
set_state(p);
sleep(2);
}
free_process(p); //释放所有进程
printf("All processes have finished\n");
}
pcb* get_process_fcfs(){//输入各个进程，并组成链队列处理,返回队头指针pcb *q,*r,*f;int i = 0;
pcb *p; //队头指针
pcb *t; //队尾指针
printf("input name 、cometime and needtime\n");
while (i < P_NUM)
{
q=(pcb *)malloc(sizeof(pcb));
scanf("%s",q->name);
scanf("%d",&q->cometime);
scanf("%d",&q->needtime);
q->cputime = 0; //cputime初始化为0
q->process = ready;//process的状态初始化为ready
q->next = NULL;
if(i==0)
{ //队列中的第一个
printf("队列中的第一个\n");
p = q;
t = q;//队尾指针也要处理
}
else
{
if (q->cometime >= t->cometime)
{//插到队列尾
t->next = q;
t = q;
}
else
{//从队头开始扫描
if (p->cometime > q->cometime)
{
q->next=p;
p=q;
}
else
{
r=p;
f=r;
while(r)
{
if (r->cometime <= q->cometime)
{
f=r;
r=r->next;
}
else
{// 插入到r前面
q->next=r;
f->next=q;
break;
}
}
}
}
}
i++;
}
return p;
}
void display_fcfs(pcb *p,int cpu){//显示各个进程的信息
pcb *q;
q=p;
printf("name cputime needtime cometime state\n");
while(q&&cpu>=q->cometime){
printf("%s",q->name);
printf(" ");
printf("%d",q->cputime);
printf(" ");
printf("%d",q->needtime);
printf(" ");
printf("%d",q->cometime);
printf(" ");
switch(q->process){
case ready:printf("ready\n");break;
case execute:printf("execute\n"); break;
case block:printf("block\n"); break;
case finish:printf("finish\n"); break;
}
q = q->next;
}
}
void fcfs_cal(){
pcb *p;
pcb *r;
int cpu;
int cpufree;
p = get_process_fcfs();//输入各个进程，并组成链队列,返回队头指针printf("输出各个进程的初始化信息：\n");
display_fcfs(p,100);
cpu = 0;
r=p;
while(r&&r->process!=finish){ //就绪队列中还有进程
cpufree=0;
if (cpu<=r->cometime) {//cpu空闲
cpufree=r->cometime-cpu;
cpu=r->cometime+r->needtime;
}
else{
cpu=cpu+r->needtime;
}
r->cputime=r->needtime;
r->needtime=0;
r->process = execute;
printf("cputime:%d cpufree:%d\n",cpu,cpufree);
display_fcfs(p,cpu); //每调度一次就显示次
set_state(p);
r=r->next;
sleep(2);
}
free_process(p); //释放所有进程
printf("All processes have finished\n");
}
int main(){
int k;
display_menu();
scanf("%d",&k);
switch(k){
case 1:priority_cal();break;//按优先级的时间片轮转
case 2:round_cal();break;//按先后顺序的有条件的时间片轮转
case 3:fcfs_cal();break;//按先来先服务执行算法
case 4:printf("退出！\n");break;
default:printf("YOU HAVE NOT CHOOSE ANY ALGORITHM!\n");
}
}
五、结果分析与总结
结果与分析：
结果1：
CHOOSE THE ALGORITHM:
1 PRIORITY
2 ROUNDROBIN
3 FIRST COME FISET SERVER
4 EXIT
1
input name and time
a 3
b 2
c 1
d 5
e 4
输出各个进程的初始化信息：
name cputime needtime priority state
a 0 3 47 ready
b 0 2 48 ready
c 0 1 49 ready
d 0 5 45 ready
e 0 4 46 ready
cputime:1
name cputime needtime priority state
a 0 3 47 ready
b 0 2 48 ready
c 1 0 46 execute
d 0 5 45 ready
e 0 4 46 ready
cputime:2
name cputime needtime priority state
a 0 3 47 ready
b 1 1 45 execute
c 1 0 46 finish
d 0 5 45 ready
e 0 4 46 ready cputime:3
name cputime needtime priority state
a 1 2 44 execute
b 1 1 45 ready
c 1 0 46 finish
d 0 5 45 ready
e 0 4 46 ready cputime:4
name cputime needtime priority state
a 1 2 44 ready
b 1 1 45 ready
c 1 0 46 finish
d 0 5 45 ready
e 1 3 43 execute cputime:5
name cputime needtime priority state
a 1 2 44 ready B 2 0 42 execute
c 1 0 46 finish
d 0 5 45 ready
e 1 3 43 ready cputime:6
name cputime needtime priority state
a 1 2 44 ready
b 2 0 42 finish
c 1 0 46 finish
d 1 4 42 execute
e 1 3 43 ready cputime:7
name cputime needtime priority state
a 2 1 41 execute
b 2 0 42 finish
c 1 0 46 finish
d 1 4 42 ready
e 1 3 43 ready cputime:8
name cputime needtime priority state
b 2 0 42 finish
c 1 0 46 finish
d 1 4 42 ready
e 2 2 40 execute cputime:9
name cputime needtime priority state
a 2 1 41 ready
b 2 0 42 finish
c 1 0 46 finish
d 2 3 39 execute
e 2 2 40 ready cputime:10
name cputime needtime priority state
a 3 0 38 execute
b 2 0 42 finish
c 1 0 46 finish
d 2 3 39 ready
e 2 2 40 ready cputime:11
name cputime needtime priority state
a 3 0 38 finish
b 2 0 42 finish
c 1 0 46 finish
d 2 3 39 ready
e 3 1 37 execute cputime:12
name cputime needtime priority state
a 3 0 38 finish
b 2 0 42 finish
c 1 0 46 finish
d 3 2 36 execute
e 3 1 37 ready cputime:13
name cputime needtime priority state
a 3 0 38 finish
b 2 0 42 finish
c 1 0 46 finish
d 3 2 36 ready
e 4 0 34 execute cputime:14
name cputime needtime priority state
a 3 0 38 finish
b 2 0 42 finish
d 4 1 33 execute
e 4 0 34 finish
cputime:15
name cputime needtime priority state
a 3 0 38 finish
b 2 0 42 finish
c 1 0 46 finish
d 5 0 30 execute
e 4 0 34 finish
All processes have finished
进程调度的时间片轮转顺序为：c b a e b d a e d a e d e d d,可以看出进程c结束时间为cpu=1时，进程b结束时间为cpu=5时，进程a结束时间为cpu=10时，进程e结束时间为cpu=13时，进程d结束时间为cpu=15时。

结果2：
CHOOSE THE ALGORITHM:
1 PRIORITY
2 ROUNDROBIN
3 FIRST COME FISET SERVER
4 EXIT
2
input name and time
a 3
b 2
c 1
d 5
e 4
输出各个进程的初始化信息：
name cputime needtime count state
a 0 3 0 ready
b 0 2 0 ready
c 0 1 0 ready
d 0 5 0 ready
e 0 4 0 ready
cputime:2
name cputime needtime count state
a 2 1 1 execute
b 0 2 0 ready
c 0 1 0 ready
d 0 5 0 ready
e 0 4 0 ready
cputime:4
name cputime needtime count state
a 2 1 1 ready
b 2 0 1 execute
c 0 1 0 ready
d 0 5 0 ready
e 0 4 0 ready cputime:5
name cputime needtime count state
a 2 1 1 ready
b 2 0 1 finish
c 1 0 1 execute
d 0 5 0 ready
e 0 4 0 ready cputime:7
name cputime needtime count state
a 2 1 1 ready
b 2 0 1 finish
c 1 0 1 finish
d 2 3 1 execute
e 0 4 0 ready cputime:9
name cputime needtime count state
a 2 1 1 ready
b 2 0 1 finish
c 1 0 1 finish
d 2 3 1 ready
e 2 2 1 execute cputime:10
name cputime needtime count state
a 3 0 2 execute
b 2 0 1 finish
c 1 0 1 finish
d 2 3 1 ready
e 2 2 1 ready cputime:12
name cputime needtime count state
a 3 0 2 finish
b 2 0 1 finish
c 1 0 1 finish
d 4 1 2 execute
e 2 2 1 ready cputime:14
name cputime needtime count state
a 3 0 2 finish
b 2 0 1 finish
c 1 0 1 finish
d 4 1 2 ready
e 4 0 2 execute
cputime:15
name cputime needtime count state
a 3 0 2 finish
b 2 0 1 finish
c 1 0 1 finish
d 5 0 3 execute
e 4 0 2 finish
All processes have finished
进程调度的执行顺序为：a b c d e a d e d,可以看出进程b结束时间为cpu=4时，进程c结束时间为cpu=5时，进程a结束时间为cpu=10时，进程e结束时间为cpu=14时，进程d结束时间为cpu=15时。

结果3：
CHOOSE THE ALGORITHM:
1 PRIORITY
2 ROUNDROBIN
3 FIRST COME FISET SERVER
4 EXIT
3
input name 、cometime and needtime
a 1 4
b 7 3
c 5 2
d 0 3
e 15 1
队列中的第一个
输出各个进程的初始化信息：
name cputime needtime cometime state
d 0 3 0 ready
a 0 4 1 ready
c 0 2 5 ready
b 0 3 7 ready
e 0 1 15 ready
cputime:3 cpufree:0
name cputime needtime cometime state
d 3 0 0 execute
a 0 4 1 ready
cputime:7 cpufree:0
name cputime needtime cometime state
d 3 0 0 finish
a 4 0 1 execute
c 0 2 5 ready
b 0 3 7 ready
cputime:9 cpufree:0
name cputime needtime cometime state
d 3 0 0 finish
a 4 0 1 finish
c 2 0 5 execute
b 0 3 7 ready
cputime:12 cpufree:0
name cputime needtime cometime state
d 3 0 0 finish
a 4 0 1 finish
c 2 0 5 finish
b 3 0 7 execute
cputime:16 cpufree:3
name cputime needtime cometime state
d 3 0 0 finish
a 4 0 1 finish
c 2 0 5 finish
b 3 0 7 finish
e 1 0 15 execute
All processes have finished
进程调度的执行顺序为：d a c b e,可以看出进程d结束时间为cpu=3时，进程a结束时间为cpu=7时，进程c结束时间为cpu=9时，进程b结束时间为cpu=12时，进程e结束时间为cpu=16时。

其他结果：
CHOOSE THE ALGORITHM:
1 PRIORITY
2 ROUNDROBIN
3 FIRST COME FISET SERVER
4 EXIT
4
退出！
CHOOSE THE ALGORITHM:
1 PRIORITY
2 ROUNDROBIN
3 FIRST COME FISET SERVER
4 EXIT
6
YOU HAVE NOT CHOOSE ANY ALGORITHM!
总结：
通过本次实验，我对进程调度算法的相关知识有了更加深刻的理解和掌握，明白了先到先服务、时间片轮转算法以及优先级调度算法的执行过程，使得所学知识不仅仅停留在课本理论知识的层次，而是上升为现实实践的层次。

教师签名：
年月日。