南昌大学计算机操作系统实验报告Word文件下载.docx

南昌大学计算机操作系统实验报告Word文件下载.docx

《南昌大学计算机操作系统实验报告Word文件下载.docx》由会员分享，可在线阅读，更多相关《南昌大学计算机操作系统实验报告Word文件下载.docx（36页珍藏版）》请在冰豆网上搜索。

P1

322

200

122

P2

902

302

600

P3

222

211

011

P4

433

002

431

假设在此后任一时刻有一个进程P发出请求向量request，通过发出的向量判断是否可以满足需要，如果可以，则假设将该资源予以分配，并通过安全性算法进行检测，如果安全，则找出安全序列，否则系统不安全，将分配的资源回收。

代码设计：

将5个进程的所有信息放在一个对应的结构体structpro【i】中，系统资源数和进程请求资源分别存放在available和request数组中，同时通过建立一个finishi布尔数组来控制和标识5个进程的完成情况,如果最后finish值都为真，则说明分配资源后系统是安全的，否则，不安全并将资源回收。

银行家算法实现代码：

#include<

stdio.h>

stdlib.h>

intmain（void）

{

structprocess

{intmax[3];

intallocation[3];

intneed[3];

}pro[5]={{7,5,3,0,1,0,7,4,3},{3,2,2,2,0,0,1,2,2},

{9,0,2,3,0,2,6,0,0},{2,2,2,2,1,1,0,1,1},

{4,3,3,0,0,2,4,3,1}};

intavailable[3]={3,3,2},request[3];

intwork[3],finish[5]={0};

intm,i,j,k,count=0,number=0;

intr=0,rank[5]={0};

printf（"

\t\2*****************银行家算法*******************\2\n"

）;

Theinformationofprocessesandsystem:

\n"

\tname\tmax\tallocation\tneed\tavailable\n"

for（i=0;

i<

5;

i++）{

printf（"

\t"

P[%d]"

i）;

for（j=0;

j<

3;

j++）

printf（"

%2d"

pro[i].max[j]）;

j++）

pro[i].allocation[j]）;

\t\t"

pro[i].need[j]）;

if（i==0）{

for（j=0;

printf（"

available[j]）;

}

}

pleasechoosetheprocessnumber:

"

scanf（"

%d"

&

m）;

pleaseinputtherequest:

scanf（"

request[i]）;

for（j=0;

if（request[j]<

=pro[m].need[j]）

count++;

if（count==3）{

for（i=0;

i++）

if（request[i]<

=available[i]）

number++;

if（number==3）{

for（k=0;

k<

k++）{

available[k]=available[k]-request[k];

pro[m].allocation[k]=pro[m].allocation[k]+request[k];

pro[m].need[k]=pro[m].need[k]-request[k];

else

{

请求资源不能满足！

exit（0）;

}

else

{

请求资源超过所需！

work[j]=available[j];

L:

count=0;

if（!

finish[i]）{

if（pro[i].need[j]<

=work[j]）

count++;

if（count==3）{

finish[i]=1;

rank[r++]=i;

for（k=0;

k++）

work[k]=work[k]+pro[i].allocation[k];

gotoL;

}

else

count=0;

number=0;

for（k=0;

if（finish[k]==1）

number++;

if（number==5）{

系统处于安全状态！

安全序列为：

\tP[%d]"

rank[i]）;

系统处于不安全状态！

return0;

}运行结果：

六、实验体会或对改进实验的建议

程序比较长，用到了上学期的c语言编程，感觉主要是count比较难把握，程序算法还是比较清晰，就是自己编一个程序有一定难度，必须多加练习了。

做完后对银行家算法有更深的理解。

南昌大学实验报告

---进程调度算法的实现

通过实验加强对进程调度算法的理解和掌握。

编写程序实现进程调度算法，具体可以编写程序实现先来先服务算法或优先度高者调度算法。

1、需写出设计说明；

2、设计实现代码及说明;

3、运行结果

四．实验主要过程和步骤

前三个算法主要是解决进程调度的顺序问题，最后一个时间片轮转调度主要是解决每个进程的完成时间，所以以下算法主要对此进行说明。

FCFS进程调度算法设计：

建立一个结构体数组pro[100]，每个结构体中都存有各进程相关信息，然后输入进程数N确定进程数，并输入各进程的相关信息。

通过fcfs算法对按照所输入进程的arrivetime的大小进行排序，排好的序即为进程调度的执行顺序。

最后再通过对个进程的其他数据进行简单处理即可。

SJF进程调度算法设计：

SJF的算法设计基本同上。

只是在排序过程中稍有不同，它是按照进程的服务时间servetime来安排进程的调度顺序的。

HRF进程调度算法设计：

通过建立add值，对进程执行完后时间的累计，用来计算下一个进程的等待时间，add初始值为第一个进程执行后的完成时间。

从第二个进程开始进行优先级priority的比较，然后记录下优先级最大的进程的标号k，并与第二进程进行调换，下一次再通过同样的方法找到最大优先级的进程同第三个进程进行调换，依次类推直到执行完所有的进程。

其中通过count值控制每次执行的循环次数，l值标明下次所要调换的程序的标号。

时间片轮转调度算法：

首先，用过一个N次的循环计算每个进程的开始时间starttime，对每个进程首先判断pro[i-1].servetime是否小于时间片大小size，如果小于size就让pro[i].starttime等于pro[i-1].starttime加上pro[i-1].servetime，否则的话，就让其加上时间片大小size。

下来接着处理完成时间，首先为每个进程建立resttime的数组，用来存放每个进程执行一次的剩余时间，并将每个进程的servetime值对应的赋给它，然后通过用一个while（count！

=N）的循环控制所有的进程是否完成，最后在这个循环里面对每个进程检测，看它的resttime是否为0，如果为0说明它已经完成，否则判断他的resttime是否小于等于size，如果小于说明本次就能完成本进程，并将time的值赋给finishtime，否则的话就将resttime值减size，并将time值加size，这样不断地循环执行，知道N个进程全部执行完毕。

FCFS进程调度算法实现代码：

charpro_name[10];

floatarrivetime;

floatservetime;

floatstarttime;

floatfinishtime;

floatcircle_time;

floatd_circle_time;

}a[100];

//用结构体存放各进程的相关信息

inti,j,k,N;

processtemp;

请输入进程数:

N）;

//进程数

请输入进程信息（包括进程名、进程到达时间、进程服务时间）:

\n"

N;

请输入第%d个进程的信息:

i+1）;

%s%f%f"

a[i].pro_name,&

a[i].arrivetime,&

a[i].servetime）;

=i;

j++）{

if（a[i].arrivetime<

a[j].arrivetime）{

temp=a[i];

a[i]=a[j];

a[j]=temp;

}}

}//按照FCFS算法对进程进行排序

\nFCFS进程调度顺序为:

%5s"

a[k].pro_name）;

a[0].starttime=a[0].arrivetime;

a[0].finishtime=a[0].servetime+a[0].starttime;

a[0].circle_time=a[0].finishtime-a[0].arrivetime;

a[0].d_circle_time=a[0].circle_time/a[0].servetime；

//计算第一个进程的相关信息

for（i=1;

a[i].starttime=a[i-1].servetime+a[i-1].starttime;

a[i].finishtime=a[i].servetime+a[i].starttime;

a[i].circle_time=a[i].finishtime-a[i].arrivetime;

a[i].d_circle_time=a[i].circle_time/a[i].servetime;

}//计算其他进程的相关信息

\n进程调度列表:

name\tarrive\tserve\tstart\tfinish\tcircle\td_circle\n"

%s\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\n"

a[i].pro_name,

a[i].arrivetime,a[i].servetime,a[i].starttime,a[i].finishtime,

a[i].circle_time,a[i].d_circle_time）;

}运行结果；

fcfs进程调度运行结果

SJF进程调度算法实现代码：

floatstarttime;

floatfinishtime;

floatcircle_time;

floatd_circle_time;

inti,j,k=0,N;

processt;

请输入进程数：

请输入进程信息（包括进程名、进程到达时间、进程服务时间：

\n"

请输入第%d个进程的信息"

floatmin=a[0].arrivetime;

if（a[i].arrivetime<

min）{

min=a[i].arrivetime;

k=i;

temp=a[0];

a[0]=a[k];

a[k]=temp;

for（j=1;

if（a[i].servetime<

a[j].servetime）{

t=a[i];

a[j]=t;

}

\n进程调度顺序为：

a[i].pro_name）;

a[0].finishtime=a[0].servetime+a[0].starttime;

a[0].d_circle_time=a[0].circle_time/a[0].servetime;

for（j=1;

a[j].starttime=a[j-1].servetime+a[j-1].starttime;

a[j].finishtime=a[j].servetime+a[j].starttime;

a[j].circle_time=a[j].finishtime-a[j].arrivetime;

a[j].d_circle_time=a[j].circle_time/a[j].servetime;

a[i].arrivetime,a[i].servetime,a[i].starttime,a[i].finishtime,

}Sjf进程调度运行结果：

HRF算法实现：

charname[10];

floatcycle_time;

floatd_cycle_time;

}pro[100];

inti,j,N,t,k,l=1;

intcount=1;

floatadd,min_arrive,priority,max=0;

请输入进程信息（包括进程名、进程到达时间、进程服务时间）\n"

pro[i].name,&

pro[i].arrivetime,&

pro[i].servetime）;

min_arrive=pro[0].arrivetime;

if（pro[i].arrivetime<

min_arrive）{

min_arrive=pro[i].arrivetime;

t=i;

temp=pro[t];

pro[t]=pro[0];

pro[0]=temp;

add=pro[0].arrivetime+pro[0].servetime;

pro[0].starttime=add;

while（count<

N）{

for（i=count;

if（pro[i].arrivetime<

=add）{

priority=（add-pro[i].arrivetime）/pro[i].servetime;

if（priority>

max）{

max=priority;

k=i;

count++;

add=add+pro[k].servetime;

temp=pro[k];

pro[k]=pro[l];

pro[l]=temp;

pro[l].starttime=add;

l=l+1;

\t%s"

pro[i].name）;

\n\n"

pro[i].finishtime=pro[i].starttime+pro[i].servetime;

pro[i].cycle_time=pro[i].finishtime-pro[i].arrivetime;

pro[i].d_cycle_time=pro[i].cycle_time/pro[i].servetime;

进程调度列表如下：

\2\n"

\tname\tarrive\tserve\tstart\tfinish\tcycle\td_cycle\n"

\t%s\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t\n"

pro[i].name,

pro[i].arrivetime,pro[i].servetime,pro[i].starttime,pro[i].finishtime,

pro[i].cycle_time,pro[i].d_cycle_time）;

}

HRF进程调度运行结果：

charname[10];

floatarrivetime;

floatservetime;

floatstarttime;

floatfinishtime;

floatcycletime;

floatd_cycletime;

}pro[100];

floatsize;

inti,j,N,count=0;

floatresttime[100],time;

\

\t***************时间片轮转调度算法***************\n\n"

pleaseinputtheprocessnumber:

pleaseinputtheprocesses'

information（nameandservetime）:

pleaseinputthe%thprocessinformation:

scanf（"

%s%f"

pleaseinputthesizeoftime:

%f"

size）;

pro[i].arrivetime=0;

pro[0].starttime=0;

for（