操作系统实习研究报告.docx
《操作系统实习研究报告.docx》由会员分享，可在线阅读，更多相关《操作系统实习研究报告.docx（33页珍藏版）》请在冰豆网上搜索。
操作系统实习研究报告
实习一处理器调度
一、实习内容
选择一个调度算法，实现处理器调度。
二、实习目的
在采用多道程序设计的系统中，往往若干个进程同时处于就绪状态。
当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占有处理器。
本实习模拟在单处理器情况下的处理器调度，加深了解处理器调度的工作。
三、实习题目
设计一个按优先数调度算法实现处理器调度的程序。
[提示]：
（1）假定系统有5个进程，每个进程用一个PCB来代表。
PCB的格式为：
进程名、指针、要求运行时间、优先数、状态。
进程名——P1~P5。
指针——按优先数的大小把5个进程连成队列，用指针指出下一个进程PCB的首地址。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——假设两种状态，就绪，用R表示，和结束，用E表示。
初始状态都为就绪状态。
（2）每次运行之前，为每个进程任意确定它的“优先数”和“要求运行时间”。
（3）处理器总是选队首进程运行。
采用动态改变优先数的办法，进程每运行1次，优先数减1，要求运行时间减1。
（4）进程运行一次后，若要求运行时间不等于0，则将它加入队列，否则，将状态改为“结束”，退出队列。
（5）若就绪队列为空，结束，否则，重复（3）。
四、数据结构及符号说明
进程的定义：
structpcb
{/*定义进程控制块PCB*/
charname[10];/*进程名*/
charstate;/*进程状态，就绪或者完成*/
intsuper;/*进程优先级*/
intneedtime;/*进程所需时间*/
intruntime;/*进程已完成时间*/
structpcb*link;/*指向下一进程*/
}
函数说明：
1.voidinsert（）
功能：
进程优先级排列函数，比较进程优先级，将其插入适当的位置。
参数：
super,依据进程优先级super来确定进程的插入位置。
调用：
被进程控制块函数和进程就绪函数调用。
2.voidinput（）
功能：
进程控制块函数
参数：
num,i,name,super,needtime
调用：
主函数main（）调用
3.voiddisp（PCB*pr）
功能：
进程显示函数，用于显示当前进程。
参数：
name,state,super,needtime,runtime
调用：
被进程查看函数check（）调用
4.voidcheck（）
功能：
进程查看函数，用于显示当前运行进程和就绪队列状态。
参数：
PCB*prpr=ready
调用：
被主函数main（）调用
5.voiddestroy（）
功能：
进程撤消函数，用于当进程运行结束时，撤消进程。
参数：
p->name
调用：
被进程就绪函数running（）调用
6.voidrunning（）
功能：
进程就绪函数，当进程运行时间到，置进程就绪状态。
参数：
p->runtime
调用：
被主函数main（）调用
7.main（）
功能：
主函数
五、程序流程图
六、实验源程序
#include
#include
#include
#definegetpch（type）（type*）malloc（sizeof（type））
structpcb
{/*定义进程控制块PCB*/
charname[10];
charstate;
intsuper;
intneedtime;
intruntime;
structpcb*link;
}
*ready=NULL,*p;
typedefstructpcbPCB;
voidsort（）/*建立对进程进行优先级排列函数*/
{
PCB*first,*second;
intinsert=0;
if（（ready==NULL）||（（p->super）>（ready->super）））/*优先级最大者,插入队首*/
{
p->link=ready;
ready=p;
}
else/*进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->link;
while（second!
=NULL）
{
if（（p->super）>（second->super））/*若插入进程比当前进程优先数大,*/
{/*插入到当前进程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else/*插入进程优先数最低,则插入到队尾*/
{
first=first->link;
second=second->link;
}
}
if（insert==0）first->link=p;
}
}
intinput（）/*建立进程控制块函数*/
{
inti,num;
printf（"\n请输入进程数?
"）;
scanf（"%d",&num）;
for（i=0;i{
printf（"\n进程号P%d:
\n",i）;
p=getpch（PCB）;
printf（"\n输入进程名:
"）;
scanf（"%s",p->name）;
printf（"\n输入进程优先数:
"）;
scanf（"%d",&p->super）;
printf（"\n输入进程运行时间:
"）;
scanf（"%d",&p->needtime）;
printf（"\n"）;
p->runtime=0;p->state='w';
p->link=NULL;
sort（）;/*调用sort函数*/
}
returnnum;
}
voiddisp（PCB*pr）/*建立进程显示函数,用于显示当前进程*/
{
printf（"\nqname\tstate\tsuper\tndtime\truneedtime\n"）;
printf（"|%s\t",pr->name）;
printf（"|%c\t",pr->state）;
printf（"|%d\t",pr->super）;
printf（"|%d\t",pr->needtime）;
printf（"|%d\t",pr->runtime）;
printf（"\n"）;
}
voidcheck（）/*建立进程查看函数*/
{
PCB*pr;
printf（"\n****当前正在运行的进程是:
%s",p->name）;/*显示当前运行进程*/
disp（p）;
pr=ready;
printf（"\n****当前就绪队列状态为:
\n"）;/*显示就绪队列状态*/
while（pr!
=NULL）
{
disp（pr）;
pr=pr->link;
}
}
voiddestroy（）/*建立进程撤消函数（进程运行结束,撤消进程）*/
{
printf（"\n进程[%s]已完成.\n",p->name）;
free（p）;
}
voidrunning（）/*建立进程就绪函数（进程运行时间到,置就绪状态*/
{
（p->runtime）++;
if（p->runtime==p->needtime）
destroy（）;/*调用destroy函数*/
else
{
（p->super）--;
p->state='w';
sort（）;/*调用sort函数*/
}
}
main（）/*主函数*/
{
intlen,h=0;
charch;
len=input（）;
while（（len!
=0）&&（ready!
=NULL））
{
ch=getchar（）;
h++;
printf（"\nTheexecutenumber:
%d\n",h）;
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check（）;
running（）;
printf（"\n按任一键继续......"）;
ch=getchar（）;
}
printf（"\n\n进程已经完成.\n"）;
ch=getchar（）;
}
实习二主存空间的分配和回收
一、实习内容
主存储器空间的分配和回收。
二、实习目的
通过本实习帮助理解在不同的存储管理方式下应怎样进行存储空间的分配和回收。
三、实习题目
第一题：
在可变分区管理方式下采用首次适应算法实现主存分配和回收。
[提示]：
（1）可变分区方式是按作业需要的主存空间大小来分割分区的。
当要装入一个作业时，根据作业需要的主存容量查看是否有足够的空闲空间，若有，则按需分配，否则，作业无法装入。
假定内存大小为128K，初始状态见右图。
空闲区说明表格式为：
起始地址——指出空闲区的起始地址；长度——一个连续空闲区的长度；状态——有两种状态，一种是“未分配”状态，另一种是“空表目”状态。
（2）采用首次适应算法分配。
运行时，输入一系列分配请求和回收请求。
四、程序流程
为了说明哪些区是空闲的，可以用来装入新作业，必须要有一张空闲区说明表，格式如下：
起址
长度
状态
第一栏
14K
12K
未分配
第二栏
32K
96K
未分配
空表目
空表目
其中：
起址——指出一个空闲区的主存起始地址。
长度——指出从起始地址开始的一个连续空闲的长度。
状态——有两种状态，一种是“未分配”状态，指出对应的由起址指出的某个长度的
分配算法流程图：
回收算法流程图：
六、实验源程序
#include
#include
#include
#definen10/*假定系统允许的最大作业为，假定模拟实验中n值为10*/
#definem10/*假定系统允许的空闲区表最大为m，假定模拟实验中m值为10*/
#defineminisize100
struct
{
floataddress;/*已分分区起始地址*/
floatlength;/*已分分区长度，单位为字节*/
intflag;/*已分配区表登记栏标志，用"0"表示空栏目*/
}used_table[n];/*已分配区表*/
struct
{
floataddress;/*空闲区起始地址*/
floatlength;/*空闲区长度，单位为字节*/
intflag;/*空闲区表登记栏标志，用"0"表示空栏目，用"1"表示未分配*/
}free_table[m];/*空闲区表*/
voidallocate（charJ,floatx）/*采用首次适应算法分配x大小的空间*/
{
inti,k;
floatad;
k=-1;
for（i=0;iif（free_table[i].length>=x&&free_table[i].flag==1）
if（k==-1||free_table[i].lengthk=i;
if（k==-1）/*未找到可用空闲区，返回*/
{
printf（"无可用空闲区\n"）;
return;
}
/*找到可用空闲区，开始分配：
若空闲区大小与要求分配的空间差小于msize大小，则空闲区全部分配；若空闲区大小与要求分配的空间差大于minisize大小，则从空闲区划出一部分分配*/
if（free_table[k].length-x<=minisize）
{
free_table[k].flag=0;
ad=free_table[k].address;
x=free_table[k].length;
}
else
{
free_table[k].length=free_table[k].length-x;
ad=free_table[k].address+free_table[k].length;
}
/*修改已分配区表*/
i=0;
while（used_table[i].flag!
=0&&ii++;
if（i>=n）/*无表目填写已分分区*/
{
printf（"无表目填写已分分区，错误\n"）;
/*修正空闲区表*/
if（free_table[k].flag==0）
/*前面找到的是整个空闲分区*/
free_table[k].flag=1;
else
{/*前面找到的是某个空闲分区的一部分*/
free_table[k].length=free_table[k].length+x;
return;
}
}
else
{/*修改已分配表*/
used_table[i].address=ad;
used_table[i].length=x;
used_table[i].flag=J;
}
return;
}/*主存分配函数结束*/
voidreclaim（charJ）
/*回收作业名为J的作业所占主存空间*/
{
inti,k,j,s,t;
floatS,L;
/*寻找已分配表中对应登记项*/
s=0;
while（（used_table[s].flag!
=J||used_table[s].flag==0）&&ss++;
if（s>=n）/*在已分配表中找不到名字为J的作业*/
{
printf（"找不到该作业\n"）;
return;
}
/*修改已分配表*/
used_table[s].flag=0;
/*取得归还分区的起始地址S和长度L*/
S=used_table[s].address;
L=used_table[s].length;
j=-1;k=-1;i=0;
/*寻找回收分区的空闲上下邻，上邻表目k，下邻表目j*/
while（i{
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!
=-1）
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;
else
if（j!
=-1）
/*上邻非空闲区，下邻为空闲区，与下邻合并*/
{
free_table[j].address=S;
free_table[j].length=free_table[j].length+L;
}
else
/*上下邻均为非空闲区，回收区域直接填入*/
{
/*在空闲区表中寻找空栏目*/
t=0;
while（free_table[t].flag==1&&tt++;
if（t>=m）/*空闲区表满,回收空间失败,将已分配表复原*/
{
printf（"主存空闲表没有空间,回收空间失败\n"）;
used_table[s].flag=J;
return;
}
free_table[t].address=S;
free_table[t].length=L;
free_table[t].flag=1;
}
return;
}/*主存回收函数结束*/
main（）
{
inti,a;
floatx;
charJ;
/*空闲分区表初始化：
*/
free_table[0].address=10240;
free_table[0].length=102400;
free_table[0].flag=1;
for（i=1;ifree_table[i].flag=0;
/*已分配表初始化：
*/
for（i=0;iused_table[i].flag=0;
while
（1）
{
printf（"选择功能项（0-退出,1-分配主存,2-回收主存,3-显示主存）\n"）;
printf（"选择功项（0~3）:
"）;
scanf（"%d",&a）;
switch（a）
{
case0:
exit（0）;/*a=0程序结束*/
case1:
/*a=1分配主存空间*/
printf（"输入作业名J和作业所需长度x:
"）;
scanf（"%*c%c%f",&J,&x）;
allocate（J,x）;/*分配主存空间*/
break;
case2:
/*a=2回收主存空间*/
printf（"输入要回收分区的作业名"）;
scanf（"%*c%c",&J）;
reclaim（J）;/*回收主存空间*/
break;
case3:
/*a=3显示主存情况*/
/*输出空闲区表和已分配表的内容*/
printf（"输出空闲区表：
\n起始地址分区长度标志\n"）;
for（i=0;iprintf（"%6.0f%9.0f%6d\n",free_table[i].address,free_table[i].length,free_table[i].flag）;
printf（"按任意键,输出已分配区表\n"）;
getch（）;
printf（"输出已分配区表：
\n起始地址分区长度标志\n"）;
for（i=0;iif（used_table[i].flag!
=0）
printf（"%6.0f%9.0f%6c\n",used_table[i].address,used_table[i].length,used_table[i].flag）;
else
printf（"%6.0f%9.0f%6d\n",used_table[i].address,used_table[i].length,used_table[i].flag）;
break;
default:
printf（"没有该选项\n"）;
}/*case*/
}/*while*/
}/*主函数结束*/
实习三磁盘存储空间的分配和回收
一、实习内容
模拟磁盘空闲空间的表示方法，以及模拟实现磁盘空间的分配和回收。
二、实习目的
磁盘初始化时把磁盘存储空间分成许多块（扇区），这些空间可以被多个用户共享。
用户作业在执行期间常常要在磁盘上建立文件或把已经建立在磁盘上的文件删去，这就涉及到磁盘存储空间的分配和回收。
一个文件存放到磁盘上，可以组织成顺序文件（连续文件）、链接文件（串联文件）、索引文件等，因此，磁盘存储空间的分配有两种方式，一种是分配连续的存储空间，另一种是可以分配不连续的存储空间。
怎样有效地管理磁盘存储空间是操作系统应解决的一个重要问题，通过本实习使学生掌握磁盘存储空间的分配和回收算法。
三、实习题目
第二题：
用位示图管理磁盘存储空间
[提示]：
（1）为了提高磁盘存储空间的利用率，可在磁盘上组织成链接文件、索引文件，这类文件可以把逻辑记录存放在不连续的存储空间。
为了表示哪些磁盘空间已被占用，哪些磁盘空间是空闲的，可用位示图来指出。
位示图由若干字节构成，每一位与磁盘上的一块对应，“1”状态表示相应块已占用，“0”状态表示该块为空闲。
位示图的形式与实习二中的位示图一样，但要注意，对于主存储空间和磁盘存储空间应该用不同的位示图来管理，绝不可混用。
（2）申请一块磁盘空间时，由分配程序查位示图，找出一个为“0”的位，计算出这一位对应块的磁盘物理地址，且把该位置成占用状态“1”。
假设现在有一个盘组共8个柱面，每个柱面有两个磁道（盘面），每个磁道分成4个物理记录。
那么，当在位示图中找到某一字节的某一位为“0”时，这个空闲块对应的磁盘物理地址为：
柱面号=字节号
磁道号=[]
物理记录号={}
（3）归还一块磁盘空间时，由回收程序根据归还的磁盘物理地址计算出归还块在位示图中的对应位，把该位置成“0”。
按照
（2）中假设的盘组，归还块在位示图中的位置计算如下：
字节号=柱面号
位数=磁道号4+物理记录号
（4）设计申请一块磁盘空间和归还一块磁盘空间的程序。
要求能显示或打印程序运行前和运行后的位示图；分配时把分配到的磁盘空间的物理地址显示或打印出来，归还时把归还块对应于位示图的字节号和位数显示或打印出来。
（5）假定已有如表4-1的磁盘空间被占用了，现在要申请五块磁盘空间，运行分配程序，按（4）中要求显示或打印运行的结果。
然后再归还如表4-2的空间，运行回收程序，按（4）中的要求显示或打印运行结果。
表4-1
柱面号
磁道号
物理记录号
0
0
1
0
0
2
0
1
0
0
1
3
1
0
0
1
1
2
表4-2
柱面号
磁道号
物理记录号
0
0
2
0
1
0
1
0
1
四、数据结构及符号说明
1．数据结构说明：
/*物理地址*/
typedefstructaddress
{
intcylinder;/*柱面号*/
inttrack;/*磁道号*/
intblock;/*块号*/
}address;
块的物理地址。
可直接通过这来寻址。
便于和位示图坐标进行转换。
/*文件*/
typedefstructfile
{
intlength;/*文件长度*/
block*head;/*文件的第一个块*/
}file;
文件长度用来定量表明文件所需的空间大小，即物理块数。
2．函数说明
/*初始化磁盘空间，用位示图表示*/
voidinitialize（）
功能：
按照题目要求，初始化磁盘空间，使用位示图来表示相应块的分配情况。
参数：
无。
使用全局变量bitmap[][]。
调用：
被主函数main（）调用来初始化程序。
升级会员 