模拟进程管理文档格式.docx

模拟进程管理文档格式.docx

《模拟进程管理文档格式.docx》由会员分享，可在线阅读，更多相关《模拟进程管理文档格式.docx（24页珍藏版）》请在冰豆网上搜索。

（5）概要设计

（6）详细设计（含主要代码）

（7）调试分析、测试结果

（8）用户使用说明

（9）附录或参考资料

五、课程设计工作量

由于是设计小组团结协作完成设计任务，一般每人的程序量在100行有效程序行左右，不得抄袭。

六、课程设计工作计划

设计在学期的第15、16周进行，时间安排如下：

序号

内容

时间（天）

1

预习、讲课

2

设计

3

编码、测试

5

4

验收

合计

10

指导教师签章：

教研室主任签章：

操作系统课程设计指导教师评语与成绩

指导教师评语：

课程设计表现成绩：

课程设计验收成绩：

课程设计报告成绩：

课程设计总成绩：

指导教师签章

2009年月日

目录

一需求分析6

二概要设计6

三详细设计（含主要代码）6

四调试分析、测试结果12

五用户使用说明14

六后记14

七参考资料14

一需求分析

在多道处理程序运行环境下，进程数目一般多于处理机数目，使得进程要通过竞争来使用处理机。

这就要求系统能按照某种算法，动态地把处理机分配给就绪队列中的一个进程，使之运行，分配处理机的任务是由金城调度程序完成的。

一个进程被创建后，系统为了便于对进程进行管理，将系统中的所有进程按照其状态，将其组成不同的进程队列。

于是系统中有运行进程队列、就绪队列和各种事件的进程等待队列。

进程调度的功能就是从就绪队列中挑选一个进程到处理机上运行。

进程调度的算法有多种，常用的有优先级调度算法、先来先服务算法、时间片轮转算法。

二概要设计

<

一>

最高优先级优先调度算法

动态优先数是指在进程创建时先确定一个初始优先数，以后在进程运行中随着进程特性的改变不断修改优先数，这样，由于开始优先数很低而得不到CPU的进程，就能因为等待时间的增长而优先数变为最高而得到CPU运行。

例如：

在进程获得一次CPU后就将其优先数减少3。

或者，进程等待的时间超过某一时限时增加其优先数的值，等等。

二>

简单轮转法调度算法

所有就绪进程按FCFS排成一个队列，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。

即将CPU的处理时间划分成一个个相同的时间片，就绪队列的诸进程轮流运行一个时间片。

当一个时间片结束时，如果运行进程用完它的时间片后还未完成，就强迫运行机制进程让出CPU，就把它送回到就绪队列的末尾，等待下一次调度。

同时，进程调度又去选择就绪队列中的队首进程，分配给它一时间片，以投入运行。

直至所有的进程运行完毕。

三>

短作业优先调度算法

所有就绪进程按所需时间由少到多排成一个队列，依次运行队列中的进程，并列表显示出来，每个进程的开始运行时间减去进入内存时间就是该进程的等待时间，每个进程的结束运行时间减去进入内存时间就是该进程的周转时间，每个进程的周转时间除于服务时间就是带权周转时间。

三详细设计

一．优先权调度算法：

1、用户可以自行输入进程的数量，每一个进程由进程控制块（PCB）表示，各种队列均采用链表数据结构。

2、进程控制块包含如下信息：

进程号、cpu时间、所需要时间、优先数、状态等等。

3、在每次运行程序时都要输入“进程数量”、“进程名称及占用时间”。

4、按照优先数的高低进行排列

5、处理机调度队首元素运行。

采用动态优先数办法，进程每运行一次优先数减“3”，同时将已运行时间加“1”。

6、进程运行一次后，若要求运行时间不等于已运行时间，则再将它加入就绪队列；

否则将其状态置为“F”,且退出就绪队列。

7、“R”状态的进程队列不为空，则重复上面步骤，直到所有进程都成为“F”状态。

流程图:

图.最高优先级优先调度算法流程图

主要代码：

