模拟操作系统的设计与实现Word文档格式.docx
- 文档编号:22944045
- 上传时间:2023-02-06
- 格式:DOCX
- 页数:100
- 大小:656.37KB
模拟操作系统的设计与实现Word文档格式.docx
《模拟操作系统的设计与实现Word文档格式.docx》由会员分享,可在线阅读,更多相关《模拟操作系统的设计与实现Word文档格式.docx(100页珍藏版)》请在冰豆网上搜索。
最后对试分配后的状态调用安全性检查算法进行安全性检查。
若安全,则分配;
否则,不分配,恢复原来状态,拒绝申请。
㈢主存的可变分区管理:
1.可变分区存储管理:
又称为动态分区模式,按照作业的大小来划分分区,但划分的时间、大小、位置都是动态的。
㈣虚拟存储器管理:
1.最近最少使用页面替换算法(LRU):
在LRU算法中,被淘汰的页面是在最近一段时间内最久未被访问的那一页。
2.最佳页面替换算法(OPT):
它是由Belady于1966年提出的一种理论上的算法。
其所选择的被淘汰页面,将是以后永不使用的或者是在最长(未来)时间内不再被访问的页面。
采用最佳置换算法,通常可保证获得最低的缺页率。
3.先进先出页面替换算法(FIFO):
基于程序总是按线性顺序来访问物理空间这一假设,总是淘汰最先调入主存的页面,即淘汰在主存中驻留时间最长的页面,认为驻留时间最长的页不再使用的可能性较大。
㈤磁盘空间的管理:
1.位示图:
位示图用若干个字构成,每一位对应一个磁盘块,“1”表示占用,“0”表示空闲。
2.空白文件目录:
空白文件目录表用来对整个磁盘的未用空间进行管理,每个空白文件占用其中的一个表目。
㈥磁盘的驱动调度管理:
1.先来先服务算法(FCFS):
这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单,且每个进程的请求都能依次得到处理,不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化,在对磁盘的访问请求比较多的情况下,此算法将降低设备服务的吞吐量,致使平均寻道时间可能较长,但各进程得到服务的响应时间的变化幅度较小。
2.最短查找时间优先算法(SSTF):
该算法选择这样的进程,其要求访问的磁道与当前磁头所在的磁道距离最近,以使每次的寻道时间最短,该算法可以得到比较好的吞吐量,但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的,因而导致响应时间的变化幅度很大。
在服务请求很多的情况下,对内外边缘磁道的请求将会无限期的被延迟,有些请求的响应时间将不可预期。
3.电梯调度算法:
每次总是选择沿移动臂的移动方向最近的那个柱面,若同一柱面上有多个请求,还需进行旋转优化。
如果当前移动方向上没有访问请求时,就改变移动臂的移动方向,然后处理所遇到的最近的I/O请求。
四、详细设计
1.定义两个结构体worktime和jcb,具体功能分别如下:
structworktime
{
floatTb;
//作业运行时刻
floatTc;
//作业完成时刻
floatTi;
//周转时间
floatWi;
//带权周转时间
};
structjcb
{
charname[10];
//作业名
floatsubtime;
//作业到达时间
floatruntime;
//作业所需的运行时间
charresource;
//所需资源
floatRp;
//后备作业响应比
charstate;
//作业状态
intworked_time;
//已运行时间
structworktimewt;
intneed_time;
//要求运行时间
intflag;
//进程结束标志
structjcb*link;
//链指针
}
2.完整的源程序如下:
#include<
iostream>
stdio.h>
#include<
stdlib.h>
conio.h>
usingnamespacestd;
#definegetpch(type)(type*)malloc(sizeof(type))//为进程创建一个空间
structworktime{
structjcb{
}*ready=NULL,*p;
typedefstructjcbJCB;
floatT=0;
intN;
JCB*front,*rear;
//时间轮转法变量
voidsort()
JCB*first,*second;
intinsert=0;
//插入数
if((ready==NULL)||((p->
subtime)<
(ready->
subtime)))
{
p->
link=ready;
ready=p;
T=p->
subtime;
Rp=1;
}
else
first=ready;
second=first->
link;
while(second!
=NULL)
if((p->
(second->
subtime))
link=second;
first->
link=p;
second=NULL;
insert=1;
first=first->
second=second->
if(insert==0)first->
voidSJFget()//最短作业优先算法
JCB*front,*mintime,*rear;
intipmove=0;
mintime=ready;
rear=mintime->
while(rear!
if((rear!
=NULL)&
&
(T>
=rear->
subtime)&
(mintime->
runtime)>
(rear->
runtime))
front=mintime;
mintime=rear;
rear=rear->
ipmove=1;
if(ipmove==1)
front->
link=mintime->
mintime->
ready=mintime;
voidcreatJCB()//为每个作业创建一个JCB并初始化形成一个循环链队列
JCB*p,*l;
inti=0;
l=(JCB*)malloc(sizeof(JCB));
cout<
<
"
\n请输入作业的个数:
;
scanf("
%d"
&
N);
printf("
\n作业号No.%d:
\n"
i);
\n请输入作业的名字:
);
%s"
l->
name);
\n请输入作业的时间:
l->
need_time);
l->
state='
r'
//作业初始状态为就绪
worked_time=0;
link=NULL;
flag=0;
front=l;
for(i=1;
i<
N;
i++)
p=(JCB*)malloc(sizeof(JCB));
p->
p->
state='
worked_time=0;
l=l->
rear=l;
rear->
link=front;
}
voidoutput()//进程输出函数
intj;
nameruntimeneedtimestate\n"
for(j=1;
j<
=N;
j++)
{printf("
%-4s\t%-4d\t%-4d\t%-c\n"
front->
name,front->
worked_time,front->
need_time,front->
state);
front=front->
intjudge(JCB*p)//判断所有进程运行结束
intflag=1,i;
for(i=0;
if(p->
state!
='
e'
)
flag=0;
break;
p=p->
returnflag;
voidRRget()//时间片轮转算法
JCB*s;
intflag1=0;
s=(JCB*)malloc(sizeof(JCB));
s=front;
\n--------------------------------------------\n"
output();
请输入任意一键继续\n"
getch();
//按任意键继续
while(flag1!
=1)
if(s->
state=='
s->
worked_time++;
need_time--;
need_time==0)
请输入任意一键继续...\n"
s->
flag==0)
进程%s已经运行完成!
\n\n"
s->
flag=1;
s=s->
flag1=judge(s);
--------------------------------------------\n"
voidinput()
inti,num;
num);
num;
p=getpch(JCB);
\n输入作业名:
\n输入作业到达时刻:
%f"
subtime);
\n输入作业运行时间:
runtime);
w'
sort();
intspace()
intl=0;
JCB*jr=ready;
while(jr!
l++;
jr=jr->
return(l);
voiddisp(JCB*jr,intselect)
if(select==3)printf("
\n作业到达时间服务时间响应比运行时刻完成时刻周转时间带权周转时间\n"
elseprintf("
\n作业到达时间服务时间运行时刻完成时刻周转时间带权周转时间\n"
%s\t"
jr->
%.2f\t"
%.2f\t"
if(select==3&
p==jr)printf("
%.2f"
Rp);
if(p==jr){
%.2f\t"
wt.Tb);
%.2f"
wt.Tc);
wt.Ti);
%.2f"
wt.Wi);
intdestroy()
\n作业[%s]已完成.\n"
free(p);
return
(1);
voidcheck(intselect)
JCB*jr;
\n****当前正在运行的作业是:
disp(p,select);
jr=ready;
\n****当前就绪队列状态为:
jr->
Rp=(jr->
runtime+T-jr->
subtime)/jr->
runtime;
disp(jr,select);
destroy();
voidrunning(JCB*jr)
if(T>
=jr->
subtime)jr->
wt.Tb=T;
elsejr->
wt.Tb=jr->
wt.Tc=jr->
wt.Tb+jr->
wt.Ti=jr->
wt.Tc-jr->
wt.Wi=jr->
wt.Ti/jr->
T=jr->
wt.Tc;
intmain()
intselect=0,len,h=0;
floatsumTi=0,sumWi=0;
\t---*****************---\n"
请选择作业调度算法的方式:
\t1.先来先服务2.最短作业优先3.时间片轮转法\n\n"
请输入作业调度算法序号(1-3):
select);
if(select==3)
{creatJCB();
RRget();
input();
len=space();
while((len!
=0)&
(ready!
=NULL))
h++;
\n执行第%d个作业\n"
h);
p=ready;
ready=p->
R'
running(p);
sumTi+=p->
wt.Ti;
sumWi+=p->
wt.Wi;
check(select);
if(select==2&
h<
len-1)SJFget();
\n按任意一键继续......"
getchar();
\n\n作业已经完成.\n"
\t此组作业的平均周转时间:
%.2f\n"
sumTi/h);
\t此组作业的带权平均周转时间:
sumWi/h);
return0;
1.定义进程控制块pcb的类,用于存放和处理进程的相关信息,如下:
classpcb
public:
intp_pid;
intp_stat;
intp_apply;
intp_occupy;
boolp_issuc;
intp_require;
pcb(intid,intrequire)
p_pid=id;
p_require=require;
p_stat=TASK_RUNNING;
p_occupy=0;
p_issuc=false;
p_apply=0;
friendostream&
operator<
(ostream&
cout,constpcb&
p)
cout<
p.p_pid<
'
\t'
p.p_stat<
p.p_require<
p.p_occupy<
endl;
returncout;
vector>
iterator>
fstream>
constintTASK_RUNNING=0;
constintTASK_SUCCEED=1;
constintTASK_WAITING=2;
ofstreamff("
result.txt"
constintRMAX=10;
//系统拥有的最大资源数
constintPMAX=4;
//系统运行的最大进程数
intRcs_left=RMAX;
voidrand(vector<
pcb>
pgrp);
voidbanker(vector<
//定义的子函数
voidwakeup(vector<
pgrp,intavailable);
boolisFinished(vector<
boolisSafeState(vector<
vector<
:
iteratorgetFirstRunningProcess(vector<
voidreadApply(vector<
iteratorproc);
vector<
pgrp;
//输入各进程申请的资源总量,以及初始化各个进程
ENTERTHEMAXNUMBERFORTHEREQUESTEDRESOURCE:
processID\tREQUESTED"
ff<
intqty;
for(inti
(1);
=PMAX;
do
{
cout<
process"
\t"
ff<
cin>
>
qty;
}while(qty<
1||
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 模拟 操作系统 设计 实现