湖南师大操作系统报告.docx

湖南师大操作系统报告.docx

《湖南师大操作系统报告.docx》由会员分享，可在线阅读，更多相关《湖南师大操作系统报告.docx（56页珍藏版）》请在冰豆网上搜索。

湖南师大操作系统报告

湖南师范大学

操作系统实验报告

姓名：

年级：

专业：

计算机科学与技术

学号：

任课教师：

开课时间：

2012~2013学年第二学期

实验

（一）

可变分区存储管理

一、实验目的：

（四号黑体）

1、加深对可变分区存储管理的理解；

2、提高用C语言编制大型系统程序的能力，特别是掌握C语言编的难点：

指针和指针作为函数参数；

3、掌握用指针实现链表和在链表上的基本操作。

二、实验内容：

（四号黑体）

参照教材P123-P125的内容，编写一个C程序，用char*malloc（unsignedsize）函数向系统申请一次内存空间（如size=1000，单位为字节），用循环首次适应算法、最佳适应算法和最坏适应算法，模拟UNIX可变分区存储管理，实现对内存区的分配和释放管理。

三、程序分析与设计：

（四号黑体）

1、算法思想和概要设计（四号仿宋，单倍行距）

把空闲表设计成链表结构的循环队列，各空闲区仍按地址从低到高的次序登记在空闲区的管理队列中，存放空闲区大小和空闲区起始地址，同时设置一个起始查找指针，指向循环队列中的一个空闲区表项。

另外，开设一个结构数组，用于进程处理，存放进程区的进程大小和起始地址。

循环首次适应法分配时总是从起始查找指针所指的表项开始查找，第一次找到满足要求的空闲区时，就分配所需大小的空闲区，修改表项，并调整起始查找指针，使其指向队列中被分配的后面的那块空闲区，下次分配时就从新指向的那块空闲区开始查找。

同时，将新的进程信息加入到进程数组中。

2、源程序

#include

#include

#include

usingnamespacestd;

#defineFree0

#defineBusy1

#defineOK1

#defineERROR0

#defineMAX_length1000

typedefintStatus;

intflag;

typedefstructfreearea//定义一个空闲区说明表结构

{

longsize;

longaddress;

intstate;

}ElemType;

//线性表的双向链表存储结构

typedefstructDuLNode

{

ElemTypedata;

structDuLNode*prior;

structDuLNode*next;

}

DuLNode,*DuLinkList;

DuLinkListblock_first;//头结点

DuLinkListblock_last;//尾结点

Statusalloa（int）;//内存分配

Statusfree（int）;//内存回收

StatusFirst_fit（int）;//循环首次适应算法

StatusBest_fit（int）;//最佳适应算法

StatusWorst_fit（int）;//最差适应算法

voidshow（）;//查看分配

StatusInitblock（）;//开创空间表

StatusInitblock（）//开创带头结点的内存空间链表

{

block_first=（DuLinkList）malloc（sizeof（DuLNode））;

block_last=（DuLinkList）malloc（sizeof（DuLNode））;

block_first->prior=NULL;

block_first->next=block_last;

block_last->prior=block_first;

block_last->next=NULL;

block_last->data.address=0;

block_last->data.size=MAX_length;

block_last->data.state=Free;

returnOK;

}

//分配主存

Statusalloa（intch）

{

intrequest=0;

cout<<"请输入需要分配的主存大小（单位:

KB）：

";

cin>>request;

if（request<0||request==0）

{

cout<<"分配大小不合适!

"<

returnERROR;

}

if（ch==2）//选择最佳适应算法

{

if（Best_fit（request）==OK）cout<<"分配成功!

"<

elsecout<<"内存不足，分配失败!

"<

returnOK;

}

if（ch==3）//选择最差适应算法

{

if（Worst_fit（request）==OK）cout<<"分配成功!

"<

elsecout<<"内存不足，分配失败!

"<

returnOK;

}

else//默认循环首次适应算法

{

if（First_fit（request）==OK）cout<<"分配成功!

"<

elsecout<<"内存不足，分配失败!

"<

returnOK;

}

}

//循环首次适应算法

StatusFirst_fit（intrequest）

{

//为申请作业开辟新空间且初始化

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->data.size=request;

temp->data.state=Busy;

DuLNode*p=block_first->next;

while（p）

{

if（p->data.state==Free&&p->data.size==request）

{

p->data.state=Busy;

returnOK;

break;

}

if（p->data.state==Free&&p->data.size>request）

{

temp->prior=p->prior;

temp->next=p;

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

p->prior->next=temp;

p->prior=temp;

p->data.address=temp->data.address+temp->data.size;

p->data.size-=request;

returnOK;

break;

}

p=p->next;

}

returnERROR;

}

//最佳适应算法

StatusBest_fit（intrequest）