voidpriority（charalgo）{

PCBq;

prt1（algo）;

for（inti=0;

i<

=Num;

i++）

{

q=pq.top（）;

pq.pop（）;

if（q.state!

=3）

q.state=1;

prt2（algo,q）;

=3）

q.state=2;

q.cputime++;

if（q.needtime>

0）

q.needtime--;

if（q.needtime==0）

q.state=3;

if（q.state!

=3）

q.prio-=3;

pp.push（q）;

while（!

pq.empty（））

{

q=pq.top（）;

pq.pop（）;

if（q.needtime==0）

q.state=3;

prt2（algo,q）;

prt1（algo）;

pp.push（q）;

}

pq=pp;

pp=pqempty;

}

printf（"

**************************************************************************\n"

）;

输出结束\n"

getchar（）;

}

二．时间片轮转算法：

1、用户可以自行输入进程的数量，每一个进程由进程控制块（PCB）表示，各种队列均采用链表数据结构。

2、按照进程输入的先后顺序排成一个队列。

再设一个队首指针指向第一个到达进程的首址。

3、执行处理机调度时，开始选择队首的第一个进程运行。

另外，再设一个当前运行进程的指针，指向当前正在运行的进程。

4、考虑到代码的可重用性,轮转法调度程序和最高优先级优先调度是调用同一个模快进行输出

5、在规定的时间片内进程是根据先来先服务的方式配列的，每个进程只运行时间片大小的时间然后转到下一个进程运行。

直到所有进程运行完为止。

流程图

图.简单轮转法调度算法流程图

