操作系统实验Word下载.docx
《操作系统实验Word下载.docx》由会员分享，可在线阅读，更多相关《操作系统实验Word下载.docx（37页珍藏版）》请在冰点文库上搜索。
intProcessNum,SourceNum;
voidSafe（）
{inti,j,k;
intcount=0;
intn=0;
intWork[100];
//工作向量，可提供所需资源
for（i=0;
i<
SourceNum;
i++）
Work[i]=Available[i];
//把可用资源赋给工作向量
//cout<
<
"
work"
Work[i]<
endl;
ProcessNum;
Finish[i]=0;
//先设置一个标志将初值设为0，判定是否安全的标志
{if（Finish[i]==1）
continue;
//如果判定过就继续
else
{for（j=0;
j<
j++）
{if（Need[i][j]>
Work[j]）
break;
//不安全，跳出}
if（j==SourceNum）
{//cout<
i"
"
Finish[i]=1;
//安全，判断过设置为1
for（k=0;
k<
k++）
{Work[k]=Work[k]+Allocation[i][k];
//可用资源累加
Work[k]<
}
count++;
p[n++]=i;
i=-1;
//将i设置为-1，之后变为0，重新开始判断
//i=0;
count"
count<
n"
n;
}}}
if（count==ProcessNum）
{cout<
系统是安全的"
cout<
安全序列是：
p[i]<
;
if（count!
=ProcessNum）
系统是不安全的"
}}
voidmain（）
{inti,j;
intRequestProcess;
inta[100];
请输入进程数：
cin>
>
请输入每个进程的资源数：
请输入每个进程最大需求资源数：
for（j=0;
Max[i][j];
输入每个进程已经分配的资源数：
Allocation[i][j];
for（i=0;
Need[i][j]=Max[i][j]-Allocation[i][j];
//need根据max-allocation算出
请输入可利用资源数：
Available[i];
Safe（）;
请输入你要分配的进程：
RequestProcess;
请输入你分配进程的资源数"
a[i];
//进行初判断
{if（a[i]>
Need[RequestProcess][i]）
输入的请求资源错误（请求的资源数已超过它所宣布的最大值）"
if（a[i]>
Available[i]）
输入的请求资源错误（尚无足够资源）"
else
{Available[i]=Available[i]-a[i];
Allocation[RequestProcess][i]=Allocation[RequestProcess][i]+a[i];
Need[RequestProcess][i]=Need[RequestProcess][i]-a[i];
Safe（）;
运算结果：
进程调度的模拟：
#include"
windows.h"
#include<
conio.h>
stdlib.h>
fstream.h>
io.h>
string.h>
stdio.h>
voidCreate_ProcInfo（）;
//建立进程调度需要的数据
voidDisplay_ProcInfo（）;
//显示当前系统全部进程的状态
voidScheduler_FF（）;
voidCpu_Sched（）;
voidIO_Sched（）;
voidNextRunProcess（）;
voidDisData（）;
voidDisResult（）;
intRunPoint;
//运行进程指针，-1时为没有运行进程
intWaitPoint;
//阻塞队列指针，-1时为没有阻塞进程
intReadyPoint;
//就绪队列指针，-1时为没有就绪进程
longClockNumber;
//系统时钟
intProcNumber;
//系统中模拟产生的进程总数
intFinishedProc;
//进程信息结构
structProcStruct
{intp_pid;
//进程的标识号
charp_state;
//进程的状态，C--运行R--就绪W--组塞B--后备F--完成
intp_rserial[16];
//模拟的进程执行的CPU和I/O时间数据序列，间隔存储，0项存储有效项数
intp_pos;
//当前进程运行到的序列位置
intp_starttime;
//进程建立时间
intp_endtime;
//进程运行结束时间
intp_cputime;
//当前运行时间段进程剩余的需要运行时间
intp_iotime;
//当前I/O时间段进程剩余的I/O时间
intp_next;
//进程控制块的链接指针
}proc[10];
voidCreate_ProcInfo（void）
{ints,i,j;
srand（GetTickCount（））;
//初始化随机数队列的"
种子"
ProcNumber=（（float）rand（）/32767）*5+5;
//随机产生进程数量5~10
FinishedProc=0;
ProcNumber;
i++）//生成进程的CPU--I/O时间数据序列
{proc[i].p_pid=（（float）rand（）/32767）*1000;
proc[i].p_state='
B'
//初始都为后备状态
s=（（float）rand（）/32767）*6+6;
//产生的进程数据序列长度在6~12间
proc[i].p_rserial[0]=s;
//第一项用于记录序列的长度
for（j=1;
=s;
j++）//生成时间数据序列，数值在10~30间
proc[i].p_rserial[j]=（（float）rand（）/32767）*10+5;
//赋其他字段的值
proc[i].p_pos=1;
proc[i].p_starttime=（（float）rand（）/32767）*49+1;
proc[i].p_endtime=0;
proc[i].p_cputime=proc[i].p_rserial[1];
proc[i].p_iotime=proc[i].p_rserial[2];
proc[i].p_next=-1;
}
printf（"
\n---------------------------\n建立了-个进程数据序列\n\n"
ProcNumber）;
DisData（）;
\nPressAnyKeyToContinue......."
）;
_getch（）;
return;
voidDisplay_ProcInfo（void）
{inti,n;
system（"
cls"
）;
\n当前系统模拟-个进程的运行时钟：
%ld\n\n"
ProcNumber,ClockNumber）;
就绪指针=%d,运行指针=%d,阻塞指针=%d\n\n"
ReadyPoint,RunPoint,WaitPoint）;
if（RunPoint!
=-1）
{
当前运行的进程No.%dID：
%d\n"
RunPoint,proc[RunPoint].p_pid）;
m,m,m\n"
proc[RunPoint].p_starttime,proc[RunPoint].p_rserial[proc[RunPoint].p_pos],proc[RunPoint].p_cputime）;
当前运行的进程ID：
NoProcessRunning!
\n"
n=ReadyPoint;
\nReadyProcess......\n"
while（n!
=-1）//显示就绪进程信息
{
printf（"
No.%dID:
],m,m,m\n"
n,proc[n].p_pid,proc[n].p_starttime,proc[n].p_rserial[proc[n].p_pos],proc[n].p_cputime）;
n=proc[n].p_next;
n=WaitPoint;
\nWaitingProcess......\n"
=-1）//显示阻塞进程信息
n,proc[n].p_pid,proc[n].p_starttime,proc[n].p_rserial[proc[n].p_pos],proc[n].p_iotime）;
\n===================后备进程====================\n"
i<
i++）
if（proc[i].p_state=='
）
],m\n"
i,proc[i].p_pid,proc[i].p_starttime）;
\n================已经完成的进程=================\n"
F'
No.%dID:
],m,m\n"
i,proc[i].p_pid,proc[i].p_starttime,proc[i].p_endtime）;
voidDisResult（void）
{inti;
\n---------------------------------\n"
ID=M>
-"
proc[i].p_pid,proc[i].p_rserial[0]）;
M,M"
proc[i].p_starttime,proc[i].p_endtime）;
）;
}
voidDisData（void）
{inti,j;
ID=M->
for（j=1;
j<
=proc[i].p_rserial[0];
M"
proc[i].p_rserial[j]）;
voidNextRunProcess（void）
{
if（ReadyPoint==-1）{RunPoint=-1;
return;
}//就绪队列也没有等待的进程
proc[ReadyPoint].p_state='
C'
RunPoint=ReadyPoint;
proc[ReadyPoint].p_cputime=proc[ReadyPoint].p_rserial[proc[ReadyPoint].p_pos];
ReadyPoint=proc[ReadyPoint].p_next;
proc[RunPoint].p_next=-1;
voidCpu_Sched（void）
{
intn;
if（RunPoint==-1）//没有进程在CPU上执行
{NextRunProcess（）;
proc[RunPoint].p_cputime--;
//进程CPU执行时间减少1个时钟单位
if（proc[RunPoint].p_cputime>
0）return;
//{printf（"
\nRunPoint=%d,ctime=%d"
RunPoint,proc[RunPoint].p_cputime）;
getchar（）;
return;
//进程完成本次CPU后的处理
if（proc[RunPoint].p_rserial[0]==proc[RunPoint].p_pos）//进程全部序列执行完成
FinishedProc++;
proc[RunPoint].p_state='
proc[RunPoint].p_endtime=ClockNumber;
RunPoint=-1;
//无进程执行
NextRunProcess（）;
else//进行IO操作，进入阻塞队列
proc[RunPoint].p_pos++;
proc[RunPoint].p_state='
W'
proc[RunPoint].p_iotime=proc[RunPoint].p_rserial[proc[RunPoint].p_pos];
n=WaitPoint;
if（n==-1）//是阻塞队列第一个I/O进程
WaitPoint=RunPoint;
{do//放入阻塞队列第尾
if（proc[n].p_next==-1）
{proc[n].p_next=RunPoint;
break;
n=proc[n].p_next;
}while（n!
=-1）;
voidIO_Sched（void）
intn,bk;
if（WaitPoint==-1）return;
//没有等待I/O的进程，直接返回
proc[WaitPoint].p_iotime--;
//进行1个时钟的I/O时间
if（proc[WaitPoint].p_iotime>
//还没有完成本次I/O
//进程的I/O完成处理
if（proc[WaitPoint].p_rserial[0]==proc[WaitPoint].p_pos）//进程全部任务执行完成
proc[WaitPoint].p_endtime=ClockNumber;
proc[WaitPoint].p_state='
if（proc[WaitPoint].p_next==-1）
{WaitPoint=-1;
return;
else//调度下一个进程进行I/O操作
n=proc[WaitPoint].p_next;
proc[WaitPoint].p_next=-1;
WaitPoint=n;
proc[WaitPoint].p_iotime=proc[WaitPoint].p_rserial[proc[WaitPoint].p_pos];
else//进行下次CPU操作，进就绪队列
bk=WaitPoint;
WaitPoint=proc[WaitPoint].p_next;
proc[bk].p_pos++;
proc[bk].p_state='
R'
//进程状态为就绪
proc[bk].p_next=-1;
n=ReadyPoint;
if（n==-1）//是就绪队列的第一个进程
{ReadyPoint=bk;
{do
if（proc[n].p_next==-1）{proc[n].p_next=bk;
break;
while（n!
=-1）;
voidNewReadyProc（void）
inti,n;
if（proc[i].p_starttime==ClockNumber）//进程进入时间达到系统时间
proc[i].p_state='
proc[i].p_next=-1;
if（ReadyPoint==-1）//就绪队列无进程
ReadyPoint=i;
else//就绪队列有进程，放入队列尾
while（proc[n].p_next!
=-1）n=proc[n].p_next;
proc[n].p_next=i;
}//for
voidScheduler_FF（void）
if（ProcNumber==0）
{printf（"
必须首先建立进程调度数据！
\n"
ClockNumber=0;
//时钟开始计时,开始调度模拟
while（FinishedProc<
ProcNumber）//执行算法
ClockNumber++;
//时钟前进1个单位
NewReadyProc（）;
//判别新进程是否到达
Cpu_Sched（）;
//CPU调度
IO_Sched（）;
//IO调度
Display_ProcInfo（）;
//显示当前状态
Sleep（800）;
DisResult（）;
getch（）;
intmain（intargc,char*argv[]）
charch;
WaitPoint=-1;
ReadyPoint=-1;
ProcNumber=0;
//当前系统中的进程总数
while（true）
***********************************\n"
1:
建立进程调度数据序列\n"
2:
执行调度算法\n"
3:
显示调度结果\n"
4:
退出\n"
printf（"
Enteryourchoice（1~4）:
do{//如果输入信息不正确，继续输入
ch=（char）_getch（）;
}while（ch!
='
1'
&
&
ch!
2'
3'
4'
if（ch=='
）{printf（"
return0;
}//选择4，退出
）DisResult（）;
//选择3
if（ch=='
）Scheduler_FF（）;
//选择2
）Create_ProcInfo（）;
//选择1
_getch（）;
//结束
\nPressAnyKeyToContinue:
_ge
升级会员 