收藏
下载资源下载资源 加入VIP,免费下载

操作系统 实验报告.docx

上传人：b****6 文档编号：5384559 上传时间：2022-12-15 格式：DOCX 页数：21 大小：401.55KB
下载 相关 举报
操作系统 实验报告.docx_第1页
第1页 / 共21页
操作系统 实验报告.docx_第2页
第2页 / 共21页
操作系统 实验报告.docx_第3页
第3页 / 共21页
操作系统 实验报告.docx_第4页
第4页 / 共21页
操作系统 实验报告.docx_第5页
第5页 / 共21页
点击查看更多>>
下载资源
资源描述

操作系统 实验报告.docx

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

操作系统 实验报告.docx

操作系统实验报告

本科实验报告

 

课程名称：

操作系统B

实验项目：

操作系统实验

实验地点：

逸夫楼

专业班级：

软件1009班学号：

2010004611

学生姓名：

李瑞

指导教师：

王华夏

2012　年　12月　6日

 

实验一几种操作系统的界面

一、目的和要求

（1）目的：

　　本实验的目的是熟悉1—2种操作系统的界面，在熟练使用机器的基础上，能了解各种操作命令和系统调用在系统中的大致工作过程。

也就是通过操作系统的外部特征，逐步深入到操作系统的内部实质内容中去。

（2）要求：

　　能熟练的在1—2种操作系统的环境下工作，学会使用各种命令，熟悉系统提供的各种功能，主动而有效地使用计算机。

　　熟悉系统实用程序的调用方法和各种系统调用模块的功能和作用

二、实验内容和原理

在某种操作系统的环境下建立、修改、运行、打印源程序和结果，最后撤消一个完整的程序。

三、主要仪器设备

ProBook6450bubuntu

四、操作方法与实验步骤

代码：

#include

#include

　　　#include

　　　#include

　　　#defineSEM_NAME"mysem"

　　　#defineOPEN_FLAGO_RDWR|O_CREAT

#defineOPEN_MODE00777

#defineINIT_V0

staticsem_t*sem=NULL;

staticvoidmysem（char*str）

{

inti=0;

while（'\0'!

=str[i]）

{

printf（"%c\n",str[i++]）;

sleep

（1）;

}

}

intmain（void）

{

pid_tpid=-1;

intret=-1;

intstatus=-1;

//创建一个命名信号量

sem=sem_open（SEM_NAME,OPEN_FLAG,OPEN_MODE,INIT_V）;

//创建子进程

pid=fork（）;

if（-1==（ret=pid））

{

perror（"forkfailed:

"）;

goto_OUT;

}

if（0==pid）

{

mysem（"abcd"）;

//V操作

sem_post（sem）;

}

if（0

{

//P操作

sem_wait（sem）;

mysem（"1234"）;

//等待子进程结束

wait（&status）;

//删掉在系统创建的信号量

sem_unlink（SEM_NAME）;

//彻底销毁打开的信号量

sem_close（sem）;

}

_OUT:

returnret;

}

五、实验结果与分析

六、讨论、心得

通过本实验，熟练了Linux操作系统的使用，了解了编译的基本步骤和指令：

如何进入vi的命令模式，进入输入模式如何操作，末行模式指令，保存退出，命令模式命令等等基础的指令；使用时不再像开始那么生疏了。

实验二进程调度程序设计

一、目的和要求

（一）目的

进程是操作系统最重要的概念之一，进程调度是操作系统的主要内容，本实验要求能独立地用高级语言编写一个进程调度程序，调度算法可任意选择或自行设计，本实验可加深对进程调度和各种调度算法的理解。

（二）要求

1．设计一个有几个进程并发执行的进程调度程序，每个进程由一个进程控制块（PCB）表示，进程控制块通常应包括下述信息：

进程名，进程优先数，进程需要运行的时间，占用CPU的时间以及进程的状态等，且可按照调度算法的不同而增删。

2．调度程序应包含2—3种不同的调度算法，运行时可以任选一种，以利于各种方法的分析和比较。

3．系统应能显示或打印各进程状态和参数的变化情况，便于观察。

二、实验内容和原理

1．题目本程序可选用优先数法或简单轮转法对五个进程进行调度。

