进程调度程序设计文档格式.docx
《进程调度程序设计文档格式.docx》由会员分享，可在线阅读，更多相关《进程调度程序设计文档格式.docx（17页珍藏版）》请在冰点文库上搜索。
循环轮转算法实现过程流程图：
循环轮转算法实现过程流程图
四.设计总结：
通过该课程设计，加深了对系统进程调度机制的理解。
在抢占方式中实践了“抢占”必须遵循的原则：
优先权原则，短进程优先原则，时间片原则。
认识了几种进程调度算法的优缺点以及应用范围。
加强C的编程能力。
参考文献
[1]AbrahamSilberschatz.操作系统概念（第8版影印版）.北京：
高等教育出版社，2010.
[2]GaryNutt（著），潘登（译）.Linux操作系统内核实习.北京：
机械工业出版社，2004.
[3]于渊.自己动手写操作系统（影印版）.电子工业出版社，2005
附录
程序源代码：
1、程序头文件
#ifndef__VIRTUAL_KERNEL__
#define__VIRTUAL_KERNEL__
#include"
iostream.h"
string.h"
stdio.h"
time.h"
#include<
stdlib.h>
#defineNOP00//空指令:
消耗一个机器周期
#defineMOV01//传送指令：
立即数赋值给寄存器A
#defineADD02//加法指令：
寄存器A加立即数
#defineOUT80//输出指令:
寄存器A的值输出到端口（端口号01--表示显示器）
#defineMAX_PID10//系统并发运行的进程数的最大值
//定义PCB结构类型
structPCB{
intA;
//累加器A
intPC;
//程序计数器PC
char*addr;
//程序加载起始地址
intlength;
//程序大小
intruntime;
intwaittime;
intstate;
intpname;
intpri;
//优先级数
structPCB*next;
}pcbs[MAX_PID];
/*运行指针*/
structPCB*running;
/*高优先级就绪队列头指针*/
structPCB*Hready;
/*低优先级队列头指针*/
structPCB*Lready;
/*等待队列头指针*/
structPCB*wait;
intsig=0;
intcur_pid;
//当前_进程号
intreadyNum=MAX_PID;
/**************************以下是函数说明****************************/
/*利用循环实现延迟*/
voiddelay（）;
voidproc（structPCB*running）;
/*将node插入到head所指示的队列的尾部*/
voidInsertIntoQueueTail（structPCB**head,structPCB*node）;
/*进程调度函数*/
intproc_switch（）;
/*进程等待函数*/
voidproc_wait（）;
/*进程唤醒函数*/
intproc_wakeup（）;
voidinitSystem（void）;
//初始化系统
intloadProgram（char*name）;
//加载应用程序
intexeInstruction（intpid）;
//执行指令
voidremoveFromQueue（structPCB**head,structPCB*node）;
#endif
2、程序文件
vknl.h"
intmain（intargc,char*argv[]）
{
inti;
if（argc!
=2）argv[1]="
app1.bin"
;
//默认应用程序
initSystem（）;
for（i=0;
i<
argc-1;
i++）{
loadProgram（argv[i]）;
}
/*模拟进程调度开始*/
for（;
readyNum>
0;
）
{
switch（sig）{
case0:
/*无进程等待调度，打印信息并返回*/
if（!
proc_switch（））
printf（"
NoProcesstorun,pressanykeytoreturn:
\n"
）;
getchar（）;
exit（-1）;
}
break;
case1:
proc_wait（）;
case2:
case3:
case4:
case5:
case6:
case7:
case8:
case9:
case10:
case11:
proc（running）;
default:
printf（"
\nerror!
"
exit（-1）;
}
return0;
//退出虚拟内核
}
//初始化系统
voidinitSystem（void）
cur_pid=0;
/*等待队列和高优先级队列为空*/
wait=NULL;
Hready=NULL;
//加载应用程序
intloadProgram（char*name）
FILE*fin=fopen（name,"
rb"
//打开源程序文件
if（fin==NULL）return-1;
//若打开失败，返回-1
fseek（fin,0L,SEEK_END）;
//文件读写指针移到文件末尾
longfsize=ftell（fin）;
//求文件长度
fseek（fin,0L,SEEK_SET）;
//读写指针移到文件开头
PCB*pcb=pcbs+cur_pid;
//获取当前进程PCB
pcb->
addr=newchar[fsize];
//为新进程分配内存
fread（pcb->
addr,fsize,1,fin）;
//程序读入内存
fclose（fin）;
//关闭文件
length=fsize;
//进程大小
A=0;
//初始化寄存器
PC=0;
pname=（cur_pid+2）;
waittime=0;
state=1;
InsertIntoQueueTail（&
Hready,pcb）;
//&
pcb[i]
cur_pid++;
return0;
//正常返回
//执行指令
intexeInstruction（intpid）
PCB*pcb=pcbs+（pid-2）;
charop_cmd=*（pcb->
addr+pcb->
PC）;
//取操作码
shortop_dat=*（（short*）（pcb->
PC+1））;
//取操作数
//注意,我们约定操作数是16位整数，所以要定义为short。
if（op_cmd==MOV）//传送指令
{
pcb->
A=op_dat;
//操作数赋给累加器A
elseif（op_cmd==ADD）//加法指令
A+=op_dat;
//加计算
elseif（op_cmd==SUB）
A-=op_dat;
elseif（op_cmd==MUL）
A*=op_dat;
elseif（op_cmd==DIV）
A/=op_dat;
elseif（op_cmd==MOD）
A%=op_dat;
elseif（op_cmd==JMP）
printf（"
JMPoperation.jumpto%d\n"
op_dat）;
pc+=（op_dat*3）;
elseif（op_cmd==OUT）//输出指令
OUToperation.resultis%d\n"
pcb->
A）;
//输出累加器A的内容
PC+=3;
//修改程序计数器
if（pcb->
PC>
=pcb->
length）
readyNum--;
state=0;
sig=0;
/*功能：
进程*/
/*入口参数：
运行指针*/
/*出口参数：
无*/
voidproc（structPCB*running）
if（running->
state==0）return;
/*显示当前运行的进程的id*/
\nNowProcess%disrunning\n"
running->
pname）;
/*当前进程执行running->
runtime个时间片*/
for（i=running->
runtime;
i>
i--）{
exeInstruction（running->
/*显示剩余的时间片*/
%dtimeslice（s）left\n"
i）;
/*延迟*/
delay（）;
proc_wakeup（）;
/*产生一个1到1000的随机数，若该随机数小余100，当前进程等待，*/
if（（rand（）%10000+1）<
1000）{
Process%dbeginstowait.\n"
sig=1;
return;
/*显示时间片耗尽，进程转为低优先级就绪状态*/
Timeslicesforprocess%dexhausted.\n"
Lready,running）;
sig=0;
将一个节点插入队列尾部*/
队列头指针地址head，待插入结点node*/
voidInsertIntoQueueTail（structPCB**head,structPCB*node）
structPCB*p;
node->
next=NULL;
if（*head==NULL）{
/*被插入队列为空*/
*head=node;
/*被插入队列不为空*/
else{
p=*head;
/*找到队列的最后一个结点*/
while（p->
next!
=NULL）p=p->
next;
p->
next=node;
进程调度*/
若调度成功，返回1，否则返回0*/
intproc_switch（）
/*若高优先级就绪队列和低优先级就绪队列均为空，则循环执行进程唤醒*/
while（Hready==NULL&
&
Lready==NULL）
proc_wakeup（））return0;
/*若高优先级就绪队列非空，则执行其第一个进程，分配2个时间片*/
if（Hready!
=NULL）{
running=Hready;
Hready=Hready->
running->
runtime=2;
/*若高优先级就绪队列为空，则执行低优先级就绪队列的第一个进程，
分配5个时间片*/
running=Lready;
Lready=Lready->
runtime=5;
/*别调度进程的id赋给sig*/
sig=running->
pname;
return1;
进程等待。
将当前运行进程置高优先级，等待时间为20，
插入等待队列尾部*/
voidproc_wait（）
PCB*p;
pri=1;
waittime=20;
wait,running）;
进程唤醒*/
若等待队列为空，则返回0，否则返回1*/
intproc_wakeup（）
structPCB*p,*last,*MoveToReady;
p=wait;
/*等待队列为空，返回0*/
if（p==NULL）return0;
/*等待队列中每个进程的等待时间减1*/
while（p!
waittime-=1;
p=p->
p=wait;
/*从等待队列中摘除等待时间为0的进程，插入到高优先级就绪队列的尾部*/
if（p->
waittime==0）{
MoveToReady=p;
if（p==wait）
wait=p->
else
last->
next=p->
Lready,MoveToReady）;
延迟一个时间片*/
voiddelay（）
inti,j;
10000;
i++）
for（j=0;
j<
5000;
j++）
升级会员 