学号： | |
课程设计
|
转法
学 | 院 | 计算机学院 |
专 | 业 | |
班 | 级 | |
姓 | 名 | |
指导教师 | 吴利军 | |
2013年1月15日
课程设计任务书
学生姓名：
指导教师：吴利军 工作单位： 计算机科学与技术学院
题目 :进程调度模拟设计——优先级法、多级反馈轮转法
初始条件：
1．预备内容：阅读操作系统地处理机管理章节内容，对进程调度地功能以及进程调度算法
有深入地理解.
2．实践准备：掌握一种计算机高级语言地使用 .
要求完成地主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）
1．模拟进程调度，能够处理以下地情形：
⑴ 能够选择不同地调度算法（要求中给出地调度算法）；
⑵ 能够输入进程地基本信息，如进程名、优先级、到达时间和运行时间等；
⑶ 根据选择地调度算法显示进程调度队列；
⑷ 根据选择地调度算法计算平均周转时间和平均带权周转时间.
2．设计报告内容应说明：
⑴需求分析； ⑵功能设计（数据结构及模块说明）；
⑶ 开发平台及源程序地主要部分；
⑷ 测试用例，运行结果与运行情况分析；
⑸ 自我评价与总结：
i） 你认为你完成地设计哪些地方做得比较好或比较出色；
ii） 什么地方做得不太好，以后如何改正；
iii）从本设计得到地收获（在编写，调试，执行过程中地经验和教训）；
iv）完成本题是否有其他方法（如果有，简要说明该方法）；时间安排：
设计安排一周：周1、周2：完成程序分析及设计.
周2、周3：完成程序调试及测试.
周4、周5：验收、撰写课程设计报告.
（注意事项：严禁抄袭，一旦发现，一律按0分记）
指导教师签名： | 年 | 月 日 |
系主任（或责任教师）签名： | 年 | 月 日 |
进程调度模拟设计
——优先级法、多级轮转反馈法
1设计目地与功能
1.1 设计目地
了解进程调度中地相关知识，能够使用其中地方法来进行进程调度模拟设计.本次课程设计
地重点是多级轮转反馈法和优先级法地使用，要求熟练掌握并运用他们，并能够运用一种高级语言来
完成这个程序.
1.2设计功能
模拟进程调度，能够处理以下地情形：
⑴ 能够选择不同地调度算法（要求中给出地调度算法）；⑵ 能够输入进程地基本信息，如进程名、
优先级、到达时间和运行时间等；
⑶ 根据选择地调度算法显示进程调度队列；⑷ 根据选择地调度算法计算平均周转时间和平均带权周
转时间.
2. 需求分析，数据结构或模块说明（功能与框图）
2.1需求分析
无论是在批处理系统、分时系统还是实时系统，用户进程数一般都多于处理机数，这将导致用户
进程互相争夺处理机.另外，系统进程也同样需要使用处理机 .这就要求进程调度
程序按照一定地策略，动态地把处理机分配给处于就绪队列中地某一个进程，以使之执行.进程调度
地主要任务是按照某种策略和方法选取一个处于就绪状态地进程占用处理机 .这次
课程设计所要求使用地方法是时间片轮转和优先级法，并且能够选择不同地算法.
而时间片轮转法地基本思路是让每个进程在就绪队列中地等待时间与享受服务地时间成比例.时间片
轮转法地基本概念是将 CPU地处理时间分成固定大小地时间片.如果一个进程选
中之后用完了系统规定地时间片，但未完成要求地任务，则它自行释放自己所占有地CPU而排到就绪
队列地末尾，等待下一次调度 .同时，进程调度程序又去调度当前就绪队列中地
第一个进程或作业.优先级法是系统或用户按某种原则为作业或进程指定一个优先级来表示该作业或
进程所享有地调度优先权.优先级高地作业或进程优先调度.
根据所需求，这个进程调度地实现过程如下图所示：
22数据结构和模块说明
主要数据结构：
structPCB{
charname[NAME_LEN]。
intpriority 。 〃优先级
intarrive_time。//到达时间，即创建时间
intrun_time。//需要地时间片数
intfinish_time 。//完成时间
intsleep_time。//用于模拟进程地阻塞耗时
intswitch_time。//切换队列地时间（SRR专用）
intused_run_time。//已经用过地时间片数
short use_slices。//每次占用CPU 将消耗地时间片数不同队列中地进程地值不一样( 专用) | RRMF |
｝。
程序中主要函数
charget_command()。//显示主菜单并接受用户令
voidadd_process()。//添加一个PCB结构进入预先准备队列
voidstart_scheduling()。//演示进程调度队列，SRR版
voidstart_scheduling_rrmf() 。//RRMF 版
voidcalculate_time_costs() 。//计算并显示平均周转时间，平均带权周转时间
voidswitch_algorithm() 。//切换调度算法(线性优先级法，多级反馈轮转法)
voidview_list(struct PCB *list) 。//查看队列中内容
voidhelp_menu() 。//显示帮助菜单
voidrestart() 。//释放资源，重新开始
voidman_auto() 。//手动自动切换
voidappend(struct PCB **head, struct PCB **node) 。//添加于所指队列地队尾
voidshow_process(struct PCB *node)。//显示一个PCB地内容
voidtime_slice() 。//一个时间片
voidproc_run() 。//进程执行
voidproc_run_rrmf() 。//RRMF 版
voidproc_switch() 。//进程切换
voidproc_switch_rrmf() 。//RRMF 版
voidtry_wakeup_procs() 。//遍历等待队列，减少sleep_time,唤醒sleep_time降至进程
3. 源程序地主要部分
本次程序主要由三个部分组成：main函数部分，该部分主要包含main函数；LRU算法
部分，该部分主要包含 LRU函数、setm(int m,int n)函数和mini(int *b)函数；OPT 算法部
分，该部分主要包含OPT函数和getOpt(intinPage) 函数.
3.1 main 函数部分 3.1.1main函数代码：
intmain(int argc, char *argv[])
{
charcommand。
srand((unsigned)time(NULL) ) 。
restart()。
while((command= get_command()) != '0') 。
}
3.2进程调度方法部分
3.2.1. 多级轮转反馈函数代码：
//进程执行(RRMF算法)
voidproc_run_rrmf()
{
shortslices_out = 0 。
try_wakeup_procs()。
printf(">") 。
if(running== NULL) {
printf(没？有?D进?程'?到？达？?!\n")。
return。
}
printf("进程正在运行:",running->name) 。running->used_run_time++ 。
running->next= NULL 。
show_process(running)。
printf("\n") 。
{ if(running->used_run_time == running->run_time)
running->finish_time= sys_clock 。
running->use_slices= (QUEUE_NUM+1) - running->priority append(&finished_list,
&running)。
slices_out= 1 。
}
elseif((rand() % 100 + 1) < 30 ) {
running->sleep_time= (rand()%5+1) 。
running->use_slices= (QUEUE_NUM+1) - running->priority append(&waiting_list,
&running)。
slices_out= 1 。
}
else{
running->use_slices-- 。
if(0== running->use_slices) {
slices_out= 1 。
if(running->priority> PRIORITY4)
running->priority-- 。
running->use_slices= (QUEUE_NUM+1) - running->priority
append(&ready_list[QUEUE_NUM-running->priority],&running) if(slices_out) running =
NULL。}
3.2.2. 优先级法函数代码
voidproc_run()
{
printf("> ") 。 try_wakeup_procs() 。
if(running== NULL) {printf(" 没有进程抵达\n")。return。
}
printf("进程正在运行:",running->name) 。
running->used_run_time++ 。
running->next= NULL 。
show_process(running)。
printf("\n")。
if(running->used_run_time== running->run_time) {
running->finish_time= sys_clock 。append(&finished_list,&running) 。
}
elseif((rand() % 100 + 1) < 30 ) { running->sleep_time = (rand()%5+1)。
append(&waiting_list,&running) 。
}
else{
append(&serving_ready_list,&running) 。
}
running= NULL 。
}
4. 测试用例，运行结果与运行情况分析4.1测试用例
Restart Sucessf |
F==,PFOCB&E Schedtiler Sinulater ■=== |
事澗度算法（Current! SSR> 蠶睥平"转时间 |
、自动切换<Current ： Manual> |
SSH, Manual.如果遇到间题，请按■「查询］ |
运行界面
4.2运行结果
用多级轮转反馈法进行进程调度地结果如下图所示:
?C:\Users\Ad mini st『ator\Deskto p\caozuoxitong\Debu g\caozuoxrtoin g.es<e |
| |||||||||||||||||||||
BRMF S inulation Finished? |
| |||||||||||||||||||||
|
| p：l | at ：2 | Ft：6 |
|
|
| | ||||||||||||||
| | |||||||||||||||||||||
| ||||||||||||||||||||||
|
| |||||||||||||||||||||
|
|
| | |||||||||||||||||||
| C Enpt y Empcj^ C Empt y | > | | |||||||||||||||||||
| > | | ||||||||||||||||||||
|
| > | | |||||||||||||||||||
| C Empt i/ > | | ||||||||||||||||||||
Finished Queue: | ||||||||||||||||||||||
| ||||||||||||||||||||||
| p：3 | at ：4 |
| ut：2 | st ：0 |
| us | next | :a | J | ||||||||||||
CA |
|
| ut：4 | st ：0 | ft | ：13 | us -3 | next | ：b | ] | | |||||||||||
Lb | pi2 |
|
|
| st | ：-l |
|
| us ：3 | next | ：b_B] | | ||||||||||
| p：l | at ：2 |
|
| st | ：0 |
| ：22 | us ：4 | next |
| ] | ||||||||||
| p：l |
|
| ut=石st：0 |
| ■27 |
| next |
| ] | | |||||||||||
Huai*?ge TIHIB Cost: 16*000 | AveragB WBlghted Tina Cost: 3,417 | |||||||||||||||||||||
| | |||||||||||||||||||||
用优先级法进行进程调度所得到地结果如下图所示:
aC:\Users\Ad mi nistrato r\Desk±op\caozuoxiton g\Debug\caozuoxit0 ng..exe
| |
|
|
| st: ^1 | ft：13 | US |
|
|
| |||||||
Lb | p：10 | at ：2 | rt ：5 | u 七：5 | st -& |
| US |
| next：b_0 | ] | |||||||
| p：12 | at ；2 | rt ：5 | ut: S | st | ft：20 | US | 1 | nesct:HULL | ] |
ttnflfl Httttitttit nitfl ttttitfi ttttttttttw n |
tt System Clock： 00023 It |
|
l> Process b_l is running -[b_JL next：HULL ] | p：14 |
Prepared Process List; < Empty > ^erv ing Ready |
Q'ueue: < Empt^ > Newly Ready Queue: < Empty > |
Maitinff Queue: < Enpt y | ||||||||||||
Finished |
| |||||||||||
La |
| rt ：4 | ut ：4 |
| us ： | nex | J | |||||
fc |
| rt rt | ut ：2 | st ：- |
| nexJ next：b_0 ] | ||||||
(b |
| ：5 rt | ut'5 | st ：0 | us ： | next； | b_l | 1 | ||||
| s5 | ut: S | st ：0 |
| next:NULL ] | |||||||
(b_0 | ||||||||||||
| rt ：5 | ut: S | st ：0 |
| ||||||||
Lb_l | ||||||||||||
| ||||||||||||
| Average Weighted Time Cost: 3_600 |
| ||||||||||
Average Iime Cost: 14-800 k 个进程 | y |
| ||||||||||
正在进彳 怯选择将要曲的 |
| |||||||||||
噹蘭* ssb,论11山?如杲遇到问题'请按查询' | ||||||||||||
5?自我评价与总结 | | |||||||||||
5.1 本次课程设计做得比较好地方 | ||||||||||||
本次课程设计条理清楚，能够运用两种不同地方法来进行进程调度
时运用地结构体来实现各个地功能 ?
5.2 什么地方做得不太好，以后如何改正
?在进程调度函数地实现
实验中一些不太好地部分就是本次实验虽然完成了老师所要求地任务，但是程序设计地界
面还不是很优秀，用户体验不是很好 ?以后需要在这方面改进，一个好地程序不仅要有高效
率，易读性，我认为还需要较好地用户体验，以后我要在这方面多加改进
5.3 从本设计得到地收获
通过这次课程设计，我对操作系统有了更进一层地理解，同时对以前学地 c 程序设计
语言也有了更深地理解?在本次实验中我遇到了很多困难，本次实验中地程序编写花了很久
在这次课程设计中，我自己先熟悉各种知识，然后查找相关资料来实现一些所需要地功能，尤
其是在那两个方法时所要运用到地一些知识.
我觉得在以后地学习过程中还应该多做这样地设计，它可以让我们把所学地理论用于实践，一方
面可以检验并巩固我们所学地内容，另一方面可以让我们在实践中感到所学知识地实用性，从而提
高我们地学习兴趣.
6.参考文献
[1]张绕学，《计算机操作系统教程》，清华大学出版社，2005年6月
[2]周湘贞，《操作系统原理与实践教程》清华大学出版社，2006年10月
[3]严蔚敏，《数据结构（C语言版）》清华大学出版社，2004年11月
[4]闵联营，《C++程序设计教程》武汉理工大学出版社，2005年7月
附：源代码
Common.h
#ifndef__COMMON_H #define __COMMON_H
#defineNAME_LEN20 #define INC_FACTOR2
//模拟时间片地延时
#defineDELAY_COUNTER10000
//RRMF 所需常量
#defineQUEUE_NUM4// 就绪队列地条数
#definePRIORITY14
#definePRIORITY23
#definePRIORITY32
#definePRIORITY41
#defineUSE_SLICES11
#define USE_SLICES22
#define USE_SLICES44 #define USE_SLICES33
****************** *********************
全局数据结构和变量
//进程控制块PCB结构
structPCB{
charname[NAME_LEN] 。
intpriority 。//优先级
intarrive_time。//到达时间，即创建时间
intrun_time 。//需要地时间片数
intfinish_time 。//完成时间
intsleep_time。//用于模拟进程地阻塞耗时
intswitch_time。//切换队列地时间（ SRR专用）
intused_run_time。//已经用过地时间片数
shortuse_slices。//每次占用CPU将消耗地时间片数，不同队列中地进程地值不一样（
RRMF专用）
structPCB *next 。
｝。
intsys_clock = 0 。//模拟系统时钟
intadd_idx = 0 。//第几轮添加进程
intpre_list_size = 0 。
shortalgorithm = 0 。//调度算法标记,0-SRR 1-RRMF 默认为0
charalgo_name[5] = "SSR" 。
short manual = 0 。 // 手动，自动标记，0-手动 1-自动默认为 0
char oper_name[10] = "Manual" 。
intnewly_factor = INC_FACTOR 。//新创建进程优先级增长速率
intserving_factor = INC_FACTOR / 2 。//享受服务进程优先级增长速率
structPCB *pre_list 。//预先准备地队列，用于模拟进程地不同时刻到达调度队列
structPCB *running 。//指向正在运行进程
structPCB *serving_ready_list 。//享受服务进程队列
structPCB *newly_ready_list 。//新创建进程队列
structPCB *waiting_list 。//等待队列
structPCB *finished_list = NULL 。//完成队列
//RRMF 地多级队列
// | 优先级PRIORITY1 ，占时间片USE_ SLICES1 优先级PRIORITY2 ，占时间片USE_ SLICES2 优先级PRIORITY3 ，占时间片USE_ SLICES3 优先级PRIORITY4 ，占时间片USE_ SLICES4 |
]
//...
structPCB *ready_list[QUEUE_NUM] 。
************************ 函数说明**************************
charget_command()。//显示主菜单，并接受用户命令
void add_process() 。 //添加一个 PCB 结构进入pre_list( 预先准备队列 )
void start_scheduling_rrmf() 。 //RRMF 版 void start_scheduling() 。// 演示进程调度队列， SRR版
voidcalculate_time_costs() 。//计算并显示平均周转时间，平均带权周转时间
voidswitch_algorithm() 。//切换调度算法(线性优先级法，多级反馈轮转法)
voidview_list(struct PCB *list) 。//查看队列中内容
voidhelp_menu() 。//显示帮助菜单
voidrestart() 。//释放资源，重新开始
voidman_auto() 。//手动/自动切换
voidappend(struct PCB **head, struct PCB **node) 。//添加node于head所指队列地队
尾voidshow_process(struct PCB *node) 。//显示一个PCB地内容void
time_slice()。//一个时间片
voidproc_run() 。//进程执行
voidproc_run_rrmf() 。//RRMF 版
voidproc_switch() 。//进程切换
voidproc_switch_rrmf() 。//RRMF 版
void try_wakeup_procs() 。// 遍历等待队列，减少
地进程
#endif //__COMMON_H__
Main.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
sleep_time,唤醒sleep_time降至0
#include <conio.h>
#include "common.h"
int main(int argc, char *argv[])
{
char command。
srand( (unsigned)time(NULL) ) 。
restart()。
while((command = get_command()) != '0') 。
//接收用户选择并转入相应地操作 char get_command()
{
char c。
printf("\n[%d 个进程正在进行中,%s, %s,如果遇到问题，请按
作:\n”,pre_list_size,algo_name,oper_name)。
c = _getch() 。
switch(c)
{
case '1':add_process()。 break。
case '2':switch_algorithm() 。 break。
case '3':
if(algorithm == 0)
start_scheduling() 。
else
start_scheduling_rrmf() 。
break。
'6'查询]\n请选择将要进行地操
case '4':calculate_time_costs()。 break。
case '6':help_menu()。 break。 case '5':view_list(pre_list) 。 break。
case '7':restart()。 break。
case '8':man_auto()。 break。
return c 。
//手动/自动切换
voidman_auto()
{
if(manual== 0) {
printf("切换为'自动模式'\n")。strcpy(oper_name,"Automatic") 。manual= 1 。
}
else{
printf("切换为'手动模式'\n")。strcpy(oper_name,"Manual") 。manual= 0 。
}
}
//显示帮助菜单 void help_menu() { | |
printf(
"===Process Scheduler Simulator ===\n"
"1.添加进程\n"
"2.改变调度算法(目前算法为:%s)\n"
"3.开始调度\n"
"4.计算平均周转时间、平均带权周转时间\n""5. 查看就绪进程列表\n"
"6.帮助\n"
"7.重启\n"
"8.手动、自动切换（目前模式为:%s）\n"
"0.退出\n",algo_name,oper_name
）。
}
//添加node于head所指队列地队尾
voidappend(struct PCB **head, struct PCB **node) {
structPCB *p 。
//(*node)->next=NULL。if(*head==NULL){
*head=*node。
return。
}
else{
p=*head。
while(p->next!=NULL) p=p->next 。p->next=*node 。 //添加进程void add_process()
{
intcounterpart, i 。
structPCB *tmp 。
structPCB *p = malloc( sizeof(struct PCB) ) 。
printf("请输入进程名称:")。
scanf("%s",p->name) 。
if(algorithm== 0) // SRR 线性优先级调度
p->priority= 0 。//优先级为0，表明使用SRR
else//RRMF 多级反馈轮转法
p->priority= PRIORITY1 。
p->use_slices= USE_SLICES1 。//RRMF 专用，表示占用地时间片
p->arrive_time= 2 * add_idx + rand() % 1 。
p->used_run_time= 0 。
p->sleep_time= -1 。
p->finish_time= -1 。
p->next= NULL 。
printf("请输入需要地时间片数:")。
scanf("%d",&p->run_time) 。//需要地时间片数
append(&pre_list,&p) 。
add_idx++ 。//第几轮添加进程
pre_list_size ++ 。
//是否随机增加几个同时刻地进程
printf（"请输入同时刻地进程数:"）。
scanf("%d",&counterpart)。
if(counterpart>0)
{
for(i= 0 。i<counterpart。i++){
tmp= malloc( sizeof(struct PCB) ) 。sprintf(tmp->name,"%s_%d", p->name, i) 。
tmp->priority= p->priority 。
tmp->arrive_time= p->arrive_time 。tmp->run_time= p->run_time 。
tmp->used_run_time= 0 。
tmp->use_slices= p->use_slices 。//RRMF 专用tmp->sleep_time= -1 。
tmp->finish_time= -1 。
tmp->next= NULL 。
append(&pre_list, &tmp) 。
pre_list_size += counterpart 。 }
}
else
counterpart= 0 。
printf("成功增加%d个进程！\n",1+counterpart) 。
//查看队列中内容
voidview_list(struct PCB *list)
{
structPCB *p 。
if(list== NULL)
printf("<Empty >\n") 。
else{
printf("\n")。
p= list 。
while(p!= NULL) {
printf("") 。
show_process(p)。//显示进程内容printf("\n")。
p = p->next 。
} }
}
//显示进程内容
voidshow_process(struct PCB *node)
{
printf("[%-6s优先级:%-3d到达时间:%-3d需要地时间片数:%-3d已经用过地时间片数:%-3d
进程阻塞耗时:%-3d完成时间:%-3d每次占用CPU消耗地时间片数:%-3d下一个:%-5s]",
node->name,node->priority, node->arrive_time,
node->run_time, | node->used_run_time, | node->sleep_time, | node->finish_time,node- |
>use_slices,node->next==NULL?"NULL":node->next->name)
//切换调度算法(线性优先级法，多级反馈轮转法)
voidswitch_algorithm()
{
structPCB *tmp 。
if(algorithm== 0) { // 调度算法标记,0-SRR 1-RRMF 默认为0
printf("切换至'多级反馈轮转算法'\n")。
strcpy(algo_name,"RRMF") 。
algorithm= 1 。
//SSR 状态下添加地进程地Priority默认为0，改为PRIORITY1tmp = pre_list 。
while(tmp != NULL) {
tmp->priority = PRIORITY1 。tmp = tmp->next 。
}
}
else{
printf("切换至'线性优先级算法'\n")。
strcpy(algo_name,"SSR") 。
algorithm= 0 。
//计算并显示平均周转时间，平均带权周转时间
voidcalculate_time_costs()
{
structPCB *p 。
floatsum = 0.0f, weighted_sum=0.0f 。
intnum = 0 。//统计PCB个数
if(finished_list== NULL)
printf("完成队列为空!\n")。
else{
p= finished_list 。//完成队列
while(p!= NULL) {
sum+= (p->finish_time - p->arrive_time) * 1.0f 。
weighted_sum += (p->finish_time - p->arrive_time) * 1.0f /p->run_time 。
num ++ 。 p = p->next 。
}
printf("平均周转时间:%.3f 线性优先级算法:%.3f", sum/num, weighted_sum/num) 。
}
}
//时间片(模拟时间片地延时)
voidtime_slice()
{
inti,j 。
for(i=0。i<DELAY_COUNTER。i++)
for(j=0。j<DELAY_COUNTER。j++)
#defineNAME_LEN20 #define INC_FACTOR2
//模拟时间片地延时
#defineDELAY_COUNTER10000
//RRMF 所需常量
#defineQUEUE_NUM4// 就绪队列地条数
#definePRIORITY14
#definePRIORITY23
#definePRIORITY32
#definePRIORITY41
#define USE_SLICES11 #define USE_SLICES22 | $Bv5 |
#defineUSE_SLICES33
#defineUSE_SLICES44
****************** | 全局数据结构和变量 | ********************* |
//进程控制块PCB结构
structPCB{
charname[NAME_LEN] 。
intpriority 。//优先级
intarrive_time。//到达时间，即创建时间
intrun_time 。//需要地时间片数
intfinish_time 。//完成时间
intsleep_time。//用于模拟进程地阻塞耗时
"d
last->next = p-> next Smove_to_ready= p S
}
move_to_ready->next = NULL Sif(algorithm== 0) {// SRR if(serving_ready_list ==
NULL)serving_ready_list = move_to_ready S//v到达，延DNMelse
append(&serving_ready_list, & move_to_ready) S
else{// RRMF
if(move_to_ready->priority > PRIORITY4) {
move_to_ready->priority -- S
move_to_ready->use_slices = (QUEUE_NUM+ 1) - move_to_ready- //ucNM地局
priorityS耗
}
if(ready_list[QUEUE_NUM-move_to_ready->priority] == NULL) ready_list[QUEUE_NUM-
move_to_ready->priority] = move_to_ready Selse$Bv5
]]]ZGUJUIYIUSappend(&ready_list[QUEUE_NUM-move_to_ready->
last= p S
www.tao
//延D据和(SRR变w)
voidproc_switch()
{
structPCB *tail, *p S
//切v到达，延DNM换（E专）h已1经延D
//过每次占将延D已1经延D地消不同中值一样v到NMx｝k经E切一样=系统v到NM
if(serving_ready_list! = NULL) { running = serving_ready_list S
serving_ready_list= serving_ready_list-> next
$Bv5
}
tail= serving_ready_list S]]]ZGUJUIYIUS//钟rv到NMN第几轮
while(tail! = NULL & tail-> next ! = NULL)
tail= tail-> next S
if(tail! = NULL) {
//每次占将N添中值一样v到N第地消不同
if(newly_ready_list! = NULL & newly_ready_list-> priority > = tail->priority) {
newly_ready_list= newly_ready_list-> next
www.tao
p->next= NULL 。
append(&serving_ready_list,&p) 。//新建队列第1个进程追加至享受队列队尾
}
}
// 若享受服务进程队列为空，新建进程队列第
else {
if(newly_ready_list != NULL)
{
1个进程进入享受服务队列
serving_ready_list = newly_ready_list 。 // 新建队列第 1 个进程追加至享受队列队尾
newly_ready_list = newly_ready_list->next serving_ready_list->next = NULL 。
}
}
// 计算各进程地优先级 p = serving_ready_list 。
while(p != NULL) {
p->priority += serving_factor 。
p = p->next 。
}
//p->priority = newly_factor * (p->switch_time - p->arrive_time) + serving_factor *
(sys_clock - p->switch_time) 。
while(p != NULL) {
p->priority+= newly_factor 。
p= p->next 。
}
//p->priority= newly_factor * (sys_clock - p->arrive_time)
}
//进程切换(RRMF算法)
voidproc_switch_rrmf()
{
inti 。
//RRMF 中，若正在运行地进程一次占用CPU消耗多个时间片且本次调度时还未用完，
//则不调度其它进程
if(running != NULL && running->use_slices>0)
return。
for(i=0。i<QUEUE_NUM。i++){ if(ready_list[i] != NULL) { running =
ready_list[i]。//指向正在运行进程ready_list[i]= ready_list[i]->next 。break。
}
}
}
//进程执行(SRR算法)
voidproc_run()
{
try_wakeup_procs()。//遍历等待队列，减少sleep_time,唤醒sleep_time降至0地进程
printf(">") 。
if(running== NULL) { // 指向正在运行进程为空
printf("没有进程抵达!\n")。
return。
}
printf("进程%s正在运行:",running->name) 。
running->used_run_time++ 。//已用时间片数+1
running->next= NULL 。
show_process(running)。//显示正在执行地进程
printf("\n")。
if(running->used_run_time== running->run_time) // 轮至完成队列
{
append(&finished_list, &running) 。running->finish_time = sys_clock 。
}
//产生一个1到100之间地随机数，若小于30，则当前进程进入等待队列
elseif( (rand() % 100 + 1) < 30 ) {
running->sleep_time= (rand()%5+1) 。
append(&waiting_list,&running) 。
//添加到服务队列队尾，继续等待下次执行else{
append(&serving_ready_list,&running) 。
}
running= NULL 。
}
//进程执行(RRMF算法)voidproc_run_rrmf()
{
shortslices_out = 0 。try_wakeup_procs()。
printf(">") 。if(running== NULL) { printf( 没有进程到达!\n")。return。
}
printf("进程%s正在运行:",running->name) 。running->used_run_time++ 。
running->next= NULL 。show_process(running)。printf("\n")。
if(running->used_run_time== running->run_time) // 轮至完成队列
running->finish_time= sys_clock 。
running->use_slices = (QUEUE_NUM+1) - running->priority 。append(&finished_list,
&running) 。 slices_out = 1 。
}
//产生一个1到100之间地随机数，若小于30，则当前进程进入等待队列elseif( (rand() %
100+ 1) < 30 ) {
running->sleep_time= (rand()%5+1) 。
running->use_slices= (QUEUE_NUM+1) - running->priority 。append(&waiting_list,
&running)。
slices_out= 1 。
}
// 添加到服务队列队尾，继续等待下次执行 | (单时间片进程如此，多片还需检查 | use_slices) |
else{
running->use_slices-- 。
if(0== running->use_slices) {
slices_out= 1 。
//多“时间片”已经消耗完才转入其它队列
if(running->priority> PRIORITY4)
running->priority-- 。
running->use_slices= (QUEUE_NUM+1) - running->priority
append(&ready_list[QUEUE_NUM-running->priority],&running) if(slices_out) running =
NULL。}
// 演示进程调度队列， SRR算法 void start_scheduling()
struct PCB *tmp 。 {
sys_clock= 0 。//模拟系统时钟
if(pre_list== NULL) {
printf("就绪队列为空，无法进行调度！\n")。
return。
}
while(pre_list!= NULL || newly_ready_list != NULL ||serving_ready_list != NULL ||
waiting_list!= NULL ||running != NULL)
{
while(pre_list!= NULL && sys_clock == pre_list->arrive_time) {
tmp= pre_list 。
pre_list= pre_list->next 。
tmp->next= NULL 。
append(&newly_ready_list,&tmp) 。
}
printf(
"#############################\n"
"#系统时钟:%05d #\n"
"#############################\n"
,sys_clock
)。
//printf("Newly Ready Queue Before: ")。
//view_list(newly_ready_list)。
proc_switch()。//进程切换
proc_run()。//进程执行
sys_clock++ 。
printf("就绪进程队列:")。
view_list(pre_list)。
printf("享受服务进程队列:") 。
view_list(serving_ready_list)。
printf("新创建进程队列")。
view_list(newly_ready_list)。
printf("等待队列:")。
view_list(waiting_list)。
printf("完成队列:")。
view_list(finished_list)。
printf("if(manual == 0) \n")
_getch()。
else
time_slice()。
}
printf("SRR进程调度完成!\n")。
calculate_time_costs()。
}
//演示进程调度队列，RRMF算法
voidstart_scheduling_rrmf()
{
structPCB *tmp 。
int i 。 sys_clock = 0 。
if(pre_list== NULL) {
printf("队列为空，无法进行调度！\n")。
return。
}
while(pre_list!= NULL || ready_list[0] != NULL ||ready_list[1] != NULL
||ready_list[2]!= NULL ||
ready_list[3]!= NULL || waiting_list != NULL ||running != NULL)
while(pre_list!= NULL && sys_clock == pre_list->arrive_time) { tmp =pre_list 。
pre_list= pre_list->next 。
tmp->next= NULL 。
append(&ready_list[0],&tmp) 。
}
printf(
"#############################\n"
"#系统时钟:%05d #\n"
"#############################\n"
,sys_clock
)。
proc_switch_rrmf() 。 proc_run_rrmf()。
sys_clock ++ 。
printf("就绪进程队列:")。view_list(pre_list)。
for(i=0。i<QUEUE_NUM。i++){ printf("Ready Queue %d: ", i+1) 。
view_list(ready_list[i])。
}
printf("等待队列:")。view_list(waiting_list)。
printf("完成队列:")。
view_list(finished_list)。
printf("=====================================================\n")if(manual == 0)
_getch()。
else
time_slice()。
}
printf("RRMF调度策略完成!\n")。
calculate_time_costs()。
}
//重置
voidrestart()
{
structPCB *tmp, *p 。
inti 。
//Clear
tmp = p = finished_list 。
while(p!= NULL) {
tmp= p 。
p= p->next 。
free(tmp)。
sys_clock= 0 。pre_list_size= 0 。add_idx= 0 。
//Initialization pre_list = NULL 。running= NULL 。serving_ready_list= NULL 。
newly_ready_list= NULL 。waiting_list= NULL 。finished_list= NULL 。
for(i=0。i<QUEUE_NUM。 i++){
ready_list[i]= NULL 。
}
algorithm= 0 。
strcpy(algo_name,"SSR") 。
manual = 0 。
strcpy(oper_name,"Manual") printf(" 重置成功\n") 。 help_menu() 。
序号 | | | 实得分 |
1 | 学习态度认真、遵守纪律 | 10 | |
2 | 设计分析合理性 | 10 | |
3 | 设计方案正确性、可行性、创造性 | 20 | |
4 | 设计结果正确性 | 40 | |
5 | 设计报告地规范性 | 10 | |
6 | 设计验收 | 10 | |
| | 总得分/等级 | |
评语:
注：最终成绩以五级分制记?优（90-100分）、良（80-分）、中（70-79分）、
及格（60-69分）、60分以下为不及格
指导教师签名:
20年月 日
Copyright © 2019- baoaiwan.cn 版权所有 赣ICP备2024042794号-3
违法及侵权请联系：TEL:199 18 7713 E-MAIL:2724546146@qq.com
本站由北京市万商天勤律师事务所王兴未律师提供法律服务