caozuoxitong.docx

caozuoxitong.docx

《caozuoxitong.docx》由会员分享，可在线阅读，更多相关《caozuoxitong.docx（47页珍藏版）》请在冰豆网上搜索。

caozuoxitong

华东交通大学软件学院

学生实验报告

课程名称

班级

姓名

学号

专业

指导教师

学期

实验项目名称

处理机调度实验

实验时间

班级

16道铁1班

姓名

乐荣强

学号

2016211002000108

【实验目的】

用高级语言实现一个进程调度程序，以加深对进程概念及进程调度算法的理解。

【实验原理】

先选择时间片的个数和每个时间片需要的时间，正在运行的进程每运行一秒其优先权数目加一，即其优先权减小。

每个时间片运行结束后，选择进入时间片进程优先权数目最小的进程，开始下一个时间片的运行。

如果有进程运行结束，则离开，再在就绪队列中选择优先权数目最小的进程进入。

在运行期间，如果有新的进程来到，按优先权大小放入就绪队列中。

设计一个按优先数调度算法实现处理器调度的程序

（1）假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格

式为：

其中，进程名----作为进程的标识，假设五个进程的进程名分别是P1，P2，P3，P4，P5。

指针----按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块

首地址，最后一个进程中的指针为“0”。

要求运行时间----假设进程需要运行的单位时间数。

优先数----赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态----可假设有两种状态，“就绪”状态和“结束“状态，五个进程的初始状态都为

“就绪“状态，用“R”表示，当一个进程运行结束后，它的状态变为“结束”，

用“E”表示。

（2）在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”

和“要求运行时间”。

（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列，用一单元指出队首

进程，用指针指出队列的连接情况。

（4）处理器调度总是选队首进程运行。

采用动态改变优先数的办法，进程每运行一次优

先数就减“1”。

由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的

启动运行，而是执行：

优先数－1

要求运行时间－1

来模拟进程的一次运行。

提醒注意的是：

在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，

它占有处理器运行，直到出现等待事件或运行结束。

在这里省去了这些工作。

【实验步骤】

#include

#include

#include

#include

usingnamespacestd;

typedefstruct

{

charname;

intArrivalTime;

intServiceTime;

intFinishedTime;

intWholeTime;

doubleWeightWholeTime;

}RR;

staticqueueRRqueue;

staticdoubleAverageWT=0,AverageWWT=0;

staticintq;

staticintn;

staticRRRRarray[100];

voidInput（）

{

cout<<"请输入进程的数量n=";

cin>>n;

cout<<"请输入进程的时间片q=";

cin>>q;

if（q<0||q>9）

{

cout<<"错误！

";

}

exit

（1）;

cout<<"请输入进程的进程名:

"<

for（inti=0;i

{

cin>>RRarray[i].name;

}

cout<<"请输入进程的到达时间:

"<

for（i=0;i

{

cin>>RRarray[i].ArrivalTime;

}

cout<<"请输入进程的服务时间:

"<

for（i=0;i

{

cin>>RRarray[i].ServiceTime;

}

cout<<"---------------------------------------------------------------------------"<

//输出用户所输入的信息

cout<

cout<

cout<

for（i=0;i

{

cout<

cout<

cout<

}

cout<<"---------------------------------------------------------------------------"<

}

voidRRAlgorithm（）

