上海大学操作系统二实验报告全Word格式文档下载.docx
《上海大学操作系统二实验报告全Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《上海大学操作系统二实验报告全Word格式文档下载.docx（45页珍藏版）》请在冰豆网上搜索。
进程所需时间片数
进程状态
进程控制块链结构如下：
其中：
RUN—当前运行进程指针；
HEAD—进程就绪链链首指针；
TAID—进程就绪链链尾指针。
2、算法与框图
（1）优先数法。
进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。
每过一个
时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3，
理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。
接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续进行，否则，调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。
（2）简单轮转法。
进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时
间按其重要程度登入进程控制块中的轮转时间片数记录项（相当于优先数法的优先数记录项位置）。
每过一个时间片，运行进程占用处理机的时间片数加1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。
（3）程序框图
运行结果：
Priority算法：
RoundRobin算法：
实验代码：
//操作系统实验--进程调度
#include<
cstdio>
ctime>
cstring>
cstdlib>
constlongn=5;
structpcbtype//进程控制块结构
{
longid,priority,runtime,totaltime;
charstatus;
//R,W,F->
运行，就绪，完成
}PCB[n+1];
longlink[n+1];
//链表结构
longRUN,HEAD,TAIL;
//选择算法
longChooseAlgo（）
{
chars[128];
printf（"
PleasetypetheAlgorithm（Priority\\RoundRobin）:
"
）;
gets（s）;
if（s[0]=='
P'
||s[0]=='
p'
）
return1;
return0;
}
//初始化
voidinit（）
longi;
for（i=1;
i<
=n;
i++）
PCB[i].id=i;
PCB[i].priority=rand（）%4+1;
PCB[i].runtime=0;
PCB[i].totaltime=rand（）%8+1;
PCB[i].status='
W'
;
//显示进程调度状况
voidshowit（）
=====================================================\n"
%-25s"
"
ID"
i++）printf（"
%4ld"
PCB[i].id）;
\n%-25s"
PRIORITY//TURNTIME"
PCB[i].priority）;
"
CPUTIME"
PCB[i].runtime）;
ALLTIME"
PCB[i].totaltime）;
STATUS"
%4c"
PCB[i].status）;
\n=====================================================\n"
if（RUN!
=-1）printf（"
RUNNINGPROCESS:
%ld\n"
RUN）;
elseprintf（"
NULL\n"
WAITINGQUEUE:
"
for（i=HEAD;
i!
=-1;
i=link[i]）printf（"
%ld"
i）;
\n\n"
//优先数调度算法
voidmain_priority（）
longi,j,k;
longsort[n+1];
init（）;
//设置就绪链
sort[i]=i;
i++）//根据优先数排序
for（j=n;
j>
i;
j--）
if（PCB[sort[j]].priority>
PCB[sort[j-1]].priority）
k=sort[j];
sort[j]=sort[j-1];
sort[j-1]=k;
HEAD=sort[1];
n;
link[sort[i]]=sort[i+1];
TAIL=sort[n];
link[TAIL]=-1;
RUN=-1;
//就绪链设置完毕
RUN=HEAD;
PCB[RUN].status='
R'
HEAD=link[HEAD];
//运行链首进程
while（RUN!
=-1）
showit（）;
PCB[RUN].totaltime--;
PCB[RUN].priority-=3;
//优先级减3
PCB[RUN].runtime++;
if（PCB[RUN].totaltime==0）//进程运行完成
PCB[RUN].status='
F'
RUN=HEAD;
if（HEAD!
else
=-1&
&
PCB[RUN].priority<
PCB[HEAD].priority）
k=HEAD;
//寻找等待链中的合适位置
while（k!
=TAIL&
PCB[link[k]].priority>
PCB[RUN].priority）
k=link[k];
if（k==TAIL）
link[k]=RUN;
//插入链尾之后
TAIL=RUN;
link[RUN]=-1;
RUN=HEAD;
link[RUN]=link[k];
//插入链中
//链首进程开始运行
//轮转调度算法
voidmain_round_robin（）
HEAD=1;
link[i]=i+1;
TAIL=n;
link[TAIL]=-1;
//运行首进程
if（PCB[RUN].totaltime==0）//进程运行完成
HEAD=link[HEAD];
PCB[RUN].runtime%PCB[RUN].priority==0）//轮转时间到
PCB[RUN].status='
//插入链尾
link[TAIL]=RUN;
link[RUN]=-1;
TAIL=RUN;
RUN=HEAD;
//链首进程开始运行
HEAD=link[HEAD];
//主函数
intmain（）
longalgo;
srand（time（NULL））;
algo=ChooseAlgo（）;
if（algo==1）
main_priority（）;
//优先数法
main_round_robin（）;
//简单轮转法
SYSTEMFINISHED\n"
实验体会：
通过写代码的过程更加清晰地了解了两种算法的思想和用处，对算法的了解加深的同事也锻炼了写代码的能力。
《计算机操作系统》实验三报告
实验三题目：
请求页式存储管理
近年来，由于大规模集成电路（LSI）和超大规模集成电路（VLSI）技术的发
展，使存储器的容量不断扩大，价格大幅度下降。
但从使用角度看，存储器的容
量和成本总受到一定的限制。
所以，提高存储器的效率始终是操作系统研究的重
要课题之一。
虚拟存储技术是用来扩大内存容量的一种重要方法。
学生应独立地
用高级语言编写几个常用的存储分配算法，并设计一个存储管理的模拟程序，对
各种算法进行分析比较，评测其性能优劣，从而加深对这些算法的了解。
实验内容：
为了比较真实地模拟存储管理，可预先生成一个大致符合实际情况的指令地址流。
然后模拟这样一种指令序列的执行来计算和分析各种算法的访问命中率。
本实验采用页式分配存储管理方案，并通过分析计算不同页面淘汰算法情况下的访问命中率来比较各种算法的优劣。
另外也考虑到改变页面大小和实际存储器容量对计算结果的影响，从而可为算则好的算法、合适的页面尺寸和实存容量提供依据。
实验是按下述原则生成指令序列的：
（1）50%的指令是顺序执行的。
（2）25%的指令均匀散布在前地址部分。
（3）25%的指令均匀散布在后地址部分。
示例中选用最佳淘汰算法（OPT）和最近最少使用页面淘汰算法（LRU）计算页面命中率。
公式为假定虚存容量为32K，页面尺寸从1K至8K，实存容量从4页至32页。
（1）最佳淘汰算法（OPT）
这是一种理想的算法，可用来作为衡量其他算法优劣的根据，在实际系统中是难以实现的，
因为它必须先知道指令的全部地址流。
由于本示例中已预生成了全部的指令地址流，故可计算出最佳命中率。
该算法的准则是淘汰已满页表中不再访问或是最迟访问的的页。
这就要求将页表中的页逐个与后继指令访问的所有页比较，如后继指令不在访问该页，则把此页淘汰，不然得找出后继指令中最迟访问的页面淘汰。
可见最佳淘汰算法要花费比较长的运算时间。
（2）最近最少使用页淘汰算法（LRU）
这是一种经常使用的方法，有各种不同的实施方案，这里采用的是不断调整页表链的方法，
即总是淘汰页表链链首的页，而把新访问的页插入链尾。
如果当前调用页已在页表内，则把
它再次调整到链尾。
这样就能保证最近使用的页，总是处于靠近链尾部分，而不常使用的页
就移到链首，逐个被淘汰，在页表较大时，调整页表链的代价也是不小的。
操作过程：
编写程序：
iostream>
process.h>
algorithm>
cmath>
usingnamespacestd;
intadress[32];
//全局变量数组，地址流
intp;
//全局变量p是一共有多少地址流
voidinit（）{//初始化函数,
intt;
srand（time（0））;
//随机产生指令序列
p=12+rand（）%32;
cout<
<
地址流个数P="
p<
endl;
随机产生的地址流序列\n"
for（inti=0,j=0;
i<
p;
i++,j++）{
t=1+rand（）%9;
adress[i]=t;
//将随机产生的指令数存入页面流
a[%d]=%d"
i,t）;
j=j%5;
if（i<
10）printf（"
if（j==4）printf（"
\n"
}
voidOPT（intn）{//FIFO算法，n是M的值
inte,q=p,m=n-1;
intflag;
intflag1;
intqueye=0;
intleaflink[32];
memset（leaflink,0,sizeof（leaflink））;
for（intx=0;
x<
q;
x++）{
e=x;
flag=0;
for（inti=0;
i++）{
if（leaflink[i]==adress[x]）{
flag=1;
flag1=i;
printf（"
有相同\n"
break;
}
}
if（flag==0）{
intk=0;
for（intj=0;
j<
m;
j++）{//012
leaflink[k]=leaflink[k+1];
k++;
leaflink[m]=adress[e];
if（e>
=m）{
queye++;
if（flag==1）{
inttemp[10]={0};
for（inti=0;
=m;
for（inta=e+1;
a<
a++）{
if（leaflink[i]==adress[a]）{
temp[i]++;
}}
intindex=0;
intmin=temp[0];
if（min>
temp[i]）{
min=temp[i];
index=i;
intl=leaflink[index];
leaflink[index]=leaflink[0];
leaflink[0]=l;
j++）
leaflink[%d]=%d"
j,leaflink[j]）;
M="
n<
时FIFO的命中率为：
（1-（（double）queye/p））*100<
%"
voidLRU（intn）{//LRU算法
inti;
intm=n-1;
intq=p;
inte;
inty;
for（i=0;
X=%d,lru[%d]=adress[%d]=%d,flag=1\n"
x,i,x,adress[x]）;
for（intj=0;
leaflink[k]=leaflink[k+1];
leaflink[m]=adress[e];
queye++;
elseif（flag==1）{
y=flag1;
j++）{
leaflink[flag1]=leaflink[flag1+1];
flag1++;
leaflink[3]=adress[e];
printf（"
发现相同后，改变leaflink[%d]=%d\n"
m,leaflink[3]）;
for（intj=0;
发生替换次数：
queye<
时LRU的命中率为：
intmain（）
charc;
请输入选择算法（O:
最佳淘汰L：
最近最少使用）：
cin>
>
c;
if（c=='
O'
for（inti=3;
4;
OPT（i）;
elseif（c=='
L'
）{
for（inti=4;
5;
LRU（i）;
cout<
最近最少使用：
最佳淘汰：
实验体会：
通过这次实验，我了解了采用页式分配存储管理方案，并对页式分配存储管理的两个算法最佳淘汰算法和最近最少使用页淘汰算法有了更深入的了解，为之后的学习奠定了基础。
《计算机操作系统》实验四报告
实验四题目：
文件操作与管理
随着社会信息量的极大增长，要求计算机处理的信息与日俱增，涉及到社会生活的各个
方面。
因此，文件管理是操作系统的一个极为重要的组成部分。
学生应独立地用高级语言编
写和调试一个简单的文件系统，模拟文件管理的工作过程。
从而对各种文件操作命令的实质内容和执行过程有比较深入的了解，掌握它们的实施方法，加深理解课堂上讲授过的知识。
1.要求：
（1）实际一个n个用户的文件系统，每个用户最多可保存m个文件。
（2）限制用户在一次运行中只能打开l个文件。
（3）系统应能检查打入命令的正确性，出错要能显示出错原因。
（4）对文件必须设置保护措施，如只能执行，允许读、允许写等。
在每次打开文件时
根据本次打开的要求，再次设置保护级别，即可有二级保护。
（5）对文件的操作至少应有下述几条命令：
creat建立文件。
delete删除文件。
open打开文件。
close关闭文件。
read读文件。
write写文件。
2.示例：
（1）程序采用二级文件目录，即设置了主文件目录（MFD）和用户文件目录（UFD）。
前者应包含文件主（即用户）及他们的目录区指针；
后者应给出每个文件主占有的文件目录，
即文件名，保护码，文件长度以及他们存放的位置等。
另外为打开文件设置了运行文件
目录（AFD），在文件打开时应填入打开文件号，本次打开保护码和读写指针等。
3.算法与框图
（1）因系统小，文件目录的检索使用了简单的线性搜索，而没有采用Hash等有效算法。
（2）文件保护简单实用了三位保护码，对应于允许读、允许写和运行执行，如下所示：
111
允许写允许读允许执行
如对应位为0，则不允许。
实验源码：
#inclu
升级会员 