计算机操作系统课程设计报告文档格式.docx
《计算机操作系统课程设计报告文档格式.docx》由会员分享，可在线阅读，更多相关《计算机操作系统课程设计报告文档格式.docx（90页珍藏版）》请在冰豆网上搜索。
（2）.对给定的序列分别使用上面的几种算法进行调度，计算每种算法下的平均周转时间和平均带权周转时间。
3.实验代码：
#include<
stdio.h>
string.h>
stdlib.h>
/********************这是先来先服务的程序*********************************/
structfcfs{//定义先来先服务结构体、参数
charname[10];
floatdaodatime;
//到达时间
floatfuwutime;
//服务时间
floatkaishitime;
//开始时间
floatwanchengtime;
//完成时间
floatzhouztime;
//周转时间
floatdaiquantime;
//带权周转时间
};
fcfsa[100];
voidinput（fcfs*p,intN）//构造一个输入进程的信息的函数，定义结构体指针
{
inti;
for（i=0;
i<
=N-1;
i++）
{
printf（"
输入第%d个进程的名字、到达时间、服务时间:
\n"
i+1）;
scanf（"
%s%f%f"
&
p[i].name,&
p[i].daodatime,&
p[i].fuwutime）;
//把输入的信息保存到结构体指针所对应的内存中
}
}//构造一个输出函数
voidPrint（fcfs*p,floatdaodatime,floatfuwutime,floatkaishitime,floatwanchengtime,floatzhouztime,floatdaiquantime,intN）
{
intk;
执行顺序:
）;
%s"
p[0].name）;
for（k=1;
k<
N;
k++）
printf（"
-->
p[k].name）;
\n进程的相关信息如下:
\n名字\t到达\t服务\t开始\t完成\t周转\t带权周转\n"
for（k=0;
{
%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n"
p[k].name,p[k].daodatime,p[k].fuwutime,p[k].kaishitime,p[k].wanchengtime,p[k].zhouztime,p[k].daiquantime）;
}//题目中加入-.2是保留双精度的两位。
一般f默认保留六位小数的。
}
voidsort（fcfs*p,intN）//进程根据到达时间进行排序
for（inti=0;
for（intj=0;
j<
=i;
j++）
if（p[i].daodatime<
p[j].daodatime）//如果i的时间到达时间小于j的到达时间，就交换
{
fcfstemp;
//在结构体中定义第三个变量进行交换
temp=p[i];
p[i]=p[j];
p[j]=temp;
}
//核心的运行阶段
voiddeal（fcfs*p,floatdaodatime,floatfuwutime,floatkaishitime,floatwanchengtime,floatzhouztime,floatdaiquantime,intN）
{intk;
if（k==0）//K=0,表示第一个进程到达
{
p[k].kaishitime=p[k].daodatime;
//那么开始时间=到达时间
p[k].wanchengtime=p[k].daodatime+p[k].fuwutime;
//完成时间=到达时间+服务时间
}
else
p[k].kaishitime=p[k-1].wanchengtime;
//下一个进程的开始时间=上一个进程的完成时间
p[k].wanchengtime=p[k-1].wanchengtime+p[k].fuwutime;
//完成时间=上一个进程的完成时间+服务时间
}
k++）//计算周转时间和带权周转时间
p[k].zhouztime=p[k].wanchengtime-p[k].daodatime;
//周转时间=完成时间-到达时间
p[k].daiquantime=p[k].zhouztime/p[k].fuwutime;
//带权周转时间=周转时间/服务时间
voidFCFS（fcfs*p,intN）//定义先来先服务函数
floatdaodatime=0,fuwutime=0,kaishitime=0,wanchengtime=0,zhouztime=0,daiquantime=0;
//初始化变量为0
sort（p,N）;
//声明排序函数
deal（p,daodatime,fuwutime,kaishitime,wanchengtime,zhouztime,daiquantime,N）;
//声明运行函数
Print（p,daodatime,fuwutime,kaishitime,wanchengtime,zhouztime,daiquantime,N）;
//声明输出函数
/***********************这是算法时间片轮转法的代码*****************************************/
structshijian{//定义时间片的结构体
charname;
//定义进程名
intdaodatime;
//到达时间
intfuwutime;
//服务时间
intshengyutime;
//剩余时间
char*state;
//所处状态
structshijian*next;
structshijian*time（）
inta,i;
structshijian*head,*rear,*p,*q,*t;
//定义队首、队尾、P是队尾指针、Q是队首指针和执行时间
head=rear=NULL;
//初始化队首和队尾为空
请输入进程数目：
"
%d"
a）;
a;
p=（structshijian*）malloc（sizeof（structshijian））;
//初始化一个空间给进程进入
%s%d%d"
p->
name,&
daodatime,&
fuwutime）;
p->
shengyutime=p->
fuwutime;
state="
就绪"
;
if（rear==NULL）//当输入结束时，把P的数据放到队首，以便执行下一步
head=p;
next=NULL;
rear=p;
else//否则执行时间就为空，队首变成Q
t=NULL;
q=head;
while（q&
&
q->
daodatime<
daodatime）//当Q和Q的到达时间小于P的到达时间时，把执行时间给Q
{
t=q;
q=q->
next;
if（q==head）//而当Q是队首时，则下一个队首变成P，以便每个进程都能够得到时间片
p->
next=head;
head=p;
elseif（t==rear）//当执行时间片到达队尾时（执行完时），返回给队首P
rear->
next=p;
else//否则给队首P占用执行时间，P执行完后到Q
t->
next=q;
}
}
returnhead;
//返回队首
voidoutput（structshijian*head）//定义输出函数
structshijian*p,*t,*r;
intnum;
请输入时间片:
num）;
while（head!
=NULL）//当队首不为空时，把P给队首
r=p=head;
while（p!
=NULL）//把执行时间给队首
t=head;
shengyutime-num;
//P的剩余时间=剩余时间-时间片
运行"
//状态变成运行态
if（p->
shengyutime<
0）//当P运行完，即剩余时间小于0时，仍然把它当做0处理
shengyutime=0;
\n************程序开始运行*****************\n"
进程到达时间服务时间剩余时间当前状态\n"
while（t!
=NULL）//时间不为空时，输出当前进程的信息，并把时间片交给下一个进程
printf（"
%2c%8d%8d%14d%10s\n"
t->
name,t->
daodatime,t->
fuwutime,t->
shengyutime,t->
state）;
t=t->
getchar（）;
//按住回车键观看
if（p->
shengyutime==0）//当队首的剩余时间为0时，先把队首改成P的下一个，然后释放内存，删除队首节点
if（p==head）
{
head=p->
free（p）;
p=head;
}
else//否则返回执行，把队尾的下一个指针变成P的下一个指针，队尾的位置移动到队首
r->
next=p->
p=r->
r=p;
}
else//否则把队首的位置给队尾，把队首的状态显示为“就绪”状态
r=p;
p=p->
}
/****************************这是优先服务调度算法的代码***********************************/
typedefstructPCB2
charname[10];
//进程名
intruntime;
//要求运行时间
intfrist;
//定义优先数
charzhuangtai;
//定义状态，R为就绪，F为完成
structPCB2PCBcontrol[4];
//定义进程控制块数组
voidyouxian（）//构造优先函数
inti,n;
请输入进程的个数:
n）;
请输入进程的名字、优先权、运行时间\n"
n;
请输入第%d个进程的信息:
scanf（"
PCBcontrol[i].name,&
PCBcontrol[i].frist,&
PCBcontrol[i].runtime）;
PCBcontrol[i].zhuangtai='
R'
//进程初始状态均为就绪
getchar（）;
//等待回车进入下一次运行
intmax_frist_process（）//确定最大优先级进程子程序
intmax=-10;
//max为最大优先数，初始化为-10
inti,key;
3;
i++）
if（PCBcontrol[i].zhuangtai=='
r'
）//r表示正在运行
return-1;
//返回-1
else
if（max<
PCBcontrol[i].frist&
PCBcontrol[i].zhuangtai=='
）//从就绪进程中选取优先数最大的进程
max=PCBcontrol[i].frist;
//max存放每次循环中的最大优先数
key=i;
//将进程号赋给key
if（PCBcontrol[key].zhuangtai=='
F'
）//具有最大优先数的进程若已运行完毕
return-1;
//则返回-1
else
returnkey;
//将key作为返回值返回
voidshow（）//显示函数
\n进程名优先级运行时间当前状态\n"
*****************************************\n"
i++）//依次显示每个进程的名、优先数、要求运行时间和状态
%s\t%d\t%d\t%s\t\n"
PCBcontrol[i].name,PCBcontrol[i].frist,PCBcontrol[i].runtime,&
PCBcontrol[i].zhuangtai）;
\n请按回车键进行查看"
voidrun（）//进程运行子程序
inti,j;
intt=0;
//t为运行次数
for（j=0;
t+=PCBcontrol[j].runtime;
}//运行次数即为各个进程运行时间之和
\n进程没运行前，当前的状态是:
show（）;
//调用show（）子程序显示运行前PCB的情况
for（j=0;
t;
j++）
while（max_frist_process（）!
=-1）//具有最大优先数的进程没有运行完，让其运行
PCBcontrol[max_frist_process（）].zhuangtai='
//将其状态置为r，表示其正在运行
for（i=0;
if（PCBcontrol[i].zhuangtai=='
）
PCBcontrol[i].frist-=1;
//将当前运行进程的优先数减1
PCBcontrol[i].runtime--;
//要求运行时间减1
{
if（PCBcontrol[i].runtime==0）
PCBcontrol[i].zhuangtai='
//运行完则将该进程状态置为结束
else
//未运行完将其状态置为就绪
}
show（）;
//显示每次运行后各PCB的情况
getchar（）;
}
voidmain（）
intN;
intnumber;
charTishikuang;
//提示框
do{
***************************************************************************\n"
**************************************************************************\n"
************************【进程调度算法】******************************\n"
**输入1—先来先服务*\n"
**输入2—时间片轮转法*\n"
**输入3—优先服务法*\n"
**输入0—退出该程序*\n"
***********************************************************************\n"
\n提示:
请根据自己的需求选择相应的操作数：
number）;
/*提示输入字母，用switch语句存入到case中，最后增加提示框是否继续*/
switch（number）
case0:
break;
case1:
\n您选择的是“先来先服务项目”\n\n"
请输入进程的数量:
N）;
input（a,N）;
FCFS（a,N）;
case2:
printf（"
\n您选择的是“时间片轮转法项目”\n\n"
structshijian*head;
//定义时间片的队首结构体
head=time（）;
//队首执行的时间
output（head）;
//输出函数
case3:
\n您选择的是“优先服务项目”，本程序可提供3个进程的调度。
\n\n"
youxian（）;
//初始化各个进程PCB
run（）;
//进程调度模拟
break;
default:
\n你的输入有误，请确定是从0到3之间进行输入，O（∩_∩）O谢谢\n"
\n是否继续操作（y/n）?
fflush（stdin）;
Tishikuang=getchar（）;
}while（Tishikuang=='
y'
||Tishikuang=='
Y'
银行家算法
不加控制的程序并发执行很容易导致进程间发生死锁，因此现代操作系统设计的一个重要内容就是追求在付出代价较小的前提下，消除系统中的死锁现象。
目前解决死锁的方法很多，使用银行家算法来控制资源分配是其中较好的一种。
本实验的目的是通过编程实现银行家算法，加深读者对算法的理解。
编程实现银行家算法，程序功能包括建立描述进程和资源的数据结构。
输入某时刻进程和资源的状态信息，即进程的执行情况与资源的分配情况，这些信息可以从键盘输入，也可以从磁盘读入。
随着程序的执行，将系统进程，资源的情况显示在屏幕上，注意将安全性算法的执行过程也按类似下面的样子显示在屏幕上。
进程可以随时发出新的资源请求。
可以将数据存入磁盘文件，也可从文件中读入数据。
用程序计算
T0时刻的安全性
P1请求向量request1（1,0,2）；
P4请求向量request4（3,3,0）；
P0请求向量request0（0,2,0）；
数据结构：
#defineFalse0
#defineTrue1
intMax[100][100]={0};
//各进程所需各类资源的最大需求
intAvaliable[100]={0};
//系统可用资源
charname[100]={0};
//资源的名称
intAllocation[100][100]={0};
//系统已分配资源
intNeed[100][100]={0};
//还需要资源
intRequest[100]={0};
//请求资源向量
inttemp[100]={0};
//存放安全序列
intWork[100]={0};
//存放系统可提供资源
intM=100;
//作业的最大数为100
intN=100;
//资源的最大数为100
voidshowdata（）//显示资源矩阵
源代码：
iostream.h>
//还需要资
升级会员 