操作系统实验.docx

操作系统实验.docx

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

操作系统实验

课程名称___操作系统实验____________

学生学院__计算机学院_______________

专业班级___16网络（3）班

学号__3116005002_______________

学生姓名___郭泽锋__________________

指导教师_____彭重嘉________________

2019年1月4日

实验指导书

每个同学必须提交的资料如下图所示：

包括可运行的实验程序和源代码，以及实验报告

—.课程的性质、目的和任务

操作系统是计算机系统配置的基本软件之一。

它在整个计算机系统软件中占有中心地位。

其作用是对计算机系统进行统一的调度和管理，提供各种强有力的系统服务，为用户创造既灵活又方便的使用环境。

本课程是计算机及应用专业的一门专业主干课和必修课。

　　　通过本课程的学习,使学生掌握操作系统的基本概念、设计原理及实施技术,具有分析操作系统和设计、实现、开发实际操作系统的能力。

　二.实验的意义和目的

　　操作系统是计算机教学中最重要的环节之一，也是计算机专业学生的一门重要的专业课程。

操作系统质量的好坏，直接影响整个计算机系统的性能和用户对计算机的使用。

一个精心设计的操作系统能极大地扩充计算机系统的功能，充分发挥系统中各种设备的使用效率，提高系统工作的可靠性。

由于操作系统涉及计算机系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性。

要学好这门课程，必须把理论与实践紧密结合，才能取得较好的学习效果。

　　培养计算机专业的学生的系统程序设计能力，是操作系统课程的一个非常重要的环节。

通过操作系统上机实验，可以培养学生程序设计的方法和技巧，提高学生编制清晰、合理、可读性好的系统程序的能力，加深对操作系统课程的理解。

使学生更好地掌握操作系统的基本概念、基本原理、及基本功能,具有分析实际操作系统、设计、构造和开发现代操作系统的基本能力。

　三.实验运行环境及上机前的准备

✧实验运行环境:

C语言编程环境

✧上机前的准备工作包括：

按实验指导书要求事先编好程序；

准备好需要输入的中间数据；

估计可能出现的问题；

预计可能得到的运行结果。

　四.实验内容及安排 

实验一进程调度

编写并调试一个模拟的进程调度程序，采用“短进程优先”调度算法对五个进程进行调度。

以加深对进程的概念及进程调度算法的理解．

下面是采用动态优先数的调度程序，可作参考。

 例题：

设计一个有N个进程共行的进程调度程序。

 　进程调度算法：

采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。

　　每个进程有一个进程控制块（PCB）表示。

进程控制块可以包含如下信息：

进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

　　进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。

进程的到达时间为进程输入的时间。

　　进程的运行时间以时间片为单位进行计算。

　　每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。

　　就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

　　如果运行一个时间片后，进程的已占用CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。

　　每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB，以便进行检查。

重复以上过程，直到所要进程都完成为止。

进程调度源程序如下：

jingchendiaodu.cpp

#include"stdio.h"

#include

#include

#include

#definegetpch（type）（type*）malloc（sizeof（type））

#defineNULL0

structpcb{/*定义进程控制块PCB*/

charname[10];

charstate;

intsuper;

intntime;

structpcb*link;

}*ready=NULL,*p;

typedefstructpcbPCB;

voidsort（）/*建立对进程进行短程序排列函数*/

{

PCB*first,*second;

intinsert=0;

if（（ready==NULL）||（（p->ntime）<（ready->ntime）））

{

p->link=ready;

ready=p;

}

else/*进程比较运行时间,插入适当的位置中*/

{

first=ready;

second=first->link;

while（second!

=NULL）

{

if（（p->ntime）<（second->ntime））

{/*插入到当前进程前面*/

p->link=second;

first->link=p;

second=NULL;

insert=1;

}

else

{

first=first->link;

second=second->link;

}

}

if（insert==0）first->link=p;

}

}

voidinput（）/*建立进程控制块函数*/

{

inti,num;

system（"cls"）;/*清屏*/

printf（"\n请输入进程号?

"）;

scanf（"%d",&num）;

for（i=0;i

{

printf（"\n进程号No.%d:

\n",i）;

p=getpch（PCB）;

printf（"\n输入进程名:

"）;

scanf（"%s",p->name）;

printf（"\n输入进程运行时间:

"）;

scanf（"%d",&p->ntime）;

printf（"\n"）;

p->state='w';

p->link=NULL;

sort（）;/*调用sort函数*/

}

}

intspace（）

{

intl=0;PCB*pr=ready;

while（pr!

=NULL）

{

l++;

pr=pr->link;

}

return（l）;

}

voiddisp（PCB*pr）/*建立进程显示函数,用于显示当前进程*/

{

printf（"\nqname\tstate\tsuper\t\tntime\t\n"）;

printf（"|%s\t",pr->name）;

printf（"|%c\t",pr->state）;

printf（"|%d\t",pr->super）;

printf（"|%d\t",pr->ntime）;

printf（"\n"）;

}

voidcheck（）/*建立进程查看函数*/

