操作系统课程设计报告处理机调度程序_操作系统课程设计报告

操作系统课程设计报告处理机调度程序由刀豆文库小编整理，希望给你工作、学习、生活带来方便，猜你可能喜欢“操作系统课程设计报告”。

操作系统

课程设计报告

学校：广州大学

学院：计算机科学与教育软件学院 班级：计算机127班 课题：处理机调度程序

任课老师：陶文正、陈文彬

姓名：黄俊鹏

学号：1200002111 班内序号：27 成绩：

日期：2015年1月6日

一、设计目的 在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择一进程占用处理机。要求学生设计一个模拟处理机调度算法，以巩固和加深处理机调度的概念。

二、设计要求

1）进程调度算法包括：时间片轮转法，短作业优先算法，动态优先级算法。2）可选择进程数量

3）本程序包括三种算法，用C语言实现，执行时在主界面选择算法（可用函数实现）（进程数，运行时间，优先数由随机函数产生）执行，显示结果。

三、设计思路及算法思想

1.界面菜单选项

一级菜单提供2个选项： ① 自动生成进程数量 ② 手动输入所需进程数量

一级菜单选择完毕后进入二级菜单： ① 重新生成进程 ② 时间片轮转法 ③ 短作业优先算法 ④ 动态优先级算法 ⑤ 退出程序

2.调度算法

程序所用PCB结构体

需要用到的进程结构体如上图所示

1)时间片轮转法

主要是设置一个当前时间变量，curTime和时间片roundTime。

遍历进程组的时候，每运行一个进程，就把curTime += roundTime。进程已运行时间加roundTime

2)短作业优先算法

遍历进程组，找到未运行完成并且运行时间最短的进程，让它一次运行完成，如此往复，直到所有进程都运行完成为止。

3)动态优先级算法

做法跟短作业优先算法类似，此处主要是比较进程的优先数，优先级高者，先执行。直到全部执行完毕。当一个进程运行完毕后，适当增减其余进程的优先数，以达到动态调成优先级的效果。

3.程序流程图

四、运行截图

1）启动后输入5，生成5个进程

2）输入1，选择时间片轮转法。

自动输出结果，分别是时间片为1和4的结果

3）输入2，选择短作业优先算法

4）输入3，选择动态优先级算法

5）输入0，重新生成进程，再输入3，生成3个进程，选择2.短作业优先算法

6）输入q，退出

五、心得体会

通过这次实验，让我对操作系统的进程调度有了更进一步的了解。这个实验的模拟程度跟真实系统相比只是冰山一角，由此可见操作系统是何其复杂的软件产品，仅进程调度就有那么丰富和内涵的知识需要掌握。

但是再复杂的系统，都是由小部件构成的。古语云：不积跬步,无以至千里。不积小流,无以成江海。掌握这些基础的知识，可以为以后打下扎实的基础。

六、附录（源代码）

//

// main.c

// ProceDispatch //

// Created by Jeans on 1/5/15.// Copyright(c)2015 Jeans.All rights reserved.//

#include #include

//最小进程数

#define MIN_PROCESS//最大进程数

#define MAX_PROCESS

//最小优先数

#define MIN_PRIORITY

0 //最大优先数

#define MAX_PRIORITY

//最小运行时间

#define MIN_RUNNING_TIME

//最大运行时间

#define MAX_RUNNING_TIME