voidRoundrun（inttimeSlice）{

while（run!

=NULL）{

run->

cputime=run->

cputime+timeSlice;

needtime=run->

needtime-timeSlice;

round+=timeSlice;

count++;

if（run->

needtime<

=0）{

run->

needtime=0;

next=finish;

finish=run;

if（run!

=tail）{

tail->

next=ready;

}

else{

ready=NULL;

state='

F'

;

run=NULL;

if（ready!

=NULL）{

firstin（）;

}

else{

run->

W'

tail=run;

run=ready;

//就绪队列的头指针赋值给运行

run->

state='

R'

//进程状态变为等待状态

ready=ready->

next;

//就绪队列头指针移到下一个进程

}}

prt（'

r'

}}

三．短作业优先调度算法

1,用户可以自行输入进程的数量，每一个进程由进程控制块（PCB）表示，各种队列均采用链表数据结构。

2，按照进程服务时间由少到多顺序排成一个队列。

再按顺序依次执行。

voidshort_timefirst（charalgo）{

PCq;

intt;

prt3（）;

for（intj=0;

j<

N;

j++）{

p[j].state='

for（inti=0;

i<

N;

i++）

{

if（p1[i].state=='

）p1[i].waittime=Tim;

if（strcmp（p[j].name,p1[i].name）==0）{

p1[i].state='

prit（i）;

p1[i].cputime=p1[i].needtime;

p1[i].needtime=0;

}

else{prit（i）;

p[j].cputime=p[j].needtime;

p[j].needtime=0;

p[j].waittime=Tim;

Tim+=p[j].cputime;

printf（"

for（inti=0;

i++）prit（i）;

四调试分析、测试结果

一．进入系统显示欢迎界面

二．如果选择P进行优先数算法则提示输入进程数：

三．输入进程号和运行时间：

四．输出优先数算法信息：

五．可以继续选择R进行时间片轮转算法，并输入时间片大小：

六．输出时间片轮转算法信息：

七．如果输入错误则结束程序：

五用户使用说明

本系统为模拟进程管理系统，界面美观，操作也比较简单，要按照提示信息一步步输入信息即可完成操作看到最终结果。

六后记

这个学期我们迎来了操作系统的课程设计，经过将近两个星期的程序设计，当遇到困难的时候我们谁都没有泄气而是努力的去查资料找方法，并且我们受到了指导老师的支持和鼓励，我在困难的时候想到了老师平时在给我们讲授知识的时候的样子，让我重新振作起来继续下面的工作，老师不厌其烦的给我们讲授知识，在此衷心的对老师说一声您辛苦了，与此同时我们还受到了许多同学的帮助。

还要感谢学校给我们学校的实验室来进行试验，使我能够顺利完成这次的任务。

我承诺我无论是在以后的学习还是工作中我都会认真努力的。

总体来说，本次课程设计还算比较成功，这与我们的辛勤劳动和老师的教导是分不开的。

我们会好好利用这次课程设计得来的宝贵经验和教训，在以后的发展中好好的利用，争取做的更好。

七参考资料

[1]严蔚敏，吴伟民，数据结构（C语言版），北京，清华大学出版社，2008年3月。

[2]杨树林，胡洁萍，C#程序设计与案例教程，北京，清华大学出版社，2007年8月。

[3]陈钟，刘强，C#编程语言程序设计与开发，北京，清华大学出版社，2006年8月。

[4]李春葆，苏光奎，数据结构算法与教程，北京，清华大学出版社，2005年6月。

八附录

#include<

stdio.h>

stdlib.h>

string.h>

queue>

usingnamespacestd;

typedefstructnode{

charname[10];

intprio;

intround;

intneedtime;

intcputime;

intcount;

intstate;

structnode*next;

booloperator<

（constnode&

o）const{

if（state==o.state）

returnprio<

o.prio;

returnstate>

o.state;

}PCB;

priority_queue<

node>

pq,pqempty,pp,qq;

PCB*finish,*ready,*tail,*run;

intN,Num;

typedefstructnod{

intwaittime;

}PC;

PCp[10];

PCp1[10];

intTim=0;

voidfirstin（）{

run=ready;

run->

state='

ready=ready->

next;

voidprt1（chara）{

if（a=='

P'

）

*进程号cpu时间所需要时间优先数状态*\n"

else

*进程号cpu时间所需时间记数时间片状态*\n"

}

voidprt2（chara,PCBq）{

）

*%-10s%-10d%-10d%-10d%-10d*\n"

q.name,q.cputime,q.needtime+Tim,q.prio,q.state）;

*%-10s%-10d%-10d%-10d%-10d%-10c*\n"

q.name,q.cputime,q.needtime+Tim,q.count,q.round,q.state）;

voidprt22（chara,PCB*q）{

*%-10s%-10d%-10d%-10d%-10d%-10c*\n"

q->

name,q->

cputime,q->

needtime,q->

count,q->

round,q->

state）;

voidprt（charalgo）{

PCB*q;

if（run!

=NULL）

prt22（algo,run）;

q=ready;

while（q!

=NULL&

&

q!

=run）{

prt22（algo,q）;

if（q->

next==run）break;

elseq=q->

q=finish;

=NULL）{

q=q->

i++）{

pq.empty（））{

voidcreate1（charalgo）{

PCBp;

inti,time;

charna[10];

ready=NULL;

finish=NULL;

run=NULL;

输入进程号和运行时间：

\n"

"

for（i=1;

=N;

i++）{

scanf（"

%s"

na）;

\n"

%d"

&

time）;

if（i!

=N）printf（"

Num+=time;

strcpy（p.name,na）;

p.cputime=0;

p.needtime=time;

p.state=2;

p.prio=50-time;

pq.push（p）;

优先数算法输出信息:

voidinsert2（PCB*q）{

tail->

next=q;

tail=tail->

voidcreate2（charalgo）{

PCB*p;

输入进程号和运行时间：

\n\n"

{

p=（PCB*）malloc（sizeof（PCB））;

strcpy（p->

name,na）;

p->

cputime=0;

needtime=time;

round=0;

count=0;

if（ready!

insert2（p）;

else{

p->

next=ready;

ready=p;

tail=ready;

时间片轮转法输出信息:

********************************************************************\n"

next=run;

prt（algo）;

while（run!

run->

if（run->

=0）{

run->

finish=run;

if（run!

=tail）{

tail->

else{

ready=NULL;

run=NULL;

if（ready!

firstin（）;

tail=run;

run=ready;

run->

ready=ready->

prt（'

intcmp（cons