西北工业大学操作系统实验OS37.docx
《西北工业大学操作系统实验OS37.docx》由会员分享，可在线阅读，更多相关《西北工业大学操作系统实验OS37.docx（15页珍藏版）》请在冰豆网上搜索。
西北工业大学操作系统实验OS37
评语:
课中检查完成的题号及题数：
课后完成的题号与题数：
成绩:
指导教师:
实验报告三
实验名称：
理解线程的相关概念
请求分页存储管理设计
日期：
2013.5.23
一、实验目的：
1.理解线程的相关概念
理解当操作系统引入线程的概念后，进程是操作系统独立分配资源的单位，线程成为系统调度的单位，与同一个进程中的其他线程共享程序空间。
2.请求分页存储管理设计
模拟存储管理常用的请求分页存储管理技术，通过本实验使学生更加深入的理解虚拟内存的思想和主要的页面淘汰算法。
二、实验内容：
1.理解线程的相关概念
线程创建和构造的相关知识，了解C语言程序编写的相关知识。
2.请求分页存储管理设计
学习虚拟存储器的相关基础知识，了解请求分页存储管理系统的原理和具体实现过程，熟悉各种主要的页面调度算法。
三、项目要求及分析：
1.理解线程的相关概念
（1）编写一个程序，在其main（）函数中创建一个（或多个）线程，观察该线
程是如何与主线程并发运行的。
输出每次操作后的结果；
（2）在main（）函数外定义一个变量shared（全局变量），在main（）中创建一个线
程，在main（）中和新线程shared进行循环加/减操作，观察该变量的变化；
（3）修改程序把shared变量定义到main（）函数之内，重复第
（2）步操作，
观察该变量的变化。
2.请求分页存储管理设计
（1）通过随机数产生一个指令行列，共320条指令，指令中的地址按下述原则生
成：
50%的指令是顺序执行；25%的指令均匀分布在前地址部分；25%的指令
均匀分布在后地址部分。
（2）具体实验办法是：
在[0，319]之间选一起始点M；顺序执行一条指令，即第
M+1条；向前地址[0，M-1]中执行一条指令M；顺序执行一条指令，即第M+1
条；向后地址[M+2，319]中执行一条指令M。
如此继续，直至产生320条指令。
使用产生随机数的函数之前，首先要初始化设置RAN（）产生序列的开始点，
SRAND（400）；然后计算随机数，产生指令序列。
例如：
a[0]=1.0*rand（）/32767*319+1；
a[1]=a[0]+1；
a[2]=1.0*rand（）/32767*（a[1]-1）+1；
a[3]=a[2]+1；
a[4]=319-1.0*rand（）/32767*（a[3]-1）；其中rand（）和srand（）为Linux操作系统提供的
函数分别进行初始化和产生随机数，多次重复使用这5条指令，产生以后的指
令序列。
（3）将指令序列变换成页面地址流：
假设，页面大小为1KB；用户实存容量（内存
区容量）为4页或32页；用户虚存容量（逻辑地址空间容量）为32KB；用户虚
存容量32KB，每1KB中放10条指令，共320条指令序列，按其地址0~9在0页，
10~19在1页，…….，310~319在31页。
（4）使用不同的页面调度算法处理缺页中断，并计算不同实存容量下的命中率：
先
进先出（FIFO）算法；最近最少使用（LRU）算法；命中率的算法为：
命中率
=1-（缺页中断次数/页地址流长度）。
本实验中，页地址流长度为320，缺页
中断次数为每次访问相应指令时，该指令所对应的页不在内存的次数。
四、具体实现：
4.1流程图
1.理解线程的相关概念
2.请求分页存储管理设计
4.2添加函数的代码
1.理解线程的相关概念【代码使用C++编写】
#include
#include
#include
usingnamespacestd;
classthread_data_base{
public:
thread_data_base（）{}
~thread_data_base（）{}
virtualvoidrun（）=0;
};
template
classthread_data:
publicthread_data_base{
public:
thread_data（F_f）:
f（_f）{
}
voidrun（）{
f（）;
}
private:
Ff;
};
classthread{
public:
staticvoid*__thread_call（void*arg）{
thread_data_base*base=reinterpret_cast（arg）;
base->run（）;
returnNULL;
}
staticvoid*__thread_call_self（void*arg）{
（（thread*）arg）->run（）;
returnNULL;
}
explicitthread（）:
tid（-1）
{
ret=pthread_create（&tid,NULL,&thread:
:
__thread_call_self,this）;
}
template
explicitthread（Ff）
:
tid（-1）,
_data（newthread_data（f））
{
ret=pthread_create（&tid,NULL,&thread:
:
__thread_call,_data）;
}
virtual~thread（）
{
//pthread_exit（&ret）;
}
virtualvoidrun（）{
_data->run（）;
}
voidjoin（）{
pthread_join（tid,&status）;
}
intgettid（）{
returntid;
}
intgetReturnValue（）{
returnret;
}
private:
pthread_ttid;
intret;
void*status;
thread_data_base*_data;
};
intglobal_count=0;
structtestFunctor{
voidoperator（）（void）{
while
（1）
cout<}
};
structtestFunctor2{
voidoperator（）（void）{
while
（1）
cout<}
};
intmain（）
{
testFunctortest;
testFunctor2test2;
threadthr（test）;
threadthr2（test2）;
thr.join（）;
thr2.join（）;
return0;
}
2.请求分页存储管理设计
#include
#include
#include
#defineFALSE0
#defineINVALID-1
#defineNUL0
#definetotal_ins320
#definetotal_vp32
#defineclc_period50
typedefstruct{
intpn,pfn,counter,time;
}pl_type;
pl_typepl[total_vp];
typedefstructpfc_struct{
intpn,pfn;
structpfc_struct*next;
}pfc_type;
pfc_typepfc[total_vp],*freepf_head,*busypf_head,*busypf_tail;
intdiseffect,a[total_ins];
intpage[total_ins],offset[total_ins];
voidinit（int）;
voidFIFO（int）;
voidLRU（int）;
intmain（）
{
intS;
srand（（int）getpid（））;
S=（int）rand（）%390;
for（inti=0;ia[i]=S;
a[i+1]=a[i]+1;
a[i+2]=（int）rand（）%390;
a[i+3]=a[i+2]+1;
S=（int）rand（）%390;
}
for（inti=0;ipage[i]=a[i]/10;
offset[i]=a[i]%10;
}
for（inti=4;i<=32;i++）{
printf（"%2dpageframes",i）;
FIFO（i）;
puts（""）;
LRU（i）;
printf（"\n"）;
}
return0;
}
voidFIFO（inttotal_pf）{
inti;
pfc_type*p;
init（total_pf）;
busypf_head=busypf_tail=NUL;
for（i=0;iif（pl[page[i]].pfn==INVALID）{
diseffect++;
if（freepf_head==NUL）{
p=busypf_head->next;
pl[busypf_head->pn].pfn=INVALID;
freepf_head=busypf_head;
freepf_head->next=NUL;
busypf_head=p;
}
p=freepf_head->next;
freepf_head->next=NUL;
freepf_head->pn=page[i];
pl[page[i]].pfn=freepf_head->pfn;
if（busypf_tail==NUL）busypf_head=busypf_tail=freepf_head;
else{busypf_tail->next=freepf_head;busypf_tail=freepf_head;}
freepf_head=p;
}
}
printf（"FIFO:
%.6f",1-（float）diseffect/320）;
}
voidLRU（inttotal_pf）{
intmin,minj,i,j,present_time;
init（total_pf）;
present_time=0;
for（i=0;iif（pl[page[i]].pfn==INVALID）{
diseffect++;
if（freepf_head==NUL）{
min=32767;
for（j=0;jif（min>pl[j].time&&pl[j].pfn!
=INVALID）{
min=pl[j].time;
minj=j;
}
freepf_head=&pfc[pl[minj].pfn];
pl[minj].pfn=INVALID;
pl[minj].time=-1;
freepf_head->next=NUL;
}
pl[page[i]].pfn=freepf_head->pfn;
pl[page[i]].time=present_time;
freepf_head=freepf_head->next;
}
else
pl[page[i]].time=present_time;
present_time++;
}
printf（"LRU:
%6.4f",1-（float）diseffect/320）;
}
voidinit（inttotal_pf）{
inti;
diseffect=0;
for（i=0;ipl[i].pn=i;
pl[i].pfn=INVALID;
pl[i].counter=0;
pl[i].time=-1;
}
for（i=1;ipfc[i-1].next=&pfc[i];
pfc[i-1].pfn=i-1;
}
pfc[total_pf-1].next=NUL;
pfc[total_pf-1].pfn=total_pf-1;
freepf_head=&pfc[0];
}
五、调试运行结果：
（1）
（2）
六、所遇问题及解决方法：
开始时不知道该如何构造线程，在查看了老师分享的资料之后，开始稍微有些明白了，在后面慢慢的实践过程中，逐步对线程的创建和使用等有了更加深入的了解。
在分页存储管理中，不明白指令应如何生成，后来经过与同学的讨论，终于明白了大意，再就是FIFO和LRU分页算法，虽然上课时感觉听的还算可以，可是在实际动手编程时还是有些迷茫，主要还是动手比较少，以后应加强这方面的锻炼。
七、实验总结：
1.在理解线程的相关概念的实验中，应注意shared的全局性和局部性，而且在作为局部变量时，应注意print_thread_id（）函数和pthread_create（）函数的使用，因为后者的第四个参数是指针型变量，故在传递shared的值时应注意指针的使用。
2.在请求分页存储管理设计实验中，首先应先生成一定数目的指令，然后再构建相应的FIFO和LRU算法，然后分别使用不同的分页算法，比较不同算法的命中率。
升级会员 