太原理工大学操作系统实验报告Word文件下载.docx

太原理工大学操作系统实验报告Word文件下载.docx

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

。

3.按住Windows键+R输入cmd回车。

4.进入Dos界面键入d：

5.输入dir查看java文件，使用javac命令进行编辑

四、程序清单（据情况而定）

classdemo

{

publicstaticvoidmain（String[]args）

{

System.out.print（"

这是一个java例子"

）;

}

}

五、讨论、心得

本次实验是在Windows10系统下进行的，通过对一个Java小程序的编译连接熟悉对Win10的操作以及DOS命令的使用。

试验中使用到的DOS工具：

查看目录：

dir

编辑：

javac

通过本次实验，进一步熟悉了对操作系统尤其是DOS命令的使用，初步了解了部分操作命令和系统调用在系统中的大致工作过程，通过实践也加深了对老师课堂一些所讲知识的理解。

实验二进程调度程序设计

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

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

三、代码：

#include<

stdio.h>

stdlib.h>

#definefurthest5

structprocess/*PCBSTRUCTURE*/

intid;

intpriority;

intcputime;

intalltime;

charstate;

intnext;

}prochain[furthest-1];

intprocnum;

intrand（）;

intalgo;

intrun,head,tail,j;

voidprint（）;

voidinsert（intq）;

voidinsert2（）;

voidtimesch（）;

voidinit（）;

voidprisch（）;

intmain（）/*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

tryagain,please\n"

gotoagan;

for（j=1;

j<

=40;

j++）

="

\n\n"

systemfinished\n"

getchar（）;

voidprint（）/*PRINTTHERUNNINGPROCESS,WAITING

QUEUEANDPCBSEQUENCELIST*/

intk,p;

for（k=1;

k<

k++）

\nrunningproc."

waitingqueue."

\n%d"

prochain[run].id）;

p=head;

while（p!

=0）

%5d"

p）;

p=prochain[p].next;

\n"

id"

k<

furthest+1;

prochain[k].id）;

priority"

prochain[k].priority）;

cputime"

prochain[k].cputime）;

alltime"

prochain[k].alltime）;

state"

%5c"

prochain[k].state）;

next"

prochain[k].next）;

voidinsert（intq）/*INSERTAPROCESS*/

intp,s;

s=prochain[head].next;

while（（prochain[q].priority<

prochain[s].priority）&

&

（s!

=0））

p=s;

s=prochain[s].next;

prochain[p].next=q;

prochain[q].next=s;

voidinsert2（）/*PUTAPROCESSONTOTHETAILOFTHEQUEUE*/

{prochain[tail].next=run;

tail=run;

prochain[run].next=0;

voidinit（）/*CREATEAWAITINGQUEUE*/

inti;

head=0;

for（i=1;

i<

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<

prochain[head].priority）&

（head!

insert（prochain[i].id）;

else

{

prochain[i].next=head;

head=prochain[i].id;

}

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

prochain[i].cputime=0;

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;

print（）;

voidprisch（）/*THEPROCESSWITHPRIOALGORITHM*/

while（run!

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!

run=head;

prochain[run].state='

head=prochain[head].next;

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

run=0;

if（（prochain[run].priority<

prochain[head].priority）&

insert（run）;

print（）;

voidtimesch（）/*THEPROCESSWITHRRALRORITHM*/

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

run=0;

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

priority）&

prochain[run].cputime=0;

insert2（）;

四、结果：

五、感想：

本次试验的目的在于加深对进程调度和各种调度算法的理解，故通过对优先数法和简单轮转法编辑程序实际运行来加深对这两种方法的理解。

对于简单轮转法，既将全部的进程按照进入的先后顺序排成一个就绪队列，设置每隔一段时间后将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。

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

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

表3-2作业的页表

页号

标志

在磁盘上的位置

0

1

5

011

8

012

2

9

013

3

021

4

0

022

023

6

121

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

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

操作

页内地址

+

070

移位

053

050

×

015

存

037

取

078

056

001

-

040

084

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

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

三、代码:

iostream>

time.h>

usingnamespacestd;

structpageTable//定义页表

intaddress;

//地址

intpage;

//页号

intblock;

//块号

structpageTable*next;

};

typedefstructpageTablePAGETABLE;

PAGETABLE*pt;

constintfirst_memory=1000;

//内存首地址

intwork[320];

//作业

intindex,offset;

//index是作业的页号，offset为页内偏移地址

PAGETABLE*oldPtr;

//minPtr指向驻留时间最久的页

intcount1;

//记数器，用于记录发生的缺页数

boolis_LRU=false;

//是否是LRU算法

voidinsertPage（）;

voidpushback_Page（PAGETABLE*,PAGETABLE*）;

voidprint（PAGETABLE*）;

voidrun（int）;

voidfind_FIFO（）;

voidfind_LRU（）;

voidmain（void）

inti=0;

while

（1）

cout<

<

"

\nPleaseselectanumber（1,2,0）"

<

endl;

1--先进先出算法（FIFO）"

2--最久未使用算法（LRU）"

0--程序结束"

cin>

>

i;

if（i==1）

cout<

\nThisisaexampleforFIFO:

is_LRU=false