每个进程处于运行R（run）、就绪W（wait）和完成F（finish）三种状态之一，并假定起始状态都是就绪状态W。

为了便于处理，程序中进程的运行时间以时间片为单位计算。

各进程的优先数或轮转时间片数、以及进程需要运行的时间片数，均由伪随机数发生器产生。

进程控制块结构如表2-1所示：

表2-1PCB

进程标识符

链指针

优先数/轮转时间片数

占用CPU时间片数

进程所需时间片数

进程状态

进程控制块链结构如图2-1所示：

RUNHEADTAIL

…

 

　　　　　　　　　　　　　　图2-1进程控制块链结构

其中：

RUN—当前运行进程指针；

HEAD—进程就绪链链首指针；

TAIL—进程就绪链链尾指针。

2.算法与框图程序框图如图2-2所示。

图2-2进程调度框图

（1）优先数法。

进程就绪链按优先数大小从大到小排列，链首进程首先投入运行。

每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3。

理由是该进程如果在一个时间片中完成不了，优先级应降低一级。

接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续运行，否则，调度就绪链链首进程投入运行。

原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。

（2）简单轮转法。

进程就绪链按各进程进入的先后次序排列，链首进程首先投入运行。

进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相应于优先数法的优先数记录项位置）。

每过一个时间片，运行进程占用处理机的时间片数加1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。

三、主要仪器设备

ProBook6450bubuntu

四、操作方法与实验步骤

程序清单：

#include

#include

#definefurthest5

structprocess/*PCBSTRUCTURE*/

{intid;

intpriority;

intcputime;

intalltime;

charstate;

intnext;}prochain[furthest-1];

intprocnum;

intrand（）;

intalgo;

intrun,head,tail,j;

main（）/*MAINPROGRAM*/

{agan:

printf（“typethealgorithmis（1:

RR,2:

PRIO）:

”）;

scanf（“%d”,&algo）;

if（algo==2）

{printf（“outputofpriority.\n”）;

init（）;

prisch（）;}

else

{if（algo==1）

{printf（“outputofroundrobin.\n”）;

init（）;

timesch（）;}

else

{printf（“tryagain,please\n”）;

gotoagan;}

}

for（j=1;j<=40;j++）

{printf（“=”）;}

printf（“\n\n”）;

for（j=1;j<=40;j++）

{printf（“=”）;}

printf（“\n\n”）;

printf（“systemfinished\n）;}

print（）/*PRINTTHERUNNINGPROCESS,WAITING

QUEUEANDPCBSEQUENCELIST*/

{intk,p;

for（k=1;k<=40;k++）

printf（“=”）;

printf（“\nrunningproc.”）;

printf（“waitingqueue.”）;

printf（“\n%d”,prochain[run].id）;

p=head;

while（p!

=0）

{printf（“%5d”,p）;

p=prochain[p].next;}

printf（“\n”）;

for（k=1;k<=40;k++）

printf（“=”）;

printf（“\n”）;

printf（“id“）;

for（k=1;k

printf（“%5d”,prochain[k].id）;

printf（“\n”）;

printf（“priority”）;

for（k=1;k

printf（“%5d”,prochain[k].priority）;

printf（“\n”）;

printf（“cputime”）;

for（k=1;k

printf（“%5d”,prochain[k].cputime）;

printf（“\n”）;

printf（“alltime”）;

for（k=1;k

printf（“%5d”,prochain[k].alltime）;

printf（“\n”）;

printf（“state”）;

for（k=1;k

printf（“%5c”,prochain[k].state）;

printf（“\n”）;

printf（“next”）;

for（k=1;k

printf（“%5d”,prochain[k].next）;

printf（“\n”）;

}

insert（intq）/*INSERTAPROCESS*/

{intp,s;

p=head;

s=prochain[head].next

while（（prochain[q].priority

=0））

{p=s;

s=prochain[s].next;}

prochain[p].next=q;

prochain[q].next=s;

}

insert2（）/*PUTAPROCESSONTOTHETAILOFTHEQUEUE*/

{prochain[tail].next=run;

tail=run;

prochain[run].next=0;

}

init（）/*CREATEAWAITINGQUEUE*/

