太原理工大学操作系统实验报告.docx
《太原理工大学操作系统实验报告.docx》由会员分享，可在线阅读，更多相关《太原理工大学操作系统实验报告.docx（58页珍藏版）》请在冰豆网上搜索。
太原理工大学操作系统实验报告
课程名称：
操作系统B
实验项目：
操作系统实验
实验地点：
逸夫楼402、逸夫楼502教室
专业班级：
软件1415班
学生姓名：
朱伟学号：
**********
*******
2016年11月28日
实验一几种操作系统的界面
一、目的和要求
（一）目的
本实验的目的是使学生熟悉1—2种操作系统的界面，在熟练使用机器的基础上，能了解各种操作命令和系统调用在系统中的大致工作过程。
也就是通过操作系统的外部特征，逐步深入到操作系统的内部实质内容中去。
（二）要求
1.能熟练的在1—2种操作系统的环境下工作，学会使用各种命令，熟悉系统提供的各种功能，主动而有效地使用计算机。
2.熟悉系统实用程序的调用方法和各种系统调用模块的功能和作用
二、实验内容
在某种操作系统的环境下建立、修改、运行、打印源程序和结果，最后撤消一个完整的程序。
提示：
可按下述步骤进行
1．编写一个完整的源程序，通过编辑命令送入机器，建立源程序文件；
2．编译该源文件，建立相应的目标文件；
3．编译有错时，再用编辑命令修改源文件，消除全部词法和语法错误；
4．连接目标文件，形成可执行文件；
5．执行该文件，得到结果；
6．打印输出源程序和运行结果；
7．撤消本次实验中形成的所有文件。
三、实验步骤及程序流程图
1、按住Windows键+R输入notepad回车调出记事本。
2、编辑一个java程序选择另存为F：
。
3、按住Windows键+R输入cmd回车。
4、进入Dos界面输入F：
。
5、输入dir查看java文件，使用javac命令进行编辑
四、程序清单
classdemo
{
publicstaticvoidmain（String[]args）
{
System.out.print（"软件1415班朱伟2014005960"）;
}
}
五、实验心得
这次实验是在win7操作系统下进行的，通过编译连接一个java小程序熟悉DOS命令的使用。
实验中用到的DOS工具：
dir：
列出当前控制台所在的路径下的所有文件以及文件夹。
javac：
编译。
这次实验，通过查找一些常用的DOS命令，进一步熟悉了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
#include
#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
{
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"）;
getchar（）;
}
voidprint（）/*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;kprintf（"%5d",prochain[k].id）;
printf（"\n"）;
printf（"priority"）;
for（k=1;kprintf（"%5d",prochain[k].priority）;
printf（"\n"）;
printf（"cputime"）;
for（k=1;kprintf（"%5d",prochain[k].cputime）;
printf（"\n"）;
printf（"alltime"）;
for（k=1;kprintf（"%5d",prochain[k].alltime）;
printf（"\n"）;
printf（"state"）;
for（k=1;kprintf（"%5c",prochain[k].state）;
printf（"\n"）;
printf（"next"）;
for（k=1;kprintf（"%5d",prochain[k].next）;
printf（"\n"）;
}
voidinsert（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;
}
voidinsert2（）/*PUTAPROCESSONTOTHETAILOFTHEQUEUE*/
{prochain[tail].next=run;
tail=run;
prochain[run].next=0;
}
voidinit（）/*CREATEAWAITINGQUEUE*/
{
inti;
head=0;
if（algo==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=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（）;
}
voidprisch（）/*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=0））
{
prochain[run].state='W';
insert（run）;
run=head;
prochain[run].state='R';
head=prochain[head].next;
}
}
print（）;
}
}
voidtimesch（）/*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（）;
四、实验结果：
（1）
（2）
五、实验心得：
通过本次实验，加深了对进程调度和调度算法的理解。
对于简单轮转法，既将全部的进程按照进入的先后顺序排成一个就绪队列，设置每隔一段时间后将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）为了检查程序的正确性，可自行确定若干组指令序列，运行设计的程序，核对执行结果。
四、代码:
#include
#include
#include
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算法
voidinit（）;
voidinsertPage（）;
voidpushback_Page（PAGETABLE*,PAGETABLE*）;
voidprint（PAGETABLE*）;
voidrun（int）;
voidfind_FIFO（）;
voidfind_LRU（）;
voidmain（void）
{
inti=0;
while
（1）
{
cout<<"\nPleaseselectanumber（1,2,0）"<cout<<"1--先进先出算法（FIFO）"<cout<<"2--最久未使用算法（LRU）"<
升级会员 