操作系统实验一进程调度模拟算法.doc

操作系统实验一进程调度模拟算法

———————————————————————————————— 作者：
———————————————————————————————— 日期：

12

个人收集整理 勿做商业用途

课程名称 操作系统 计算机科学与技术 分院 信1001—2 班 组 学号
实验者姓名 实验日期 2013 年 4 月 11 日
评分 教师签名
实验一 进程调度模拟算法

一、 实验目的
通过进程调度实验，了解了优先数算法和时间片轮转算法的具体实施办法，体会了优先数算法和时间片轮转算法进程调度的过程，掌握了有关进程控制快、进程队列等概念，提高了编程技巧和对算法的理解和掌握。
二、 实验要求
进程调度是处理机管理的核心内容，本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念。
三、 实验过程
1． 准备
分别用两种调度算法对伍个进程进行调度。每个进程可有三种状态；执行状态（RUN）、就绪状态（READY,包括等待状态）和完成状态（FINISH)，并假定初始状态为就绪状态。
进程控制块结构如下：
NAME--进程标示符
PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2）
CPUTIME——进程累计占用CPU的时间片数
NEEDTIME—-进程到完成还需要的时间片数
STATE——进程状态
NEXT——链指针
进程的就绪态和等待态均为链表结构，共有四个指针如下：
RUN-—当前运行进程指针
READY——就需队列头指针
TAIL—- 就需队列尾指针
FINISH-— 完成队列头指针
运行和显示
程序开始运行后，首先提示：请用户选择算法，输入进程名和相应的NEEDTIME值.
每次显示结果均为如下5个字段：
name cputime needtime priority state
注：
1．在state字段中，”R"代表执行态,”W"代表就绪（等待）态，”F”代表完成态.
2．应先显示"R"态的，再显示”W”态的，再显示”F"态的。
3．在”W”态中，以优先数高低或轮转顺序排队；在"F”态中，以完成先后顺序排队。

2。主要流程和源代码
实验一源代码
#include
＃include
＃include
typedef struct node
｛
char name［10］；
int prio;
int round;
int cputime；
int needtime；
int count；
char state；
struct node *next;
}PCB;