{inti;

head=0;

if（alog==2）

{for（i=1;i

{prochain[i].id=i;

prochain[i].priority=（rand（）+11）%41;

prochain[i].cputime=0;

prochain[i].alltime=（rand（）+1）%7;

prochain[i].state=’W’;

prochain[i].next=0;

if（prochain[i].priority

priority）&&（head!

=0））

insert（prochain[i].id）;

else

{prochain[i].next=head;

head=prochain[i].id;}

}

}

else

{for（i=1;i

{prochain[i].id=i;

prochain[i].priority=（rand（）+1）%3+1;

prochain[i].cputime=0;

prochain[i].alltime=（rand（）+1）%7;

prochain[i].state=’W’;

prochain[i].next=（i+1）%（furthest+1）;}

head=1;

tail=furthest;

prochain[furthest].next=0;

}

run=head;

prochain[run].state=’R’;

head=prochain[head].next;

prochain[run].next=0;

print（）;

}

prisch（）/*THEPROCESSWITHPRIOALGORITHM*/

{while（run!

=0）

{prochain[run].cputime+=1;

prochain[run].priority-=3;

prochain[run].alltime-=1;

if（prochain[run].alltime==0）

{prochain[run].state=’F’;

prochain[run].next=0;

if（head!

=0）

{run=head;

prochain[run].state=’R’;

head=prochain[head].next;}

else

{prochain[0].id=prochain[run].id;

run=0;}

}

else

{if（（prochain[run].priority

priority）&&（head!

=0））

{prochain[run].state=’W’;

insert（run）;

run=head;

prochain[run].state=’R’;

head=prochain[head].next;}

}

print（）;

}

}

timesch（）/*THEPROCESSWITHRRALRORITHM*/

{while（run!

=0）

{prochain[run].alltime-=1;

prochain[run].cputime+=1;

if（prochain[run].alltime==0）

{prochain[run].state=’F’;

prochain[run].next=0;

if（head!

=0）

{run=head;

prochain[run].state=’R’;

head=prochain[head].next;}

else

{prochain[0].id=prochain[run].id;

run=0;}

}

else

{if（（prochain[run].cputime==prochain[run].

priority）&&（head!

=0））

{prochain[run].state=’W’;

prochain[run].cputime=0;

insert2（）;

run=head;

prochain[run].state=’R’;

head=prochain[head].next;}

}

print（）;

}

}

五、实验结果与分析

　

　　

　

　

六、讨论、心得

通过编写长长的代码，以及编译运行，观察结果，对进程调度算法有了更深一层的印象。

本实验选用优先数法或简单轮转法对五个进程进行调度。

每个进程处于运行R（run）、就绪W（wait）和完成F（finish）三种状态之一。

优先数法是预先确定个进程的优先数，系统将cpu的使用权赋予就绪队列中具备最高优先级的就绪进程。

这种方法又分为静态与动态的。

静态的缺点是：

在整个进程运行过程中不会改变，不能反映实时的信息，所以动态的是对静态的改进，在整个进程运行过程中各个进程的优先级在不断的改变。

简单轮转法是就绪队列中的所有进程以相等的速度向前推进。

　

 

实验三存储管理程序设计

一、目的和要求

（一）目的

存储管理的主要功能之一是合理地分配主存空间。

请求页式管理是一种常用的虚拟存储管理技术。

本实验的目的是通过请求页式存储管理中页面置换算法的模拟设计，来了解虚拟存储技术的特点，掌握请求页式存储管理的页面置换算法。

（二）要求

模拟页式虚拟存储管理中硬件的地址转换和缺页中断的处理过程，并用先进先出调度算法（FIFO）处理缺页中断。

二、实验内容和原理

（1）为了装入一个页面而必须调出一页时，如果被选中调出的页面在执行中没有修改过，则不必把该页重新写到磁盘上（因磁盘上已有副本）。

因此，在页表中可以增加是否修改过的标志，当执行“存”指令、“写”指令时把对应页的修改标志置成“1”，表示该页修改过，否则为“0”，表示该页未修改过。

页表格式如表3-1所示。

表3-1页表格式

页号

标志

主存块号

修改标志

磁盘上的位置

 

（2）设计一个地址转换程序来模拟硬件的地址转换和缺页中断处理过程。

当访问的页在主存时则形成绝对地址，但不去模拟指令的执行，可用输出转换后的绝对地址来表示一条指令已完成。