{

charprocessMoment[100];

RRqueue.push（RRarray[0]）;

intprocessMomentPoint=0;

intCurrentTime=0;

inttempTime;

inti=1;

intfinalProcessNumber=0;

intprocessTime[50];

//CurrentTime的初始化

if（RRarray[0].ServiceTime>=q）

{

CurrentTime=q;

}

else

{

CurrentTime=RRarray[0].ServiceTime;

}

while（!

RRqueue.empty（））

{

for（intj=i;j

{

if（RRarray[j].name!

=NULL&&CurrentTime>=RRarray[j].ArrivalTime）

{

RRqueue.push（RRarray[j]）;

i++;

}

}

if（RRqueue.front（）.ServiceTime

{

tempTime=RRqueue.front（）.ServiceTime;

}

else

{

tempTime=q;

}

RRqueue.front（）.ServiceTime-=q;

processMoment[processMomentPoint]=RRqueue.front（）.name;

processMomentPoint++;

processTime[finalProcessNumber]=tempTime;

finalProcessNumber++;

if（RRqueue.front（）.ServiceTime<=0）

{

//RRqueue.front（）.FinishedTime=CurrentTime;

RRqueue.pop（）;

}

else

{

RRqueue.push（RRqueue.front（））;

RRqueue.pop（）;

}

CurrentTime+=tempTime;

}

cout<<"各进程的执行时刻信息：

"<

cout<<""<<"0时刻到"<

（2）<

processTime[finalProcessNumber]=0;

inttime=processTime[0];

intcount=0;

for（i=0;i

{

count=0;

cout<

while（RRarray[count].name!

=processMoment[i]&&count

{

count++;

}

RRarray[count].FinishedTime=time;

if（i

{

cout<

（2）<

time+=processTime[i+1];

}

}

cout<

for（i=0;i

{

RRarray[i].WholeTime=RRarray[i].FinishedTime-RRarray[i].ArrivalTime;

RRarray[i].WeightWholeTime=（double）RRarray[i].WholeTime/RRarray[i].ServiceTime;

}

doublex=0,y=0;

for（i=0;i

{

x+=RRarray[i].WholeTime;

y+=RRarray[i].WeightWholeTime;

}

AverageWT=x/n;

AverageWWT=y/n;

}

voiddisplay（）

{

cout<<"---------------------------------------------------------------------------"<

cout<<"RR调度算法执行后：

进程相关信息如下：

"<

cout<

cout<

cout<

cout<

cout<

cout<

for（inti=0;i

{

cout<

cout<

cout<

cout<

cout<

cout<

}

cout<<"所有进程的平均周转时间="<

cout<<"所有进程的平均带权周转时间="<

cout<<"---------------------------------------------------------------------------4"<

}

intmain（）

{

Input（）;

RRAlgorithm（）;

display（）;

system（"pause"）;

return0;

}

【实验结果和分析】

当输入的进程数量不为0-9范围内时，输出：

【实验小结】

本次实验通过课本处理器调度的进程的初步认识和实验按优先数调度算法实现处理器调度的实现，了解到进程与进程控制块之间的联系，进程运行过程中状态以及已运行时间的判断和计算，选中运行的进程名以及选中进程运行后的各进程控制块状态。

实验项目名称

存储管理

实验时间

班级

16道铁1班

姓名

乐荣强

学号

2016211002000108

【实验目的】

1、了解存储管理在内存空间分配的作用

2、一个好的计算机系统不仅要有一个足够容量的、存取速度高的、稳定可靠的主存储器，而且要能合理地分配和使用这些存储空间。

当用户提出申请存储器空间时，存储管理必须根据申请者的要求，按一定的策略分析主存空间的使用情况，找出足够的空闲区域分配给申请者。

当作业撤离或主动归还主存资源时，则存储管理要收回作业占用的主存空间或归还部分主存空间。

熟悉主存的分配与回收。

理解在不同的存储管理方式下，如何实现主存空间的分配与回收。

掌握动态分区分配方式中的数据结构和分配算法及动态分区存储管理方式及其实现过程。

【实验原理】

一、首次适应算法（FirstFit）：

该算法从空闲分区链首开始查找，直至找到一个能满足其大小要求的空闲分区为止。

然后再按照作业的大小，从该分区中划出一块内存分配给请求者，余下的空闲分区仍留在空闲分区链中。

特点：

该算法倾向于使用内存中低地址部分的空闲区，在高地址部分的空闲区很少被利用，从而保留了高地址部分的大空闲区。

显然为以后到达的大作业分配大的内存空间创造了条件。

缺点：

低地址部分不断被划分，留下许多难以利用、很小的空闲区，而每次查找又都从低地址部分开始，会增加查找的开销。

二、最佳适应算法（BestFit）：

该算法总是把既能满足要求，又是最小的空闲分区分配给作业。

为了加速查找，该算法要求将所有的空闲区按其大小排序后，以递增顺序形成一个空白链。

这样每次找到的第一个满足要求的空闲区，必然是最优的。

孤立地看，该算法似乎是最优的，但事实上并不一定。

因为每次分配后剩余的空间一定是最小的，在存储器中将留下许多难以利用的小空闲区。

同时每次分配后必须重新排序，这也带来了一定的开销。

特点：

每次分配给文件的都是最合适该文件大小的分区。

缺点：

内存中留下许多难以利用的小的空闲区。

三、最坏适应算法（WorstFit）：

最坏适应算法是将输入的作业放置到主存中与它所需大小差距最大的空闲区中。