{

intch;//记录最小剩余空间

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->data.size=request;

temp->data.state=Busy;

DuLNode*p=block_first->next;

DuLNode*q=NULL;//记录最佳插入位置

while（p）//初始化最小空间和最佳位置

{

if（p->data.state==Free&&（p->data.size>=request））

{

if（q==NULL）

{

q=p;

ch=p->data.size-request;

}

elseif（q->data.size>p->data.size）

{

q=p;

ch=p->data.size-request;

}

}

p=p->next;

}

if（q==NULL）returnERROR;//没有找到空闲块

elseif（q->data.size==request）

{

q->data.state=Busy;

returnOK;

}

else

{

temp->prior=q->prior;

temp->next=q;

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

q->prior->next=temp;

q->prior=temp;

q->data.address+=request;

q->data.size=ch;

returnOK;

}

returnOK;

}

//最差适应算法

StatusWorst_fit（intrequest）

{

intch;//记录最大剩余空间

DuLinkListtemp=（DuLinkList）malloc（sizeof（DuLNode））;

temp->data.size=request;

temp->data.state=Busy;

DuLNode*p=block_first->next;

DuLNode*q=NULL;//记录最佳插入位置

while（p）//初始化最大空间和最佳位置

{

if（p->data.state==Free&&（p->data.size>=request））

{

if（q==NULL）

{

q=p;

ch=p->data.size-request;

}

elseif（q->data.sizedata.size）

{

q=p;

ch=p->data.size-request;

}

}

p=p->next;

}

if（q==NULL）returnERROR;//没有找到空闲块

elseif（q->data.size==request）

{

q->data.state=Busy;

returnOK;

}

else

{

temp->prior=q->prior;

temp->next=q;

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

q->prior->next=temp;

q->prior=temp;

q->data.address+=request;

q->data.size=ch;

returnOK;

}

returnOK;

}

//主存回收

Statusfree（intflag）

{

DuLNode*p=block_first;

for（inti=0;i<=flag;i++）

if（p!

=NULL）

p=p->next;

else

returnERROR;

p->data.state=Free;

if（p->next==NULL）

{//cout<data.size<<"?

"<

if（p->prior!

=block_first&&p->prior->data.state==Free）//与前面的空闲块相连

{

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

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

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

p=p->prior;

}

if（p->prior==block_first&&p->prior->data.state==Free）

{

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

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

//可能*****************************

}

}

else

{cout<data.size<<"*"<

if（p->prior!

=block_first&&p->next!

=block_last&&p->prior->data.state==Free&&p->next->data.state==Free）//与前后的空闲块相连

{

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

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

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

p=p->prior;

}

if（p->prior!

=block_first&&p->prior->data.state==Free）//与前面的空闲块相连

{

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

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

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

p=p->prior;

}

if（p->next!

=block_last&&p->next->data.state==Free）//与后面的空闲块相连

{

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

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

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

}

if（p->next==block_last&&p!

=block_first&&p->next->data.state==Free）//与最后的空闲块相连

{

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

p->next=NULL;

}

if（p->next==block_last&&p==block_first&&p->next->data.state==Free）

{

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

}

}

returnOK;

}

//显示主存分配情况

voidshow（）

{

intflag=0;

cout<<"\n主存分配情况:

\n";

cout<<"\n\n";

DuLNode*p=block_first->next;

cout<<"分区号\t起始地址\t分区大小\t状态\n\n";

while（p）

{

cout<<""<

cout<<""<data.address<<"\t\t";

cout<<""<data.size<<"B\t\t";

if（p->data.state==Free）cout<<"空闲\n\n";

elsecout<<"已分配\n\n";

p=p->next;

}

cout<<"\n\n";

}

//主函数

intmain（）

{

intch;//算法选择标记

cout<<"请输入所使用的内存分配算法：

\n";

cout<<"1、循环首次适应算法\n2、最佳适应算法\n3、最差适应算法\n";

cin>>ch;

while（ch<1||ch>3）

{

cout<<"输入错误，请重新输入所使用的内存分配算法：

\n";

cin>>ch;

}

Initblock（）;//开创空间表

intchoice;//操作选择标记

while

（1）

{

show（）;

cout<<"输入操作数：

";

cout<<"\n1:

分配内存\n2:

回收内存\n0:

退出\n";

cin>>choice;

if（choice==1）alloa（ch）;//分配内存

elseif（choice==2）//内存回收

{

intflag;

cout<<"输入要释放的分区号：

";

cin>>flag;

free（flag）;

}

elseif（choice==0）continue;//退出

else

{

cout<<"输入有误!

"<

continue;

}

}

}

3、结果（四号仿宋，单倍行距）

附：

运行结果

选择首次循环1

最佳使用算法：

最坏使用算法：

四、本次上机经验及体会：

（四号黑体）

这次实验，我做了很久，足有三天的时间，想起自己的那些过程，自己的经验真的很少，对编译器及语法真的不了解。

做程序，从开始的写算法，到最后的实现，觉得过程真的很枯燥，到最后程序的完成，不知道查了多少的资料，看了多少别人的程序，才编写出来。

