操作系统集中上机实验报告Word文档下载推荐.docx
《操作系统集中上机实验报告Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《操作系统集中上机实验报告Word文档下载推荐.docx（30页珍藏版）》请在冰点文库上搜索。
stdio.h>
string.h>
stdlib.h>
iomanip.h>
conio.h>
constintMAX_P=20;
//允许的最大作业数
constintMAXA=10;
//定义A类资源的总数量
constintMAXB=5;
//定义B类资源的总数量
constintMAXC=7;
//定义C类资源的总数量
typedefstructnode{
inta;
intb;
intc;
intremain_a;
intremain_b;
intremain_c;
}bank;
typedefstructnode1{
charname[20];
intneed_a;
intneed_b;
intneed_c;
}process;
bankbanker;
processprocesses[MAX_P];
intquantity;
//初始化函数
voidinitial（）
{
inti;
banker.a=MAXA;
banker.b=MAXB;
banker.c=MAXC;
banker.remain_a=MAXA;
banker.remain_b=MAXB;
banker.remain_c=MAXC;
for（i=0;
i<
MAX_P;
i++）{
strcpy（processes[i].name,"
"
）;
processes[i].a=0;
processes[i].b=0;
processes[i].c=0;
processes[i].need_a=0;
processes[i].need_b=0;
processes[i].need_c=0;
}
//新加作业
voidadd（）
intflag=0;
intt;
intneed_a,need_b,need_c;
printf（"
\n"
新加作业\n"
━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
请输入新加作业名:
scanf（"
%s"
name）;
quantity;
if（!
strcmp（processes[i].name,name））{
flag=1;
break;
if（flag）{
错误,作业已存在\n"
else{
本作业所需A类资源:
%d"
&
need_a）;
本作业所需B类资源:
need_b）;
本作业所需C类资源:
need_c）;
t=1;
A类资源:
需要%d,现有%d"
need_a,banker.remain_a）;
if（need_a>
banker.remain_a）{
错误,所需A类资源大于银行家所剩A类资源\n"
t=0;
B类资源:
need_b,banker.remain_b）;
if（need_b>
banker.remain_b）{
错误,所需B类资源大于银行家所剩B类资源\n"
C类资源:
need_c,banker.remain_c）;
if（need_c>
banker.remain_c）{
错误,所需C类资源大于银行家所剩C类资源\n"
if（t）{
strcpy（processes[quantity].name,name）;
processes[quantity].need_a=need_a;
processes[quantity].need_b=need_b;
processes[quantity].need_c=need_c;
quantity++;
新加作业成功\n"
新加作业失败\n"
//为作业申请资源
voidbid（）
inti,p;
inta,b,c;
intflag;
a=b=c=0;
\n为作业申请资源\n"
要申请资源的作业名:
p=-1;
p=i;
if（p!
=-1）{
该作业要申请A类资源数量:
a）;
该作业要申请B类资源数量:
b）;
该作业要申请C类资源数量:
c）;
if（（a>
banker.remain_a）||（a>
processes[p].need_a-processes[p].a））{
错误,所申请A类资源大于银行家所剩A类资源或该进程还需数量\n"
flag=0;
if（（b>
banker.remain_b）||（b>
processes[p].need_b-processes[p].b））{
错误,所申请B类资源大于银行家所剩B类资源或该进程还需数量\n"
if（（c>
banker.remain_c）||（c>
processes[p].need_c-processes[p].c））{
错误,所申请C类资源大于银行家所剩C类资源或该进程还需数量\n"
banker.remain_a-=a;
banker.remain_b-=b;
banker.remain_c-=c;
processes[p].a+=a;
processes[p].b+=b;
processes[p].c+=c;
为作业申请资源成功\n"
为作业申请资源失败\n"
该作业不存在\n"
//撤消作业
voidfinished（）
\n撤消作业\n"
要撤消作业名:
banker.remain_a+=processes[p].a;
banker.remain_b+=processes[p].b;
banker.remain_c+=processes[p].c;
for（i=p;
quantity-1;
processes[i]=processes[i+1];
strcpy（processes[quantity-1].name,"
processes[quantity-1].a=0;
processes[quantity-1].b=0;
processes[quantity-1].c=0;
processes[quantity-1].need_a=0;
processes[quantity-1].need_b=0;
processes[quantity-1].need_c=0;
quantity--;
撤消作业成功\n"
撤消作业失败\n"
//查看资源情况
voidview（）
\n查看资源情况\n"
银行家所剩资源（剩余资源/总共资源）\n"
A类:
%d/%d"
banker.remain_a,banker.a）;
B类:
banker.remain_b,banker.b）;
C类:
banker.remain_c,banker.c）;
\n作业占用情况（已占用资源/所需资源）\n"
if（quantity>
0）{
作业名:
%s"
processes[i].name）;
processes[i].a,processes[i].need_a）;
processes[i].b,processes[i].need_b）;
processes[i].c,processes[i].need_c）;
当前没有作业\n"
//显示版权信息函数
voidversion（）
┏━━━━━━━━━━━━━━━━━━━━━━━┓\n"
┃银行家算法┃\n"
┠───────────────────────┨\n"
┃（c）AllRightReservedYT┃\n"
┃移通学院┃\n"
┃version2010buildsonghua┃\n"
┗━━━━━━━━━━━━━━━━━━━━━━━┛\n"
voidmain（）
intchioce=0;
intflag=1;
initial（）;
version（）;
while（flag）{
1.新加作业2.为作业申请资源3.撤消作业\n"
4.查看资源情况0.退出系统\n"
请选择:
chioce）;
switch（chioce）{
case1:
add（）;
break;
case2:
bid（）;
case3:
finished（）;
case4:
view（）;
case0:
flag=0;
default:
printf（"
选择错误\n"
时间片轮转法
将CPU的处理时间划分成一个个时间片，就绪队列中的诸进程轮流运行一个时间片，当时间片结束时，就强迫运行进程让出CPU，该进程进入就绪队列，等待下一次调度，同时,进程调度又去选择就绪队列中的一个进程,分配给它一个时间片，以投入运行。
在轮转法中，时间片长度的选择非常重要,将直接影响系统开销和响应时间。
如果时间片长度很小，则调度程序剥夺处理机的次数频繁,加重系统开销；
反之，如果时间片长度选择过长，比方说一个时间片就能保证就绪队列中所有进程都执行完毕，则轮转法就退化成先进先出算法。
#include<
typedefstructnode
charname[10];
/*进程标识符*/
intprio;
/*进程优先数*/
intround;
/*进程时间轮转时间片*/
intcputime;
/*进程占用CPU时间*/
intneedtime;
/*进程到完成还要的时间*/
intcount;
/*计数器*/
charstate;
/*进程的状态*/
structnode*next;
/*链指针*/
}PCB;
PCB*finish,*ready,*tail,*run;
//队列指针
intN,t;
//进程数,时间片的大小
voidfirstin（）
run=ready;
//就绪队列头指针赋值给运行头指针
run->
state='
R'
;
//进程状态变为运行态
ready=ready->
next;
//就绪队列头指针后移到下一进程
voidprt1（chara）//输出标题函数
if（toupper（a）=='
P'
）//优先级法
进程名占用CPU时间到完成还要的时间轮转时间片状态\n"
voidprt2（chara,PCB*q）//进程PCB输出
）//优先级法的输出
%4s%8d%12d%14d%8c\n"
q->
name,q->
cputime,q->
needtime,q->
round,q->
state）;
voidprt（charalgo）//输出函数
PCB*p;
prt1（algo）;
//输出标题
if（run!
=NULL）//如果运行指针不空
prt2（algo,run）;
//输出当前正在运行的PCB
p=ready;
//输出就绪队列PCB
while（p!
=NULL）
{
prt2（algo,p）;
p=p->
}
p=finish;
//输出完成队列的PCB
prt2（algo,p）;
}
getchar（）;
//按住任意键继续
voidinsert（PCB*q）//时间片轮转的插入算法
PCB*p1,*s,*r;
s=q;
//待插入的PCB指针
p1=ready;
//就绪队列头指针
r=p1;
//*r做pl的前驱指针
while（p1!
if（p1->
round<
=s->
round）
p1=p1->
if（r!
=p1）
r->
next=s;
s->
next=p1;
else
//否则插入在就绪队列的头
ready=s;
}
voidcreate（charalg）//时间片轮转法创建链表进程PCB
inti,time;
charna[10];
ready=NULL;
finish=NULL;
run=NULL;
输入进程名及其需要运行的时间（中间以空格隔开）：
for（i=1;
=N;
i++）
p=newPCB;
scanf（"
%s%d"
na,&
time）;
strcpy（p->
name,na）;
p->
cputime=0;
needtime=time;
W'
//进程的状态
round=0;
if（ready!
=NULL）
insert（p）;
next=ready;
ready=p;
*************时间片轮转法进程调度过程*************\n"
prt（alg）;
voidtimeslicecycle（charalg）//时间片轮转法
while（run!
cputime=run->
cputime+t;
//处理时间加t
needtime=run->
needtime-t;
//完成需要时间减t
round=run->
round+t;
//运行完将其变为完成态，插入完成队列
if（run->
needtime<
=0）//当进程完成时
{
next=finish;
finish=run;
F'
=NULL）//就绪队列不空，将第一个进程投入进行
firstin（）;
}
//将进程插入到就绪队列中等待轮转
insert（run）;
//将就绪队列的第一个进程投入运行
voidmain（）//主函数
charalgo='
//算法标记
输入进程的个数：
N）;
//输入进程数
定义时间片大小：
t）;
//输入时间片大小
create（algo）;
//创建进程
timeslicecycle（algo）;
//时间片轮转法调度
}//main（）
非抢占式优先级调度算法
该算法的基本思想是进程优先级高者优先调度，是一种常用的进程调度算法。
该算法的关键是如何确定优先数。
通常确定优先数的方法有两种，即静态法和动态法。
（1）静态优先权是在创建进程时确定的，其运行特征是优先数确定之后在整个进行运行期间不再改变。
确定静态优先权的依据有进程的类型、进程所使用的资源、进程的估计运行时间等因素。
进程所申请的资源越多，估计的运行时间越长，进程的优先权越低。
进程类型不同，优先权也不同，如系统进程的优先权高于用户进程的优先权。
（2）动态优先级是指在创建进程时，其运行特征是根据系统资源的使用情况和进程的当前特点确定一个优先权，在进程运行过程中再根据情况的变化调整优先权。
动态优先权一般根据进程占有CPU时间的长短、进程等待CPU时间的长短等因素确定。
占有处理机的时间越长，则优先权越低；
等待时间越长，则优先权越高。
①静态优先级调度算法实现较为简单，但不能反映系统以及进程在运行过程中发生的各种变化。
而动态优先级法可以满足这个方面的需要。
②动态优先级调度算法的性能一般介于时间片轮转算法和先来先服务算法之间。
#include
<
#define
MAX
5
//进程数/*非抢占式优先数算法*/
struct
pro1
int
num;
//进程名
arriveTime;
//到达时间
burst;
//运行时间;
weight;
//优先数
pro1
*next;
};
//函数声明
pro1*
creatList（）;
void
insert（struct
*head,struct
*s）;
searchByAT（struct
*head,int
AT）;
run（struct
*head）;
del（struct
p）;
getCount（struct
creatList（）
//创建链表，按照进程的到达时间排列
head=（struct
pro1*）malloc（sizeof（struct
pro1））;
head->
next=NULL;
*s;
i;
MAX;
s=（struct
请输入进程名:
（s->
num））;
请输入到达时间:
arriveTime））;
请输入运行时间:
burst））;
请输入优先数:
升级会员 