上海大学操作系统2实验报告合集1Word文件下载.docx
《上海大学操作系统2实验报告合集1Word文件下载.docx》由会员分享，可在线阅读，更多相关《上海大学操作系统2实验报告合集1Word文件下载.docx（5页珍藏版）》请在冰豆网上搜索。
每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3，理是该进程如果在一个时间片中完成不了，优先级应该降低一级。
接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续进行，否则，调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。
（2）简单轮转法。
进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项。
每过一个时间片，运行进程占用处理机的时间片数加1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。
（3）程序框图 运行结果：
Priority算法：
RoundRobin算法：
实验代码：
//操作系统实验--进程调度#include#include#include#includeconstlongn=5;
structpcbtype{longid,priority,runtime,totaltime;
charstatus;
//R,W,F->
运行，就绪，完成//进程控制块结构}PCB[n+1];
longlink[n+1];
//链表结构longRUN,HEAD,TAIL;
//选择算法longChooseAlgo（）{ chars[128];
printf（\gets（s）;
if（s[0]==‘P’||s[0]==‘p’）}return1;
return0;
//初始化 voidinit（）{longi;
for（i=1;
ii;
j--）{if（PCB[sort[j]].priority>
PCB[sort[j-1]].priority）{k=sort[j];
sort[j]=sort[j-1];
sort[j-1]=k;
}}}//根据优先数排序 longsort[n+1];
PCB[RUN].priority-=3;
//优先级减3PCB[RUN].runtime++;
if（PCB[RUN].totaltime==0）{PCB[RUN].status=‘F’;
RUN=HEAD;
if（HEAD!
=-1）HEAD=link[HEAD];
PCB[RUN].status=‘R’;
}else{if（HEAD!
=-1&
&
PCB[RUN].priorityPCB[RUN].priority）k=link[k];
if（k==TAIL）{link[k]=RUN;
TAIL=RUN;
link[RUN]=-1;
RUN=HEAD;
HEAD=link[HEAD];
PCB[RUN].status=‘R’;
}else{link[RUN]=link[k];
link[k]=RUN;
RUN=HEAD;
//链首进程开始运行//插入链中//插入链尾之后//进程运行完成HEAD=link[HEAD];
}}} }showit（）;
}//轮转调度算法 voidmain_round_robin（）{longi;
init（）;
//设置就绪链HEAD=1;
i PCB[RUN].status=‘W’;
//插入链尾link[TAIL]=RUN;
link[RUN]=-1;
TAIL=RUN;
RUN=HEAD;
//链首进程开始运行HEAD=link[HEAD];
}}}showit（）;
}//主函数 intmain（）{longalgo;
srand（time（NULL））;
algo=ChooseAlgo（）;
if（algo==1）{main_priority（）;
//优先数法}else{main_round_robin（）;
//简单轮转法}printf（\return0;
}实验体会：
通过写代码的过程更加清晰地了解了两种算法的思想和用处，对算法的了解加深的同事也锻炼了写代码的能力。
《计算机操作系统》实验二报告 实验二题目：
死锁观察与避免姓名：
LinuxUbuntu系统实验目的：
1、目的 死锁会引起计算机工作僵死,造成整个系统瘫痪。
因此,死锁现象是操作系统特别是大型系统中必须设法防止的。
学生应独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序,观察死锁产生的条件,并采用适当的算法,有效的防止死锁的发生。
通过实习,更直观地了解死锁的起因,初步掌握防止死锁的简单方法,加深理解课堂上讲授过的知识。
2、要求
（1）设计一个n个并发进程共享m个系统资源的系统。
进程可动态地申请资源和释放资源。
系统按各进程的申请动态地分配资源。
（2）系统应能显示各进程申请和释放资源以及系统动态分配资源的过程,便于用户观察和分析。
（3）系统应能选择是否采用防止死锁算法或选用何种防止算法（如有多种算法）。
在不采用防止算法时观察死锁现象的发生过程。
在使用防止死锁算法时,了解在同样申请条件下,防止死锁的过程。
实验内容：
1、题目 本示例采用银行算法防止死锁的发生。
假设有三个并发进程共享十个系统。
在三个进程申请的系统资源之和不超过10时,当然不可能发生死锁,因为各个进程申请的资源都能满足。
在有一个进程申请的系统资源数超过10时,必然会发生死锁。
应该排除这二种情况。
程序采用人工输入各进程的申请资源序列。
如果随机给各进程分配资源,就可能发生死锁,这也就是不采用防止死锁算法的情况。
假如,按照一定的规则,为各进程分配资源,就可以防止死锁的发生。
示例中采用了银行算法。
这是一种犹如“瞎子爬山”的方法,即探索一步,前进一步,行不通,再往其他方向试探,直至爬上山顶。
这种方法是比较保守的。
所花的代价也不小。
2、代码 #includeusingnamespacestd;
#includeintRes[15];
intn,m;
structProcess{ intHad[15];
intMax[15];
intNeed[15];
boolIsEnd;
}Processes[15];
intcurProcess;
intReq[15];
ProcesstmpProcesses[15];
boolIsEnd（）{ boolR=true;
for（inti=0;
i boolIstmpEnd（）{boolR=true;
for（inti=0;
i boolLegal=false;
boolBanker（）{Legal=true;
iProcesses[curProcess].Need[i]）{ Legal=false;
break;
}} for（inti=0;
iRes[i]）{ Legal=false;
}} inttmp[15];
i tmp[i]=Res[i];
} for（inti=0;
itmp[i]）{ IsFF=false;
break;
} } IsFind=IsFF;
if（IsFind==true）{ curRel=i;
} } }if（IsFind）{ for（inti=0;
i }while（!
IstmpEnd（）&
IsFind==true）;
i if（tmpProcesses[i].IsEnd==false）{ Legal=false;
}} returnLegal;
} intmain（）{ memset（Processes,0,sizeof（Processes））;
memset（Res,0,sizeof（Res））;
memset（Req,0,sizeof（Req））;
cin>
>
n>
m;
i>
Res[i];
} for（inti=0;
Processes[i].Had[j]>
Processes[i].Max[j];
}} intoption=-1;
option;
if（option==0）{ do{ for（inti=0;
i cin>
curProcess;
Req[i];
} Legal=false;
Banker（）;
if（Legal）{ Processes[curProcess].IsEnd=true;
i } }while（!
IsEnd（））;
} return0;
} 3、程序运行结果INPUT:
OPTION=0 CLAIMOFPROCESS1IS:
123-1-10CLAIMOFPROCESS2IS:
2311-20CLAIMOFPROCESS3IS:
125-1-20MAXCLAIMOFPROCESS1IS:
6MAXCLAIMOFPROCESS2IS:
7MAXCLAIMOFPROCESS3IS:
8 THESYSTEMALLOCTIONPROCESSISASFOLLOWS:
PROCESSCLAIMALLOCATIONREMAINDER
（1）1119 RESOURCEISALLOCATEDTOPROCESS1
（2）2227 RESOURCEISALLOCATEDTOPROCESS2（3）3116 RESOURCEISALLOCATEDTOPROCESS3（4）1234 RESOURCEISALLOCATEDTOPROCESS1（5）2324 IFALLOCATED,DEADLOCKMAYOCCUR（6）1234 THEREMAINDERISLESSTHANPROCESS2CLAIMS（7）30010 PROCESS3HASFINISHED,RETURNITSRESOURSETHEWHOLEWORKISCOMPLETED ******************************************** 《计算机操作系统》实验三报告 实验三题目：
请求页式存储管理 姓名：
近年来，于大规模集成电路和超大规模集成电路技术的发展，使存储器的容量不断扩大，价格大幅度下降。
但从使用角度看，存储器的容量和成本总受到一定的限制。
所以，提高存储器的效率始终是操作系统研究的重要课题之一。
虚拟存储技术是用来扩大内存容量的一种重要方法。
学生应独立地用高级语言编写几个常用的存储分配算法，并设计一个存储管理的模拟程序，对各种算法进行分析比较，评测其性能优劣，从而加深对这些算法的了解。
为了比较真实地模拟存储管理，可预先生成一个大致符合实际情况的指令地址流。
然后模拟这样一种指令序列的执行来计算和分析各种算法的访问命中率。
本实验采用页式分配存储管理方案，并通过分析计算不同页面淘汰算法情况下的访问命中率来比较各种算法的优劣。
另外也考虑到改变页面大小和实际存储器容量对计算结果的影响，从而可为算则好的算法、合适的页面尺寸和实存容量提供依据。
实验是按下述原则生成指令序列的：
（1）50%的指令是顺序执行的。
（2）25%的指令均匀散布在前地址部分。
（3）25%的指令均匀散布在后地址部分。
示例中选用最佳淘汰算法和最近最少使用页面淘汰算法计算页面命中率。
公式为假定虚存容量为32K，页面尺寸从1K至8K，实存容量从4页至32页。
最佳淘汰算法 这是一种理想的算法，可用来作为衡量其他算法优劣的根据，在实际系统中是难以实现的，因为它必须先知道指令的全部地址流。
于本示例中已预生成了全部的指令地址流，故可计算出最佳命中率。
该算法的准则是淘汰已满页表中不再访问或是最迟访问的的页。
这就要求将页表中的页逐个与后继指令访问的所有页比较，如后继指令不在访问该页，则把此页淘汰，不然得找出后继指令中最迟访问的页面淘汰。
可见最佳淘汰算法要花费比较长的运算时间。
最近最少使用页淘汰算法 这是一种经常使用的方法，有各种不同的实施方案，这里采用的是不断调整页表链的方法，即总是淘汰页表链链首的页，而把新访问的页插入链尾。
如果当前调用页已在页表内，则把它再次调整到链尾。
这样就能保证最近使用的页，总是处于靠近链尾部分，而不常使用的页就移到链首，逐个被淘汰，在页表较大时，调整页表链的代价也是不小的。
操作过程：
编写程序：
#include#include#include#include#include#include#include#include#includeusingnamespacestd;
intadress[32];
//全局变量数组，地址流intp;
//全局变量p是一共有多少地址流voidinit（）{//初始化函数, intt;
srand（time（0））;
//随机产生指令序列 p=12+rand（）2;
cout=m）{ queye++;
}} if（flag==1）{ inttemp[10]={0};
for（inti=0;
itemp[i]）{ min=temp[i];
index=i;
} } intl=leaflink[index];
leaflink[index]=leaflink[0];
leaflink[0]=l;
} for（intj=0;
j mfd[i].user=i;
memset（f,0,sizeoff）;
for（intj=0;
j>
x;
if（x=10）{ cout>
s;
switch（s）{ case1:
if（flag3）{ cout>
mfd[x].p[0].fname;
cout>
mfd[x].p[0].len;
mfd[x].p[0].procode[i];
for（intj=0;
mfd[x].p[index].fname;
mfd[x].p[index].len;
mfd[x].p[index].procode[i];
t;
file;
file1;
file2;
i 实验体会：
本次实验主要是模拟了一下文件系统，文件是我们平时接触最多也是最广的形式，即便是不会计算机的人们也可以通过这种操作文件来很方便地完成操作，而本次实验让我了解到了文件系统的内部实现，虽然仅仅是通过C++模拟的，但还是让我对它的原理有了更好的理解，也是对我们上课的内容的一个巩固。
《计算机操作系统》实验五报告 实验五题目：
Linux文件系统实验 实验目的：
return0;
} intmain（intargc,char*argv）{inti,ret;
for（i=1;
i {ret=ShowFileInfo（argv[i]）;
if（argc-i>
1）printf（\} returnret;
} // #include externintetext,edata,end;
main（）{ printf（\} // #include#include#include#include#include #defineSHW_ADR（ID,I）printf（\externintetext,edata,end;
char*cptr=\charbuffer1[25];
main（） {voidshowit（char*）;
inti=0;
printf（\ SHW_ADR（\ SHW_ADR（\ SHW_ADR（\ SHW_ADR（\ SHW_ADR（\ strcpy（buffer1,\ write（1,buffer1,strlen（buffer1）+1）;
for（;
i void showit（char*p）{char*buffer2;
SHW_ADR（\ if（（buffer2=（char*）malloc（（unsigned）（strlen（p）+1）））!
=NULL） {strcpy（buffer2,p）;
printf（\ free（buffer2）;
} else {printf（\ exit
（1）;
}} // #include#include intmain（intargc,char*argv）{chars[1024];
FILE*fp;
if（（fp=fopen（argv[1],\ {while（（fgets（s,1024,fp））!
=（char*）0） puts（s）;
} else {fprintf（stderr,\ exit
（1）;
} exit（0）;
} 《计算机操作系统》实验六报告 实验六题目：
FAT文件系统实验 姓名：
win95虚拟机实验目的：
从系统分析的角度出发，了解FAT文件系统的组织结构和文件的存储方式。
进一步理解操作系统文件管理的基本思想。
实验内容：
1.了解3吋软盘的FAT文件系统结构。
2.察看文件分配表的簇号链。
3.察看文件目录表中文件目录结构。
4.了解用簇号链映射的文件链式存储结构。
5.分析目录文件的组成。
实验步骤：
1.进入DEBUG环境，装入FAT文件系统结构。
执行命令：
L00021 说明：
将0号驱动器中，逻辑扇区号从0开始的共21H个扇区读入内存，放在DS:
0000为起始的地址中。
2．观察软盘中FAT12文件系统结构。
D0000 连续执行D命令，每次显示128个字节，可见文件系统结构。
FAT文件系统结构如下：
逻辑扇区号 其中：
Boot引导程序FAT文件分配表FDT文件目录表 软盘逻辑扇号与物理扇区的对应关系逻辑扇号0#——0道0面1扇 逻辑扇号1H~11H——0道0面2~18扇逻辑扇号12H~23H——0道1面1扇~18扇逻辑扇号24H~35H——1道0面1扇~18扇 软盘有两面，每面80个磁道，每个磁道18个扇区，每个扇区512个字节，所以软盘的容量是2*80*18*512=1474560,1474560/1024/1024大约为。
3．分析文件分配表结构，了解用簇链映射的文件的链式存储结构。
D200 思考：
上面屏幕显示首簇号为003的文件共包括几个扇区？
它分布在哪几个物理扇区上？
答：
首簇号为003的文件共包括2个扇区，它分布在0道0面2、3扇。
4．观察软盘中文件目录表FDT以及文件目录结构执行命令：
将逻辑扇区0H开始的共21H个物理扇区装入DS:
0000H起始的内存。
D2600 说明：
显示从2600H地址开始的FDT文件表。
思考：
①计算的软盘根目录最多可以容纳多少文件？
软盘的文件目录表FDT共14个扇区，每个文件的目录登记项占用32个字节，用作目录的一个扇区最多只能装入512/32=16个文件。
因此，软盘的根目录下最多可建文件或子目录224个。
②上图屏幕显示的文件的目录项中标示该文件的首簇号在何处？
该文件是什么属性？
首簇号在第2行的1A～1B
升级会员 