一开始我就知道怎么实现内存的分配，怎么对内存进行操作，

写程序真的有点累，特别是对与我们这些没有经验的来说，调试一个小小的问题都要思考半天，在写程序的这几天中，我觉得过得很充实，时间也过得很快，脑袋里也觉得有点东西了。

实验

（二）

进程调度模拟实验

一、实验目的：

（四号黑体）

本实验模拟在单处理机环境下的处理机调度，帮助理解进程调度的概念，深入了解进程控制块的功能，以及进程的创建、撤销和进程各个状态间的转换过程。

二、实验内容：

1、实现进程相关数据结构（如进程控制块）的创建和查看功能；

2、实现多种进程调度算法：

FCFS、SJF、时间片轮转调度算法。

三、程序分析与设计：

（四号黑体）

1、算法思想和概要设计（四号仿宋，单倍行距）

FCFS：

　按照作业提交或进程变为就绪状态的先后次序，分派CPU；当前作业或进程占用CPU，直到执行完或阻塞，才出让CPU（非抢占方式）。

在作业或进程唤醒后（如I/O完成），并不立即恢复执行，通常等到当前作业或进程出让CPU。

SJF：

SJF算法以进入系统的作业所要求的CPU时间为标准，总选取估计计算时间最短的作业投入运行。

时间片轮转调度算法：

A、设置多个就绪队列,并为各个队列赋予不同的优先级.第一个队列的优先级最高,第二个队列次之,其余各队列的优先权逐个降低.

　　该算法赋予各个队列中进程执行时间片的大小也各不相同:

在优先权愈高的队列中,为每个进程所规定的执行时间片就愈小.

B、当一个新进程进入内存后,首先将它放入第一队列的末尾,按FCFS原则排队等待调度.当轮到该进程执行时,如它能在该时间片内完成,便可准备撤离系统;如果它在一个时间片结束时尚未完成,调度程序便将该进程转入第二队列的末尾,再同样地按FCFS原则等待调度执行;如果它在第二队列中运行一个时间片后仍未完成,再依次将它放入第三队列,……,如此下去,当一个长作业（进程）从第一队列依次降到第n队列后,在第n队列中便采取按时间片轮转的方式运行.

C、仅当第一队列空闲时,调度程序才调度第二队列中的进程运行;仅当第1~（i-1）队列均空时,才会调度第i队列中的进程运行.如果处理机正在第i队列中为某进程服务时,又有新进程进入优先权较高的队列（第1~（i-1）中的任何一个队列）,则此时新进程将抢占正在运行进程的处理机,即由调度程序把正在运行的进程放回到第i队列的末尾,把处理机分配给新到的高优先权进程.

2、源程序

#include

#include

#include

#include

#include

usingnamespacestd;

structPCB{

intcome_time;//进程到达时间

intrun_time;//进程运行时间

intVIP;//进程的优先级

intfinish_time;//进程完成时间

intruned_time;//进程已经执行了的时间,主要在时间片轮转时起作用

charname;//进程名

charstate;//进程状态

PCB*next;//下一个进程

};

PCB*create（int）;//创建进程链表

PCB*My_Copy（PCB*）;//拷贝进程链表

voidRelease（PCB*）;//释放进程链表

voidPint（PCB*,int）;//输出进程链表

voidMenu（PCB*,int）;//打针菜单

voidFirstcome_Firstserve（PCB*）;//先来先服务

voidShortwork_Firstserve（PCB*）;//短作业优先

voidTimeSlice_Firstserve（PCB*,int,int）;//时间片轮转

voidVIP_Firstserve（PCB*）;//优先级优先

voidPrintResult（PCB*）;//打印算法的周转时间和带权周转时间

/*创建进程链表*/

PCB*create（intn）

{

PCB*head,*p,*q;//head表示进程链表的头节点,一个标示

head=（PCB*）malloc（sizeof（PCB））;//生成头节点

p=head;

p->next=NULL;

charNAME='A';//进程名.假设从A开始

for（inti=0;i

{

if（（q=（PCB*）malloc（sizeof（PCB）））==NULL）//分配不成功时退出

{

cout<<"ERROR!

"<

exit（0）;

}

q->name=NAME+i;

cout<<"进程"<<（char）（NAME+i）<<":

"<

cout<<"进程开始时间"<

cin>>q->come_time;

cout<<"进程运行时间"<

cin>>q->run_time;

cout<<"进程优先级"<

cin>>q->VIP;

q->runed_time=0;

q->finish_time=0;

q->state='W';

p=head;

while（p->next!

=NULL&&q->come_time>=p->next->come_time）//按时间到达时间排序

p=p->next;

q->next=p->next;

p->next=q;

}

returnhead;//返回创建好的链表

}

/*拷贝链表*/

PCB*My_Copy（PCB*head1）

{

PCB*head2=（PCB*）malloc（sizeof（PCB））;

head2->next=NULL;

PCB*p=head1->next;

PCB*q=head2;

PCB*node=NULL;

w