{

PCB*pr;

printf（"\n****当前正在运行的进程是:

%s",p->name）;/*显示当前运行进程*/

disp（p）;

pr=ready;

printf（"\n****当前就绪队列状态为:

\n"）;/*显示就绪队列状态*/

while（pr!

=NULL）

{

disp（pr）;

pr=pr->link;

}

}

voiddestroy（）/*建立进程撤消函数（进程运行结束,撤消进程）*/

{

printf（"\n进程[%s]已完成.\n",p->name）;

free（p）;

}

voidmain（）/*主函数*/

{

intlen,h=0;

charch;

input（）;

len=space（）;

while（（len!

=0）&&（ready!

=NULL））

{

ch=getchar（）;

h++;

printf（"\nTheexecutenumber:

%d\n",h）;

p=ready;

ready=p->link;

p->link=NULL;

p->state='R';

check（）;

destroy（）;

printf（"\n按任一键继续......"）;

ch=getchar（）;

}

printf（"\n\n进程已经完成.\n"）;

ch=getchar（）;

}

流程图

在已设置的三个进程中，由于进程2的运行时间最短，所以优先运行，运行完后到运行时间第二短的进程1运行完毕最后到进程三运行完成。

结束

实验二作业调度

一、实验目的：

用高级语言编写和调试一个或多个作业调度的模拟程序，以加深对作业调度算法的理解。

二、实验内容：

1．写并调试一个单道处理系统的作业等待模拟程序。

2．作业等待算法：

分别采用先来先服务（FCFS）、响应比高者优先（HRN）的调度算法。

3．由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CPU时限等因素。

4．每个作业由一个作业控制块JCB表示，JCB可以包含如下信息：

作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。

作业的状态可以是等待W（Wait）、运行R（Run）和完成F（Finish）三种状态之一。

每个作业的最初状态总是等待W。

5．对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间。

#include"stdafx.h"

#include

#include

#include

voidSingleAccess（）;

voidstart（）;//主调用函数

voidsort_FCFS（）;//插入排序——先来先服务

voidsort_SJF（）;//插入排序——短作业优先

voidsort_HRN（）;//插入排序——高响应比优先

voidrenew（）;//更新作业队列、系统时间及显示已经完成的作业信息

voidinput（）;

voidshow（）;//显示所有作业信息

voidrun（）;

voidclock（）;//系统时间计数器；

structJCB

{

charname[10];

floattimeSubmitted;

floattimeRequired;

void*resourceRequired;//资源在单批道中暂且不考虑

char*status;

JCB*next;

};

JCB*readyList;//作业就绪队列

floatsysTime;//定义系统时间

inttimePiece;//定义时间片，单位：

s

intsumOfJob;

floattotalRuntime;//总周转时间

floattotalRuntimeWithWeight;//总的带权周转时间；

voidSingleAccess（）

{

readyList=NULL;

sysTime=100;//系统时间初始化为100

timePiece=1;

totalRuntime=0;

totalRuntimeWithWeight=0;

}

voidinput（）

{

intcount;

JCB*p;

p=NULL;

printf（"当前系统时间：

100\n请输入作业数量：

"）;

scanf（"%d",&count）;

sumOfJob=count;//获得作业数

for（inti=1;i<=count;i++）

{

if（i==1）

{

printf（"\n请按顺序输入：

\n\t作业名提交时间所需要的运行时间\n"）;

printf（"no.%d:

",i）;

p=（JCB*）malloc（sizeof（JCB））;

scanf（"%s%f%f",p->name,&（p->timeSubmitted）,&（p->timeRequired））;

p->status="wait";

readyList=p;

continue;

}

printf（"no.%d:

",i）;

p->next=（JCB*）malloc（sizeof（JCB））;

p=p->next;

scanf（"%s%f%f",p->name,&（p->timeSubmitted）,&（p->timeRequired））;

p->status="wait";

}

p->next=NULL;

}

voidsort_FCFS（）

{

JCBb,*pb,*p,*ph,*pt;

pb=&b;//设置新链表头

pb->next=NULL;

for（ph=readyList;ph!

=NULL;ph=pt）

{

pt=ph->next;//保留下一节点

for（p=pb;p->next!

=NULL;p=p->next）

if（p->next->timeSubmitted>ph->timeSubmitted）break;

ph->next=p->next;

p->next=ph;

}

readyList=pb->next;//把排好序的链表重新赋值给readyList；

}

voidsort_SJF（）

{

JCBb,*pb,*p,*ph,*pt;

pb=&b;//设置新链表头

pb->next=NULL;

for（ph=readyList;ph!

=NULL;ph=pt）

{

pt=ph->next;//保留下一节点

for（p=pb;p->next!

=NULL;p=p->next）

if（p->next->timeRequired>ph->timeRequired）break;

ph->next=p->next;

p->next=ph;

}

readyList=pb->next;//把排好序的链表重新赋值给readyList；

}

voidsort_HRN（）