当访问的页不在主存时则输出“*该页页号”来表示硬件产生了一次缺页中断。

模拟地址转换的程序流程如图3-1所示。

（3）编制一个FIFO页面调度程序。

FIFO页面调度算法总是先调出作业中最先进入主存的那一页，因此，可以用一个数组来构成页号队列。

数组中每个元素是该作业已在主存的页面号，假定分配给作业的主存块数为m，且该作业开始的m页已装入主存，则数组可由m个元素组成：

P[0]，P[1]，…，P[m-1]

它们的初值为

P[0]∶=0，P[1]∶=1，…，P[m-1]∶=m-1

用一指针k指示当要装入新页时应调出的页在数组的位置，k的初值为“0”。

图3-1地址转换和FIFO页面调度流程

当产生缺页中断后，操作系统总是选择P[k]所指出的页面调出，然后执行

P[k]∶=要装入的新页页号

k∶=（k+1）modm

在实验中不必实际地启动磁盘执行调出一页和装入一页的工作，而用输出“OUT调出的页号”和“IN要装入的新页页号”来模拟一次调出和装入的过程。

模拟程序的流程见图3-1。

（4）假定主存的每块长度为1024个字节，现有一个共7页的作业，其副本已在磁盘上。

系统为该作业分配了4块主存块，且该作业的第0页至第3页已经装入主存，其余3页尚未装入主存，该作业的页表见表3-2所示。

表3-2作业的页表

页号

标志位

主存块号

修改标志

在磁盘上的位置

0

1

5

0

011

1

1

8

0

012

2

1

9

0

013

3

1

1

0

021

4

0

0

022

5

0

0

023

6

0

0

121

如果该作业依次执行的指令序列如表3-3所示。

表3-3作业依次执行的指令序列

操作

页号

页内地址

操作

页号

页内地址

+

0

070

移位

4

053

+

1

050

+

5

023

×

2

015

存

1

037

存

3

021

取

2

078

取

0

056

+

4

001

-

6

040

存

6

084

依次执行上述的指令序列来调试你所设计的程序（仅模拟指令的执行，不必考虑指令序列中具体操作的执行）

（5）为了检查程序的正确性，可自行确定若干组指令序列，运行设计的程序，核对执行结果。

三、主要仪器设备

　　ProBook6450bubuntu

四、操作方法与实验步骤

程序清单：

#include"stdio.h"

#definesize1024

structplist

{

intnumber;

intflag;

intblock;

intmodify;

intlocation;

};

Struct　plistp1[7]={{0,1,5,0,010},{1,1,8,0,012},{2,1,9,0,013},{3,1,1,0,021},{4,0,-1,0,022},{5,0,-1,0,023},{6,0,-1,0,121}};

structilist

{

charoperation[10];

intpagenumber;

intaddress;

};

structilistp2[12]={{"+",0,70},{"+",1,50},{"*",2,15},{"存",3,21},

{"取",0,56},{"-",6,40},{"移位",4,53},{"+",5,23},

{"存",1,37},{"取",2,78},{"+",4,1},{"存",6,84}};

main（）

{

Inti,lpage,pflage,replacedpage,pmodify;///////////////////////////////////////////////////////////////////////////////////

intp[4]={0,1,2,3};

intk=0;

intm=4;

longmemaddress;

printf（"\n操作\t页号\t页内地址标志绝对地址修改页号页架号绝对地址\n"）;

for（i=0;i<12;i++）

{

lpage=p2[i].pagenumber;

pflage=p1[lpage].flag;

if（pflage==0）

{

replacedpage=p[k];

pmodify=p1[replacedpage].modify;

p[k]=lpage;

k=（k+1）%m;

p1[lpage].flag=1;//标志位改为1

p1[lpage].block=p1[replacedpage].block;

p1[replacedpage].block=-1;

p1[replacedpage].flag=0;

p1[replacedpage].modify=0;

}

memaddress=p1[lpage].block*size+p2[i].address;

if（p2[i].operation=="save"）

p1[lpage].modify=1;

printf（"%s\t",p2[i].operation）;

printf（"%d\t",p2[i].pagenumber）;

printf（"%d\t",p2[i].address）;

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置：首页 > 高等教育 > 其它

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1