操作系统实验报告进程调度zzp.docx
《操作系统实验报告进程调度zzp.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告进程调度zzp.docx（18页珍藏版）》请在冰豆网上搜索。
操作系统实验报告进程调度zzp
沈阳工程学院
学生实验报告
实验室名称：
计算机实验室实验课程名称：
操作系统
实验项目名称：
进程调度实验日期：
2016年月日
班级：
物联网151姓名：
学号：
指导教师：
曲乐声刘琪批阅教师：
成绩：
一．实验目的
本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解基于时间片轮转调度算法的具体实施办法。
二．实验设备
PC机一台，WIN-TC软件。
三．实验项目
（1）设计进程控制块PCB的结构，通常应包括如下信息：
进程名、或轮转时间片数、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、进程优先级、当前队列指针等
（ 2）编写调度算法程序：
时间片轮转、优先级调度算法程序
（3）按要求输出结果。
（附图）
四．根据实验写结果
1.时间片轮转
时间片大小
进程名
A
B
C
D
E
平均
q=4
到达时间
0
1
2
3
4
服务时间
2
3
4
5
6
完成时间
2
5
9
15
22
周转时间
2
4
7
12
18
8.6
带权周转时间
1
1.3
1.75
2.4
3
1.89
2.优先级
时间片大小
进程名
A
B
C
D
E
平均
q=4
到达时间
0
1
2
3
4
服务时间
2
3
4
5
6
优先数
1
2
3
4
5
完成时间
2
11
13
18
20
周转时间
2
10
11
15
16
10.8
带权周转时间
1
3.3
2.75
3
2.6
2.5
四．实验程序代码（附页）
成绩评定
算法正确性
2.5
2
1.5
1
0.5
0
程序正确性
2.5
2
1.5
1
0.5
0
结果及分析的正确性
5
4
3
2
1
0
成绩
时间片轮转
#include
#include
#include
typedef struct node
{
char name[20]; /*进程的名字*/
int prio; /*进程的优先级*/
int round; /*分配CPU的时间片*/
int cputime; /*CPU执行时间*/
int needtime; /*进程执行所需要的时间*/
char state; /*进程的状态，W——就绪态，R——执行态，F——完成态*/
int count; /*记录执行的次数*/
struct node *next; /*链表指针*/
}PCB;
PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/
int num;
void GetFirst（）; /*从就绪队列取得第一个节点*/
void Output（）; /*输出队列信息*/
void InsertPrio（PCB *in）; /*创建优先级队列，规定优先数越小，优先级越高*/
void InsertTime（PCB *in）; /*时间片队列*/
void InsertFinish（PCB *in）; /*时间片队列*/
void PrioCreate（）; /*优先级输入函数*/
void TimeCreate（）; /*时间片输入函数*/
void Priority（）; /*按照优先级调度*/
void RoundRun（）; /*时间片轮转调度*/
int main（void）
{
char chose;
printf（"输入进程名及其需要运行的时间\n"）;
scanf（"%d",&num）;
getchar（）;
printf（"Schedulingmethodforinputprocess:
（P/R）\n"）;
scanf（"%c",&chose）;
switch（chose）
{
case 'P':
case 'p':
PrioCreate（）;
Priority（）;
break;
case 'R':
case 'r':
TimeCreate（）;
RoundRun（）;
break;
default:
break;
}
Output（）;
return 0;
}
void GetFirst（） /*取得第一个就绪队列节点*/
{
run = ready;
if（ready!
=NULL）
{
run ->state = 'R';
ready = ready ->next;
run ->next = NULL;
}
}
void Output（） /*输出队列信息*/
{
PCB *p;
p = ready;
printf（"进程名\tpriority\tnumber\tcputime\ttimeyouneed\tprocessstate\tcounter\n"）;
while（p!
=NULL）
{
printf（"%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count）;
p = p->next;
}
p = finish;
while（p!
=NULL）
{
printf（"%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count）;
p = p->next;
}
p = run;
while（p!
=NULL）
{
printf（"%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count）;
p = p->next;
}
}
void InsertPrio（PCB *in） /*创建优先级队列，规定优先数越小，优先级越低*/
{
PCB *fst,*nxt;
fst = nxt = ready;
if（ready == NULL） /*如果队列为空，则为第一个元素*/
{
in->next = ready;
ready = in;
}
else /*查到合适的位置进行插入*/
{
if（in ->prio >= fst ->prio） /*比第一个还要大，则插入到队头*/
{
in->next = ready;
ready = in;
}
else
{
while（fst->next !
= NULL） /*移动指针查找第一个别它小的元素的位置进行插入*/
{
nxt = fst;
fst = fst->next;
}
if（fst ->next == NULL） /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/
{
in ->next = fst ->next;
fst ->next = in;
}
else /*插入到队列中*/
{
nxt = in;
in ->next = fst;
}
}
}
}
void InsertTime（PCB *in） /*将进程插入到就绪队列尾部*/
{
PCB *fst;
fst = ready;
if（ready == NULL）
{
in->next = ready;
ready = in;
}
else
{
while（fst->next !
= NULL）
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void InsertFinish（PCB *in） /*将进程插入到完成队列尾部*/
{
PCB *fst;
fst = finish;
if（finish == NULL）
{
in->next = finish;
finish = in;
}
else
{
while（fst->next !
= NULL）
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void PrioCreate（） /*优先级调度输入函数*/
{
PCB *tmp;
int i;
printf（"Entertheprocessnameandprocesstimerequired:
\n"）;
for（i = 0;i < num; i++）
{
if（（tmp = （PCB *）malloc（sizeof（PCB）））==NULL）
{
perror（"malloc"）;
exit
（1）;
}
scanf（"%s",tmp->name）;
getchar（）; /*吸收回车符号*/
scanf（"%d",&（tmp->needtime））;
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/
tmp ->round = 0;
tmp ->count = 0;
InsertPrio（tmp）; /*按照优先级从高到低，插入到就绪队列*/
}
}
void TimeCreate（） /*时间片输入函数*/
{
PCB *tmp;
int i;
printf（"Entertheprocessnameandthetimerequiredfortheprocesstimeslice:
\n"）;
for（i = 0;i < num; i++）
{
if（（tmp = （PCB *）malloc（sizeof（PCB）））==NULL）
{
perror（"malloc"）;
exit
（1）;
}
scanf（"%s",tmp->name）;
getchar（）;
scanf（"%d",&（tmp->needtime））;
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 0;
tmp ->round = 2; /*假设每个进程所分配的时间片是2*/
tmp ->count = 0;
InsertTime（tmp）;
}
}
void Priority（） /*按照优先级调度，每次执行一个时间片*/
{
int flag = 1;
GetFirst（）;
while（run !
= NULL） /*当就绪队列不为空时，则调度进程如执行队列执行*/
{
Output（）; /*输出每次调度过程中各个节点的状态*/
while（flag）
{
run->prio -= 3; /*优先级减去三*/
run->cputime++; /*CPU时间片加一*/
run->needtime--;/*进程执行完成的剩余时间减一*/
if（run->needtime == 0）/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/
{
run ->state = 'F';
run->count++; /*进程执行的次数加一*/
InsertFinish（run）;
flag = 0;
}
else /*将进程状态置为W，入就绪队列*/
{
run->state = 'W';
run->count++; /*进程执行的次数加一*/
InsertTime（run）;
flag = 0;
}
}
flag = 1;
GetFirst（）; /*继续取就绪队列队头进程进入执行队列*/
}
}
void RoundRun（） /*时间片轮转调度算法*/
{
int flag = 1;
GetFirst（）;
while（run !
= NULL）
{
Output（）;
while（flag）
{
run->count++;
run->cputime++;
run->needtime--;
if（run->needtime == 0） /*进程执行完毕*/
{
run ->state = 'F';
InsertFinish（run）;
flag = 0;
}
else if（run->count == run->round）/*时间片用完*/
{
run->state = 'W';
run->count = 0; /*计数器清零，为下次做准备*/
InsertTime（run）;
flag = 0;
}
}
flag = 1;
GetFirst（）;
}
}
优先级
#include
#include
#include
#definegetpch（type）（type*）malloc（sizeof（type））
#defineNULL0
structpcb{
charname[10];
charstate;
intsuper;
intntime;
intrtime;
structpcb*link;
}*ready=NULL,*p;
typedefstructpcbPCB;
voidsort（）
{
PCB*first,*second;
intinsert=0;
if（（ready==NULL）||（（p->super）>（ready->super）））
{
p->link=ready;
ready=p;
}
else/*进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->link;
while（second!
=NULL）
{
if（（p->super）>（second->super））/*若插入进程比当前进程优先数大*/
{/*插入到当前进程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else/*插入进程优先数最低,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if（insert==0）first->link=p;
}
}
voidinput（）/*建立进程控制块函数*/
{
inti,num;
system（"cls"）;/*清屏*/
printf（"\nprintthenumberoftheprocess:
"）;
scanf（"%d",&num）;
for（i=1;i<=num;i++）
{
printf（"\nprocessNo.%d:
\n",i）;
p=getpch（PCB）;
printf（"\nprintthenameofprocess:
"）;
scanf（"%s",p->name）;
printf（"\nprintthepriority:
"）;
scanf（"%d",&p->super）;
printf（"\nprintthetimeofprocess:
"）;
scanf（"%d",&p->ntime）;
printf（"\n"）;
p->rtime=0;p->state='W';
p->link=NULL;
sort（）;/*调用sort函数*/
}
}
intspace（）
{
intl=0;
PCB*pr=ready;
while（pr!
=NULL）
{
l++;
pr=pr->link;
}
return（l）;
}
voiddisp（PCB*pr）/*建立进程显示函数,用于显示当前进程*/
{
printf（"\nprocessname\tstate\tpriority\tneedtime\truntime\n"）;
printf（"|%s\t",pr->name）;
printf（"|%c\t",pr->state）;
printf（"|%d\t",pr->super）;
printf（"|%d\t\t",pr->ntime）;
printf（"|%d\t",pr->rtime）;
printf（"\n"）;
}
voidcheck（）/*建立进程查看函数*/
{
PCB*pr;
printf（"\n****theprocessisrunning:
\n"）;/*显示当前运行进程*/
disp（p）;
pr=ready;
printf（"\n****thestate:
\n"）;/*显示就绪队列状态*/
while（pr!
=NULL）
{
disp（pr）;
pr=pr->link;
}
}
voiddestro
升级会员 