{

JCBb,*pb,*p,*ph,*pt;

pb=&b;//设置新链表头

pb->next=NULL;

for（ph=readyList;ph!

=NULL;ph=pt）

{

pt=ph->next;//保留下一节点

for（p=pb;p->next!

=NULL;p=p->next）

if（（（sysTime-p->next->timeSubmitted）/p->timeRequired）<（（sysTime-ph->timeSubmitted）/ph->timeRequired））break;

ph->next=p->next;

p->next=ph;

}

readyList=pb->next;//把排好序的链表重新赋值给readyList；

}

voidrenew（）

{

floatstartRuntime;

startRuntime=sysTime;

for（inti=0;itimeRequired;i+=timePiece）

clock（）;

printf（"\n【作业:

%s已经完成】\n",readyList->name）;

totalRuntime+=sysTime-readyList->timeSubmitted;

totalRuntimeWithWeight+=（sysTime-readyList->timeSubmitted）/readyList->timeRequired;

printf（"开始时间\t完成时间\t周转时间\t带权周转时间\n"）;

printf（"%f\t%f\t%f\t%f\n\n",readyList->timeSubmitted,sysTime,sysTime-readyList->timeSubmitted,（sysTime-readyList->timeSubmitted）/readyList->timeRequired）;

//删除该作业

JCB*p;

p=readyList;

readyList=readyList->next;

free（p）;system（"pause"）;

}

voidshow（）

{

JCB*p;

p=readyList;

for（inti=1;i<80;i++）

putchar（'*'）;

printf（"\n作业名:

\t提交时间:

\t所需时间:

\t状态:

\t当前系统时间:

\n"）;

while（p!

=NULL）

{

printf（"%-10s\t%f\t%f\t%s\t%f\n",p->name,p->timeSubmitted,p->timeRequired,p->status,sysTime）;

p=p->next;

}

for（inti=1;i<80;i++）

putchar（'*'）;

}

voidclock（）

{

sysTime+=timePiece;

Sleep（timePiece*1000）;

}

voidrun（）

{

intchoice;//选择作业调度模式

do{

printf（"\n1：

先来先服务\n2：

最小作业优先\n3：

响应比高者优先\n请选择：

"）;

scanf（"%d",&choice）;

}while（choice<1||choice>4）;

while（readyList!

=NULL）

{

if（choice==1）

sort_FCFS（）;

elseif（choice==2）

sort_SJF（）;

else

sort_HRN（）;

readyList->status="running";

show（）;

renew（）;

}

for（inti=1;i<80;i++）

putchar（'*'）;

printf（"\n这组作业：

\n平均周转时间：

%f\t平均带权周转时间：

%f\n",totalRuntime/sumOfJob,totalRuntimeWithWeight/sumOfJob）;

}

voidstart（）

{

input（）;

run（）;

}

voidmain（）

{

inti;

//SetConsoleTitle（"作业调度"）;

for（inti=1;i<=40;i++）putchar（'*'）;putchar（'\n'）;

printf（"作业调度模拟程序\n"）;

for（i=1;i<=40;i++）putchar（'*'）;putchar（'\n'）;

SingleAccess（）;

start（）;

}

先来先到服务

响应比高者优先（HRN）

思考：

比较各种算法的优缺点。

先来先服务算法：

是按照作业进入输入井的先后次序来挑选作业，先进入输入井的作业优先被挑选，当系统中现有的尚未分配的资源不能满足先进入输入井的作业，那么顺序挑选后面的作业。

FCFS算法简单易行，但性能却不大好。

响应比高者优先算法：

最高响应比优先法（HRN）是对FCFS方式和SJF方式的一种综合平衡。

FCFS方式只考虑每个作业的等待时间而未考虑执行时间的长短，而SJF方式只考虑执行时间而未考虑等待时间的长短。

因此，这两种调度算法在某些极端情况下会带来某些不便。

HRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。

　　响应比R定义如下：

R=（W+T）/T=1+W/T

其中T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。

每当要进行作业调度时，系统计算每个作业的响应比，选择其中R最大者投入执行。

这样，即使是长作业，随着它等待时间的增加，W/T也就随着增加，也就有机会获得调度执行。

这种算法是介于FCFS和SJF之间的一种折中算法。

由于长作业也有机会投入运行，在同一时间内处理的作业数显然要少于SJF法，从而采用HRN方式时其吞吐量将小于采用SJF法时的吞吐量。

另外，由于每次调度前要计算响应比，系统开销也要相应增加。

实验三动态分区分配方式的模拟

1、实验目的：

了解动态分区分配方式中的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解

2、实验内容：

（1）用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程和回收过程。

其中，空闲分区通过空闲分区链（表）来管理；在进行内存分配时，系统优先使用空闲区低端的空间。

（2）假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：

请分别采用首次适应算法和最佳适应算法进行内存的分配和回收，要求每次分配和回收后显示出空闲内存分区链的情况。

作业1申请130KB•作业2申请60KB

•作业3申请100KB作业2释放60KB

作业4申请200KB

•作业3释放100KB

作业1释放130KB

作业5申请140KB

作业6申请60KB•作业7申请50KB•作业8申请60KB

//shiyan3.cpp:

定义控制台应用程序的入口点。

//

#include"stdafx.h"

#include

#include

usingnamespacestd;