PCB ＊finish，*ready,*tail，＊run；
int N;
void firstin（void);
void print1(char a)；
void print2（char chose，PCB *p）；
void print（char chose);
void insert_prio(PCB ＊q）
void prior_init（char chose）;
void priority(char chose);
void insert_rr(PCB ＊q)；
void roundrun_init(char chose）；
void roundrun(char chose）;

void main()//主函数
{
char chose=' '；
while（(chose!=’q'）&&（chose！='Q')）
｛
fflush（stdin）;
printf("选择进程优先级算法请输入P，选择循环轮转算法请输入R，退出请输入Q\n"）;
printf（”请输入你的选择："）;
scanf("%c",&chose);
if（（chose！=’q')&＆（chose！=’Q’）)
{
system("cls”）;
if((chose=='P'）｜｜（chose=='p’））
｛

prior_init(chose）;
priority(chose)；
system（”cls")；
｝
else if（（chose==’r'）｜|（chose==’R'））
{

roundrun_init(chose）；
roundrun(chose）；
system（”cls"）;
}
｝
｝
printf（”谢谢使用!\n”)；
｝

void firstin（void)
｛
if(ready!=NULL)
{
run=ready;
ready=ready—>next;
run—>state='R'；
run-〉next=NULL；
｝
else
｛
run=NULL;
｝
｝

void print1（char a）
{
if（toupper(a)=='P’）
{
printf("name cputime needtime priority state \n”)；
｝
else
{
printf(”name cputime needtime count round state \n"）；
}
}

void print2（char chose,PCB ＊p)
｛
if（toupper（chose)==’P')
｛
printf（"％s\t％d\t%d\t％d\t%c\n”，p—〉name，p-〉cputime,p—>needtime,p-〉prio,p-〉state）；
｝
else
｛
printf（”%s\t％d\t%d\t%d\t％d\t％c\n”,p-〉name，p->cputime,p->needtime，p->count,p->round，p—〉state)；
}
｝
void print(char chose）
{
PCB ＊p；
print1(chose）；
if(run！=NULL)
｛
print2（chose,run）;
｝
p=ready;
while（p!=NULL）
{
print2（chose，p);
p=p->next;
}
p=finish;
while（p！=NULL）
{
print2（chose，p);
p=p—〉next;
｝
}
void insert_prio（PCB ＊q)
{
PCB *p,＊s,*r;
s=q;
p=ready；
r=p；
if（s—〉prio>ready—〉prio）// ｛
s->next=ready;
ready=s;
}
else
{
while（p）
｛
if（p->prio>=s->prio）
{
r=p；
p=p—>next;
｝
else
break;
} s—>next=p;
r-〉next=s；
｝
｝

void prior_init(char chose)
｛
PCB *p；
int i，time;
char na［10］;
ready=NULL;
finish=NULL；
run=NULL；
printf("输入进程 的个数 N：\n”);
scanf（”%d”,＆N);
for(i=0；iCB)）;
printf(”输入第%d个进程名\n”,i+1)；
scanf（"%s",na）；
printf（"完成进程需要的时间片数\n");
scanf(”％d”，&time）；
strcpy(p-〉name,na）；
p-〉cputime=0；
p—〉needtime=time；
p->state=’W';
p-〉prio=50-time；
if(ready==NULL)
｛
ready=p；
ready->next=NULL;
｝
else
｛
insert_prio（p）;
｝
printf(”当前就绪队列的进程的信息\n"）;
print（chose）;
}
printf("％d个进程已按优先级从高到低进到就绪队列中\n”，N）;
printf（”按回车键开始模拟优先级算法.。。..\n")；
fflush（stdin）;
getchar(）；
firstin();
｝
void priority（char chose）
｛
int i=1；
while（run！=NULL)
{
run-〉cputime+=1；
run—>needtime-=1;
run->prio—=1;
if（run->needtime==0)
｛

run—〉next=finish；
finish=run；
run-〉state='F’；
run—>prio=0；
run=NULL；
firstin（）；
｝
else
{
if（（ready！=NULL）&&（run-〉prioprio)）
{
run->state=’W';
insert_prio（run)；
run=NULL；
firstin（）；
｝
}
print（chose）;
｝
getchar)；
｝
void insert_rr(PCB ＊q)
{
tail->next=q;
tail=q；
q-〉next=NULL；
｝
void roundrun_init(char chose）
｛
PCB *p；
int i，time；
char na[10]；
ready=NULL；
finish=NULL;
run=NULL；
printf（”\t\t循环轮转算法模拟全过程\n\n"）；
printf(”输入进程 的个数 N:\n"）;
scanf(”％d”,＆N);
for（i=0；i〈N;i++)
｛
p=（PCB＊）malloc（sizeof（PCB)）；
printf（"输入第%d个进程名\n”,i+1）；
scanf(”%s”,na）；
printf（"完成进程需要的时间片数\n”)；
scanf(”％d”，&time);
strcpy（p—>name,na);
p—>cputime=0；
p-〉needtime=time；
p—>count=0；
p->state='W’；
p->round=2；
if(ready!=NULL)
｛
insert_rr(p)；
｝
else
{
p—〉next=ready；
ready=p;

tail=p；
}
printf("当前就绪队列的进程的信息\n”）；
print(chose);
}
printf（”%d个进程已按FIFO进到就绪队列中\n”,N）;
printf（”按回车键开始模循环轮转算法.。。..\n"）;
fflush(stdin）;
getchar（）;
run=ready;
ready=ready—>next;
run—〉state=’R'；

}
void roundrun（char chose）
{
int i=1;
while（run！=NULL）
｛
run—>cputime+=1；
run-〉needtime-=1；
run-〉count+=1;
if（run—>needtime==0)
｛
run—〉next=finish;
finish=run;
run—〉state=’F’；
run->prio=0；
run=NULL;
if（ready！=NULL)
｛
firstin（);
｝
}
else
{
if(run-〉count==run—>round）
{
run->count=0；
if（ready!=NULL）
｛
run—〉state='W';
insert_rr（run）；
firstin（）;
｝
}
｝
print(chose）；
}
getchar(）；
｝
四、 实验结果

五、 实验总结
通过本次试验，可以更加清楚的了解时间片轮转的原理。主要是利用时间片的轮转使得每个进程都可以得到一部分时间的执行段。这样可以保证计算机能过在较短的时间内对用户的要求尽量做到都能满足到。
了解完原理，就是动手实践的时候。在网上下载几个代码，进行调试，运行、查看结果。最终选择一个比较简单易懂的代码进行实验.看懂代码和结果后，这次实验也算是成功的一大半了。
做完实验,首先想到的是这个方法的思想。以及他和其它调度算法的区别,比如先来先服务和短作业（进程）优先调度算法.以及它的优势和劣势。优点是能够在给定的时间内响应所有用户的要求，缺点是时间片大小的确定是一件非常麻烦的事情，如果使用不当的话，可能会造成一些麻烦.比如,过长的话，进程在一个时间片内都执行完，响应时间比较长。过短的话,用户的一次请求需要多个时间片才能处理完，上下文切换次数增加，响应时间一样会比较长。
总之这次实验还是让我收获很大，让我在书本上的知识能够运用到实际当中。这种学以致用的感觉才是最好的。