操作系统 实验报告 全Word格式文档下载.docx
《操作系统 实验报告 全Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《操作系统 实验报告 全Word格式文档下载.docx（13页珍藏版）》请在冰豆网上搜索。
/*模拟寄存器*/
intrun;
/*定义指向正在运行进程的进程控制块的指针*/
inthead;
inttail;
}ready;
/*定义指向就绪队列的头指针head和尾指针tail*/
intblock;
/*定义指向等待队列的指针*/
intpfree;
/*定义指向空闲进程控制块队列的指针*/
sheduling（）
/*进程调度函数*/
inti;
if（ready.head==-1）/*空闲进程控制块队列为空，退出*/
{
printf（"
无就绪进程\n"
）;
return0;
}
i=ready.head;
/*就绪队列头指针赋给i*/
ready.head=pcbarea[ready.head].next;
/*就绪队列头指针后移*/
if（ready.head==-1）ready.tail=-1;
/*就绪队列为空，修正尾指针ready.tail*/
pcbarea[i].status=running;
/*修改进程控制块状态*/
TIME=sometime;
/*设置相对时钟寄存器*/
/*恢复该进程现场信息：
*/
AX=pcbarea[run].ax;
BX=pcbarea[run].bx;
CX=pcbarea[run].cx;
DX=pcbarea[run].dx;
PC=pcbarea[run].pc;
PSW=pcbarea[run].psw;
/*修改指向运行进程的指针*/
run=i;
}/*进程调度函数结束*/
create（intx）
/*创建进程*/
if（pfree==-1）/*空闲进程控制块队列为空*/
无空闲进程控制块，进程创建失败\n"
i=pfree;
/*取空闲进程控制块队列的第一个*/
pfree=pcbarea[pfree].next;
/*pfree后移*/
/*填写该进程控制块内容：
pcbarea[i].name=x;
pcbarea[i].status=aready;
pcbarea[i].ax=x;
pcbarea[i].bx=x;
pcbarea[i].cx=x;
pcbarea[i].dx=x;
pcbarea[i].pc=x;
pcbarea[i].psw=x;
if（ready.head!
=-1）
/*就绪队列不空时，挂入就绪队列方式*/
pcbarea[ready.tail].next=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
else
/*就绪队列空时,挂入就绪队列方式：
ready.head=i;
}/*进程创建函数结束*/
main（）
/*系统初始化*/
intnum,j;
run=ready.head=ready.tail=block=-1;
pfree=0;
for（j=0;
j<
n-1;
j++）
pcbarea[j].next=j+1;
pcbarea[n-1].next=-1;
输入进程编号（避免编号的冲突,以负数输入结束,最多可以创建10个进程）:
\n"
scanf（"
%d"
&
num）;
while（num>
0）
create（num）;
sheduling（）;
if（run!
进程名进程状态寄存器内容:
axbxcxdxpcpsw:
%4d%10d%14d%3d%3d%3d%3d%3d\n"
pcbarea[run].name,
pcbarea[run].status,pcbarea[run].ax,pcbarea[run].bx,pcbarea[run].cx,
pcbarea[run].dx,pcbarea[run].pc,pcbarea[run].psw）;
}/*main（）结束*/
实验二可变分区管理方式的主存分配回收模拟
一、实验目的
深入了解动态分区存储管理方式主存分配回收的实现。
//动态分区存储管理方式的主存分配回收
#include<
fstream.h>
iostream.h>
iomanip.h>
string.h>
process.h>
#definen10//假定系统允许的最大作业为，假定模拟实验中n值为10
#definem10//假定系统允许的空闲区表最大为m，假定模拟实验中m值为10
#defineminisize100
ofstreamout（"
output.txt"
typedefstruct
floataddress;
//已分分区起始地址
floatlength;
//已分分区长度，单位为字节
intflag;
//已分配区表登记栏标志，用"
0"
表示空栏目,实验中只支持一个字符的作业名
}used;
//已分配区表
usedused_table[n];
//空闲区起始地址
//空闲区长度，单位为字节
//空闲区表登记栏标志，用"
表示空栏目，用"
1"
表示未分配
}freed;
//空闲区表
freedfree_table[m];
//采用最优分配算法分配xk大小的空间
voidallocate（charJ,floatxk）
inti,k;
floatad;
k=-1;
for（i=0;
i<
m;
i++）//寻找空间大于xk的最小空闲区登记项k
if（free_table[i].length>
=xk&
&
free_table[i].flag==1）
if（k==-1||free_table[i].length<
free_table[k].length）
k=i;
if（k==-1）//未找到可用空闲区，返回
cout<
<
"
无可用空闲区"
endl;
return;
}
//找到可用空闲区，开始分配：
若空闲区大小与要求分配的空间差小于msize大小，则空闲区全部分配；
若空闲区大小与要求分配的空间差大于minisize大小，则从空闲区划出一部分分配
if（free_table[k].length-xk<
=minisize）
free_table[k].flag=0;
ad=free_table[k].address;
xk=free_table[k].length;
else
free_table[k].length=free_table[k].length-xk;
ad=free_table[k].address+free_table[k].length;
//修改已分配区表
i=0;
//寻找空表目
while（used_table[i].flag!
=0&
n）i++;
//无表目填写已分分区
if（i>
=n）
已分配区表长度不足，分配失败，出错"
//修正空闲区表
if（free_table[k].flag==0）
free_table[k].flag=1;
//前面找到的是某个空闲分区的一部分
free_table[k].length=free_table[k].length+xk;
//修改已分配表
used_table[i].address=ad;
used_table[i].length=xk;
used_table[i].flag=J;
//回收作业名为J的作业所占主存空间
voidreclaim（charJ）
inti,k,j,s,t;
floatS,L;
//寻找已分配表中对应登记项
s=0;
while（（used_table[s].flag!
=J||used_table[s].flag==0）&
s<
n）
s++;
//在已分配表中找不到名字为J的作业
if（s>
=n）
未找到作业，回收失败"
used_table[s].flag=0;
//取得归还分区的起始地址S和长度L
S=used_table[s].address;
L=used_table[s].length;
j=-1;
//寻找回收分区的空闲上下邻，上邻表目k，下邻表目j
while（i<
m&
（j==-1||k==-1））
if（free_table[i].flag==1）
if（free_table[i].address+free_table[i].length==S）k=i;
//找到上邻
if（free_table[i].address==S+L）j=i;
//找到下邻
i++;
if（k!
if（j!
=-1）//上邻空闲区，下邻空闲区，三项合并
free_table[k].length=free_table[j].length+free_table[k].length+L;
free_table[j].flag=0;
else//上邻空闲区，下邻非空闲区，与上邻合并
free_table[k].length=free_table[k].length+L;
=-1）//上邻非空闲区，下邻为空闲区，与下邻合并
free_table[j].address=S;
free_table[j].length=free_table[j].length+L;
else//上下邻均为非空闲区，回收区域直接填入
{//在空闲区表中寻找空栏目
t=0;
while（free_table[t].flag==1&
t<
m）
t++;
if（t>
=m）//空闲区表满,回收空间失败,将已分配表复原
cout<
主存空闲表没有空间,回收空间失败"
used_table[s].flag=J;
return;
free_table[t].address=S;
free_table[t].length=L;
free_table[t].flag=1;
//主函数
voidmain（）
inti,j;
floatxk;
chars;
ifstreamin（"
input.txt"
//空闲分区表初始化
free_table[0].address=10240;
free_table[0].length=102400;
free_table[0].flag=1;
for（i=1;
i++）
free_table[i].flag=0;
//已分配表初始化
n;
used_table[i].flag=0;
while
（1）
请输入演示功能项:
"
================================="
endl<
0.退出"
1.分配主存"
2.回收主存"
3.显示主存"
请输入（0－3）:
cin>
>
j;
switch（j）
case0:
exit（0）;
case1:
输入作业名s（注意：
只能是一个字符）:
cin>
s;
作业所需长度xk:
xk;
xk<
allocate（s,xk）;
break;
case2:
输入要回收分区的作业名（注意：
只能是一个字符）"
reclaim（s）;
case3:
输出空闲区表：
\n起始地址分区长度标志\n"
;
for（i=0;
setw（6）<
free_table[i].address<
setw（9）<
free_table[i].length<
free_table[i].flag<
输出已分配区表：
if（used_table[i].flag!
=0）
used_table[i].address<
used_table[i].length<
char（used_table[i].flag）<
used_table[i].flag<
default:
没有该选项"
}//case
}//while
}//主函数结束
实验三文件操作模拟
读取file1的内容以行为单位倒置输出到file2中（改进）
这两个加一起是一个的答案
importjava.io.File;
importjava.io.FileReader;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.util.ArrayList;
publicclassTest
publicstaticvoidmain（String[]args）throwsIOException
Filefile1=newFile（"
D:
/f1.txt"
Filefile2=newFile（"
/f2.txt"
intc;
InputStreaminput1=System.in;
InputStreamReaderreader1=newInputStreamReader（input1）;
FileWriterwriter1=newFileWriter（file1）;
while（（c=reader1.read（））!
=-1）{
writer1.write（c）;
}
writer1.close（）;
FileReaderreader2=newFileReader（file1）;
FileWriterwriter2=newFileWriter（file2）;
ArrayList<
Integer>
list=newArrayList<
（）;
while（（c=reader2.read（））!
list.add（c）;
for（inti=list.size（）-1;
i>
=0;
--i）{
writer2.write（list.get（i））;
writer2.close（）;
升级会员 