typedef struct PCB{

char name;

//进程名

int priority;

//优先数

int runningTime;

//运行时间

int arriveTime;

//到达时间

int beginTime;

//开始时间

int finishTime;

//完成时间

int cyclingTime;

//周转时间

double weigthCyclingTime;//带权周转时间

int hadRunTime;

//已经运行时间

int finish;

//是否完成 }PCB;//获取随机数

int GetRandomNumber(int min,int max){

return arc4random()%(max-min)+ min;}

//初始化PCB组

void InitPCBGroup(PCB p[],int num){

char name = 'A';

for(int i = 0;i

p[i].name = name;

p[i].priority = GetRandomNumber(MIN_PRIORITY, MAX_PRIORITY);

p[i].runningTime = GetRandomNumber(MIN_RUNNING_TIME,MAX_RUNNING_TIME);

name++;

} }

void PrintResult(PCB p[],int num){

double avgCycTime = 0,avgWeiCycTime = 0;

printf(“|进程名

到达时间

运行时间

开始时间

完成时间

周转时间

带权周转时间

优先数

|n”);

for(int i = 0;i

printf(“|%3c

%-4d

%-4d

%-4d

%-4d

%-4d

%-6.2f

%-4d|n”,p[i].name,p[i].arriveTime,p[i].runningTime,p[i].beginTime,p[i].finishTime,p[i].cyclingTime,p[i].weigthCyclingTime,p[i].priority);

avgCycTime += p[i].cyclingTime;

avgWeiCycTime += p[i].weigthCyclingTime;

//还原

p[i].arriveTime = 0;

p[i].beginTime = 0;

p[i].finishTime = 0;

p[i].cyclingTime = 0;

p[i].weigthCyclingTime = 0;

p[i].hadRunTime = 0;

p[i].finish = 0;

}

avgWeiCycTime /= num;

avgCycTime /= num;

printf(“平均周转时间：%.2f

平均带权周转时间:%.2fn”,avgCycTime,avgWeiCycTime);} //时间片轮转法

void RealRoundRobin(PCB p[],int num,int roundTime){

printf(“nn-----------------------------时间片：%d------n”,roundTime);

int finishNum = 0;

int curTime = 0;

while(finishNum!= num){

for(int i = 0;i

if(p[i].finish)continue;

//开始时间

if(p[i].beginTime == 0 && i!= 0){

p[i].beginTime = curTime;

}

//已经完成if(p[i].hadRunTime + roundTime >= p[i].runningTime){

p[i].finishTime = curTime + p[i].runningTimep[i].arriveTime;

p[i].weigthCyclingTime = p[i].cyclingTime/(double)p[i].runningTime;

p[i].finish = 1;

finishNum ++;

curTime += p[i].runningTimep[min].arriveTime;

p[min].weigthCyclingTime = p[min].cyclingTime/(double)p[min].runningTime;

p[min].finish = 1;

finishNum++;

curTime = p[min].finishTime;

}

PrintResult(p, num);}

//动态优先级算法

void DynamicPriorityFirst(PCB p[],int num){

printf(“nn-----------------------------动态优先级算法--n”);

int finishNum = 0;

int curTime = 0;

while(finishNum!= num){

int min = 0;

//查找优先级最高下标

for(int i = 1;i

if(p[i].finish == 0 && p[min].priority >= p[i].priority)

min = i;

else if(p[i].finish == 0 && p[min].finish == 1)

min = i;

}

p[min].beginTime = curTime;

p[min].hadRunTime = p[min].runningTime;

p[min].finishTime = p[min].beginTime + p[min].runningTime;

p[min].cyclingTime = p[min].finishTime-p[min].arriveTime;

p[min].weigthCyclingTime = p[min].cyclingTime/(double)p[min].runningTime;

p[min].finish = 1;

finishNum++;

curTime = p[min].finishTime;

}

PrintResult(p, num);}

int main(int argc, const char * argv[]){

PCB pcbGroup[30];

//pcb数组

int proceNum = 0;//进程数

while(1){

//选择进程数量

while(1){

if(proceNum!= 0)

break;

printf(“n----------n”);

printf(“当前默认进程数范围%d--%dn”,MIN_PROCESS,MAX_PROCESS);

printf(“1)输入0可随机生成进程数目n2)输入%d-%d范围内数字，回车，可生成指定数目进程n>>>>>>”,MIN_PROCESS,MAX_PROCESS);

int num = 0;

scanf(“%d”,&num);

if(num == 0){

proceNum = GetRandomNumber(MIN_PROCESS, MAX_PROCESS);

break;

}else{

if((num >= MIN_PROCESS)&&(num

proceNum = num;

InitPCBGroup(pcbGroup,proceNum);

break;

}else

printf(“n输入有误，请重新输入.n”);

}

}

//选择算法

printf(“n-----------------------------请输入对应选项序号-----------------------------n”);

printf(“0.重新生成进程 | 1.时间片轮转法 | 2.短作业优先算法 | 3.动态优先级算法 | q.退出n>>>>>>”);

char ch;

while((ch = getchar())== 'n');

switch(ch){

case '0'://0 重新生成进程

proceNum = 0;break;

case '1'://1 时间片轮转法

RoundRobin(pcbGroup, proceNum);break;

case '2'://2 短作业优先算法

ShortestJobFirst(pcbGroup, proceNum);break;

case '3'://3 动态优先级算法

DynamicPriorityFirst(pcbGroup,proceNum);break;

case 'q'://q 退出

exit(0);

default:

break;

}

}

return 0;}