空闲区大小由大到小排序。

特点：

尽可能地利用存储器中大的空闲区。

缺点：

绝大多数时候都会造成资源的严重浪费甚至是完全无法实现分配。

【实验步骤】

#include

usingnamespacestd;

constintMax_length=640;

inta,b;//a记录算法编号，b记录操作编号

structfreearea

{

intID;

intsize;

intaddress;

boolflag;

};

typedefstructDuNode

{

freeareadata;

DuNode*prior;

DuNode*next;

}*DuLinkList;

DuLinkListm_rid=newDuNode,m_last=newDuNode;

voidinit（）

{

m_rid->prior=NULL;

m_rid->next=m_last;

m_last->prior=m_rid;

m_last->next=NULL;

m_rid->data.size=0;

m_last->data.address=0;

m_last->data.size=Max_length;

m_last->data.ID=0;

m_last->data.flag=0;//!

!

!

}

voidshow（）

{

DuNode*p=m_rid->next;

cout<<"+++++++++++++++++++++++++++++++++++++++"<

while（p）

{

cout<<"分区号：

";

if（p->data.ID==0）

cout<<"FREE"<

else

cout<data.ID<

cout<<"分区起始地址：

"<data.address<

cout<<"分区大小：

"<data.size<

cout<<"分区状态：

";

if（p->data.flag）

cout<<"已被占用"<

else

cout<<"空闲"<

cout<<"——————————————————"<

p=p->next;

}

}

boolfirst_fit（intid,intm_size）

{

DuNode*p=m_rid->next;

DuLinkListfa=newDuNode;

//memset（fa,0,sizeof（DuNode））;

fa->data.ID=id;

fa->data.size=m_size;

fa->data.flag=1;

while（p）

{

if（p->data.size>=m_size&&!

p->data.flag）

{

if（p->data.size==m_size）

{

p->data.ID=id;

p->data.flag=1;

free（fa）;//清空新创建的空闲区

returntrue;

}

elseif（p->data.size>m_size）

{

fa->data.address=p->data.address;

p->data.address+=m_size;

p->data.size-=m_size;

p->prior->next=fa;

fa->next=p;

fa->prior=p->prior;

p->prior=fa;

returntrue;

}

}

p=p->next;

}

free（fa）;

returnfalse;

}

boolbest_fit（intid,intm_size）

{

DuNode*p=m_rid->next;

DuNode*q=NULL;

DuLinkListfa=newDuNode;

memset（fa,0,sizeof（DuNode））;

fa->data.ID=id;

fa->data.size=m_size;

fa->data.flag=1;

intd=Max_length;

while（p）

{

if（p->data.size>=m_size&&!

p->data.flag）

{

if（p->data.size-m_size

{

q=p;

d=q->data.size-m_size;

}

}

p=p->next;

}

if（q==NULL）

returnfalse;

else

{

if（d==0）

{

p->data.ID=id;

p->data.flag=1;

free（fa）;

returntrue;

}

Else

{

fa->data.address=q->data.address;

q->data.address+=m_size;

q->data.size-=m_size;

q->prior->next=fa;

fa->next=q;

q->prior=fa;

fa->prior=q->prior;

returntrue;

}

}

}

boolallocation（）

{

intid,m_size;

cout<<"请输入作业编号（分区号）和申请的内存大小（KB）：

";

cin>>id>>m_size;

if（m_size<=0）

{

cout<<"申请的内存大小错误！

请重新输入"<

returnfalse;

}

if（a==1）

{

if（first_fit（id,m_size））

{

cout<<"内存分配成功！

"<

show（）;

}

else

cout<<"内存不足，分配失败！

"<

returntrue;

}

if（a==2）

{

if（best_fit（id,m_size））

{

cout<<"内存分配成功！

"<

show（）;

}

else

cout<<"内存不足，分配失败！

"<

returntrue;

}

}

voidrecycle（）

{

intid;

cout<<"请输入想要释放的作业号：

";

cin>>id;

DuNode*p=m_rid->next;

DuNode*p1=NULL;

while（p）

{

if（p->data.ID==id）

{

p->data.ID=0;

p->data.flag=0;

if（!

p->prior->data.flag）

{

p->prior->data.size+=p->data.size;

p->prior->next=p->next;

p->next->prior=p->next;

}

if（!

p->next->data.flag）

{

p->data.size+=p->next->data.size;

p->next->next->prior=p;

p->n