操作系统linux版实验报告.doc

操作系统实验报告（Ｌiｎux版）
网络142 潘豹　 1４２999
实验一 观察Liｎuｘ进程状态
一、 实验目得
在本实验中学习Liｎｕx操作系统得进程状态，并通过编写一些简单代码来观察各种情况下，Lｉｎux进程得状态,进一步理解进程得状态及其转换机制。
二、实验环境
硬件环境：计算机一台,局域网环境;
软件环境:Linｕx　Ｕbuntu操作系统，ｇcc编译器。
（四）查瞧“不可中断阻塞”状态(D)
创建一个C程序,如ｕnｉnｔeｒ＿ｓｔａtus、c，让其睡眠30ｓ
代码：
#ｉncludeｎ（）
｛
iｎt ｉ=0,j=0,k=0;
for(i=0;i<１00０000；i＋+）
{
　ｆor（j＝０；j＜１0００000;j++）
　 ｛
　k++；
　ｋ--;
　　}
}
｝
实验结果:

（二)查瞧“暂停”状态（Ｔ)
运行run_ｓtａtuｓ进程,其进入R状态：
代码同上：
（三）查瞧“可中断阻塞”状态(Ｓ)
创建一个C程序,如intｅrrｕptibｌie＿status、c,让其睡眠3０s
编译链接,后台运行该程序（后接&符号），并使用ps命令查瞧运行状态
代码:
#iｎcludｅ〈unistｄ、h＞
＃ｉnclude＜stdio、ｈ＞
int maiｎ（）
{
sleep（３0）；
rｅturn；
｝
实验结果:

（四)查瞧“不可中断阻塞”状态（D)
创建一个C程序，如uｎinter_staｔｕs、c，让其睡眠３0s
编译链接，后台运行该程序(后接＆）,并使用pｓ命令查瞧运行状态
代码：
#ｉnｃｌude〈unistd、h>
＃iｎｃlude〈stdｉo、h＞
inｔ ｍain（)
｛
ｉf(vfork（)==0）
{
　 sleep(3０0）;
　reｔｕrｎ；
}
｝
实验结果:

（五）查瞧“僵尸”进程(Z)
创建一个C程序,如ｚomｂiｅ_statuｓ、c,在其中创建一个子进程,并让子进程迅速结束,而父进程陷入阻塞
编译链接,后台运行该程序（后接&)，并使用ps命令查瞧运行状态（30s内）
代码：
＃iｎcｌｕde
＃incｌdue
ｉnt maｉn()
｛
iｆ（fork(）)
{
　 sleep（300);
｝
｝
实验结果：

实验二 观察Lｉｎux进程/线程得异步并发执行
一、实验目得
通过本实验学习如何创建Linux进程及线程，通过实验，观察Ｌinux进程及线程得异步执行。理解进程及线程得区别及特性，进一步理解进程就是资源分配单位，线程就是独立调度单位。
二、实验环境
硬件环境:计算机一台,局域网环境;
软件环境：Linux　Ubuｎｔｕ操作系统,ｇcc编译器.
三、实验内容与步骤
１、进程异步并发执行
编写一个C语言程序,该程序首先初始化一个ｃｏｕnt变量为1,然后使用fork函数创建两个子进程，每个子进程对ｃｏｕnt加1后,显示“I ａm son，　coｕnｔ=x”或“I am　dauｇhter， count=ｘ”，父进程对count加1之后,显示“I　am ｆathｅｒ, cｏｕnｔ=ｘ”,其中ｘ使用cｏunt值代替。最后父进程使用waitｐｉd等待两个子进程结束之后退出。
编译连接后，多次运行该程序，观察屏幕上显示结果得顺序性，直到出现不一样得情况为止，并观察每行打印结果中couｎt得值。
代码：
＃inｃlude＜ｕｎistd、h>
#incｌｕdｅ＜stdio、h〉
ｉnt main（）
{
　pｉd_ｔ son_pid，ｄaugｈtｅr_pｉd；
int couｎt＝1;
soｎ_pｉd＝fork（）；
　 ｉf（ｓon＿pｉｄ==0）
　 {
　　count++;
pｒintｆ(”i aｍ soｎ,ｃoｕnt=％d\n"，ｃounｔ）；
}
ｅlse
　 {
　ｄaugｈter＿piｄ＝fork(）；
if（dauｇhtｅｒ＿pid＝=0）
　 ｛
　 count++;
　 　 printf(”i ａm dauｇhter,cｏｕｎt=％ｄ\ｎ＂，cｏｕnt）;
｝
　 else
　{
　 count+＋；
　 printf("i aｍ　father，count＝％ｄ\n”，coｕnt);
　 waｉtpid（sｏn_pid,ＮULL，0）；
　waiｔpid(ｄaughter＿pid,ＮUＬL，０)；
　 }
　｝
｝

2、线程异步并发执行
编写一个Ｃ语言程序，该程序首先初始化一个count变量为1，然后使用pｔhｒeａd_cｒeatｅ函数创建两个线程，每个线程对couｎｔ加1后，显示“I　aｍ　son, cｏuｎｔ＝x”或“Ｉ am　daｕghｔｅr, coｕｎt＝x"，父进程对cｏｕnt加1之后，显示“I am father， count=x”,其中ｘ使用counｔ值代替。最后父进程使用pthreａd_jｏｉn等待两个线程结束之后退出。
编译连接后,多次运行该程序,观察屏幕上显示结果得顺序性，直到出现不一样得情况为止,并观察每行打印结果中cｏunｔ得值。
代码：
＃incluｄeｉｎcｌｕde
vｏid ＊daｕghｔｅｒ(vｏid *nｕm)
｛
iｎt＊ a=（int ＊）num;
*a+=1;
prｉnｔｆ(”i am daughｔer，ｃｏunt＝％d\ｎ",*a）;
}
void ＊ｓoｎ（ｖoid　*nuｍ)
｛
ｉnt* a=（ｉnt ＊）num；
*a+=1;
ｐriｎtf（"i ａm son，coｕｎｔ＝%d\ｎ＂,*a）;
}
int main(）
｛
pthread_ｔ sｏn_tid，daｕｇhｔer＿tｉd;
int cｏunｔ=1；
pthrｅad_cｒeａtｅ(＆son_tｉd,NULＬ,sｏn,&counｔ）；
pｔｈrｅad_ｃｒeate(＆ｄａｕghtｅr＿tｉｄ，NULL,daｕgｈter,&ｃｏｕｎt）；
counｔ＋+；
pｒintf（"i　ａm　parent，coｕｎt：=%d\n”，coｕnｔ);
ｐｔｈｒead_joiｎ(ｓon＿tid,NUＬL)；
ｐthread_join（dauｇhter_tid，ＮUＬL）;
retｕｒｎ ０；
}
实验结果：

实验三 使用信号量进行互斥与同步
一、 实验目得
本实验介绍在Linuｘ中使用信号量进行进程同步、互斥得方法。读者可以通过实验进一步理解进程间同步与互斥、临界区与临界资源得概念与含义,并学会Liｎux信号量得基本使用方法。
二、实验环境
硬件环境：计算机一台,局域网环境;
软件环境：Linux Uｂunｔu操作系统，gcc编译器.
三、实验内容与步骤
三、实验内容与步骤
（一)参考:PＯSIX以及Ｓｙsｔｅm V
Syｓteｍ　V:Uｎｉｘ众多版本中得一支，最初由AT＆T定义，目前为第四个版本,其中定义了较为复杂得API。
POSＩX：Ｐｏrtaｂle Opｅrating Sｙsteｍ Interfacｅ，IEEE为了统一Unｉx接口而定义得标准，定义了统一得APＩ接口。Linux即支持System ＡPI,又支持PＯSIX ＡPI
(二)实验步骤

stｅｐ1：通过实例查瞧不使用互斥时得情况 (假设文件命名为ｎｏ_sem、c）
编译链接，同时运行两个进程，显示结果
代码：
#iｎcｌudｅｓｓａｇe)；
fflush（stｄｏuｔ）；
slｅｅp(ｒａnｄ（）％2）;
｝
sｌｅep（１0）;
exit；
｝
实验结果:

stｅp2:使用信号量来对临界资源进行互斥 （假设文件命名为witｈ＿sem、c）
编译链接,同时运行两个进程。
观察X与O得出现规律,并分析原因。
代码：
#inｃlude＜stdiｏ、h〉
＃incluｄe＜sｔdlib、ｈ＞
＃inｃlｕdetａt、h＞
iｎt main(int argｃ,chａｒ　*ａrgｖ[]）
｛
cｈar　ｍessａge=’x＇;
ｉnt i=0；
iｆ(ａrgｃ>1）
｛
mｅsｓage=argv［1］[0］；
｝
sem_ｔ　*mutex=sem_open（＂myｓeｍ”，O_CREAＴ,06６６，1）;
fｏr(i=0；ｉ〈1０；i++)
｛
sem_wait（ｍuteｘ）;
ｐrｉｎtf（＂％c”，message）；
ｆflush（stdｏut）;
sleep(rand(）％３）；
ｐrintｆ("％c",mｅsｓage）;
fflｕsｈ(stdouｔ）；
sem_post（ｍｕteｘ);
ｓlｅeｐ（ｒanｄ（）％２)；
｝
ｓleｅｐ（10);
sｅm＿clｏｓe(ｍutex);
sem＿ｕnlｉnｋ(”ｍｙsｅｍ”);
exiｔ（0）;
}
实验结果:

ｓtep3：使用信号量来模拟下象棋红黑轮流走子得情况
编写两个C语言程序black＿ｃhess、ｃ以及red_chess、c,分别模拟下象棋过程中红方走子与黑方走子过程。走子规则:红先黑后，红、黑双方轮流走子，到第1０步,红方胜，黑方输。
代码：
红色棋
＃iｎcluｄe〈stｄｉｏ、ｈ〉
＃include＜stdｌib、h>
#incluｄes、h〉
＃include〈ｓys/ｉpc、h>
＃ｉnclude
#iｎclｕdentf("Red　cｈｅss hａd moveｄ,blacｋ，chess go！\n")；
｝
elsｅ{
ｐrintf（"Ｒed cｈess win!\n＂）;
｝
ｆflｕsh（sｔｄouｔ)；
sem_post（honｇ)；
}
sｌeep（10);
seｍ_ｃlose（hei）;
sem_close(hong)；
seｍ＿uｎliｎk（”cｈess_red＿sem");
ｓｅm_ｕnlｉnk("cheｓs_black＿ｓem”);
exｉt(0）；
｝
黑色棋 ：
#ｉncludedｅ＜sys／tｙｐeｓ、h＞
＃inｃlude〈syｓ/ｉpc、h〉
＃includｅ〈semaphore、h＞
＃include＜fｃntl、h>
＃iｎclude＜sｙs/ｓtat、ｈ>
int main（int arｇｃ,char *argv[]）
｛
ｉｎt i=0；
sem＿t *hei＝sem_open(＂chess＿bｌack_ｓem”,O＿CREAT，06６６,1）;
sem_t *hong＝sｅm_open(”cｈeｓs_red＿ｓeｍ",O_CREAT,06６6,０）;
for(ｉ=0；ｉ〈10;ｉ＋＋）
｛
sem_wait(hoｎg）;
iｆi!=９){
priｎtf（＂Ｂｌack chess haｄ movｅd,red chess go!\ｎ”）;
｝
else｛
ｐrintｆ("Blaｃk cheｓｓ　win！\ｎ＂）；
}
fflｕｓh（stdｏut);
ｓｅm_ｐoｓt（ｈei)；
}
sleeｐ(10）；
sｅm_clｏｓｅ（hｅi)；
sem_clｏse(hong）;
seｍ＿unliｎk（”chess_ｒed＿seｍ");
sem_unｌｉnｋ（”cheｓs_ｂlack_sｅm”)；
exit（0)；
｝
实验结果：

实验四　 作业调度算法模拟
一、 实验目得
（1）掌握周转时间、等待时间、平均周转时间等概念及其计算方法。
（2）理解五种常用得进程调度算法(FＣFS、SJF、HRＲF、ＨPF、ＲR）,区分算法之间得差异性，并用C语言模拟实现各算法。
(3）了解操作系统中高级调度、中级调度与低级调度得区别与联系.
二、实验环境
硬件环境：计算机一台,局域网环境；
软件环境：Linux Uｂｕntｕ操作系统,gcc编译器。
三、实验内容与步骤
本实验所选用得调度算法均默认为非抢占式.
实验所用得测试数据如下表所示。
本实验所用得测试数据如下表所示
表 实验测试数据
作业Id
到达时间
执行时间
优先权
１
8００
50
0
2

815
30
1
3
830
25
2
４
８３５
20
２
5
845
15
２
６
７０0
10
1
7
820
5
０
作业得数据结构：
typｅdeｆ struct noｄｅ
{
ﻩint　number； // 作业号
int rｅａｃh＿time；// 作业抵达时间
int ｎeｅd＿tｉme;// 作业得执行时间
int pｒiviｌege；//　作业优先权
ﻩfloat excｅlｌent;// 响应比
int sｔａrt_timｅ；// 作业开始时间
ｉnt　wａit_tｉｍe;// 等待时间
iｎt visｉｔed；/／ 作业就是否被访问过
bool isreached;／/ 作业就是否已经抵达
｝joｂ；
代码:
#incｌｕｄe 〈stdｉo、h>
＃ｉｎｃludｅ ＜strinｇ、h＞
#ｉncluｄe
#iｎcｌudｅ〈stdｂｏol、h〉
//最大作业数量
coｎｓt int ＭAXＪOB=５0；
//作业得数据结构
typedef sｔｒuct node
｛
inｔ nuｍber；/／作业号 　　
ｉｎt　reach＿tｉmｅ;/／作业抵达时间
iｎt need＿tｉmｅ；//作业得执行时间
ｉnt　pｒivilege;／／作业优先权
float excｅllｅnt;/／响应比
ｉnｔ ｓtarｔ_time；//作业开始时间
iｎt　wａit_time；／/等待时间
ｉｎｔ　visｉted；//作业就是否被访问过
bool ｉsrｅached；／/作业就是否抵达
}joｂ；
ｊob jobs［50]；／／作业序列
iｎｔ ｑuantiｔｙ；//作业数量
//初始化作业序列
voiｄ　iｎｉｔial＿jobs(）
｛
int i；
ｆｏr（ｉ＝0;i〈MAXJOB;ｉ＋+)
{
jｏbｓ［i］、ｎｕmber＝0；
jｏbｓ[i］、rｅach＿timｅ=0；
jobs［i]、ｐｒivｉlegｅ=０;
jobs[i]、ｅxcｅllｅnt=0；
jobs［i]、stａrt_time=０;
ｊobs［ｉ]、waｉt_time=0；
ｊoｂs［i]、ｖisited=０；
ｊobs[i]、isｒeａcheｄ=ｆａlse;
｝
ｑuantity＝0；
}
//重置全部作业信息
vｏｉd　reset_ｊinｆo（）
｛
iｎｔ　i；　
fｏr(ｉ=0；i〈MAXJＯB;i＋＋）
{
jobs［i］、start＿ｔiｍe＝0；
joｂｓ[i]、wａit_tiｍe=0；　
ｊobs[i］、ｖisｉｔed=０；
｝
}
//查找当前cuｒrent_timｅ已到达未执行得最短作业，若无返回－1
int fiｎｄmiｎjob（job jobｓ［],ｉnt ｃｏuｎｔ)
｛
int minｊob=－1；//＝jｏbs[0］、neｅd_time；
iｎt ｍinloｃ=-１；
int ｉ；
for（i=0；i＜ｃｏunｔ；i++）
｛
if（minloc==-1){
if（ ｊobs［i］、ｉsreached=＝true &＆ joｂs［i］、ｖｉsiｔed＝=0)｛
ｍinjob＝jｏbｓ[i］、ｎeeｄ_time；
ｍiｎloc=i；
}
｝
ｅlsｅ iｆ（mｉnjｏb〉ｊobs［i]、neｅｄ_time&&ｊoｂｓ［i］、ｖisiteｄ=＝0＆&jobs［ｉ]、ｉsrｅaｃhｅｄ=＝trｕe)
{
minjob=jobｓ[i]、neeｄ_ｔime；
mｉnloc=i;
｝
}
ｒetｕｒn ｍｉnloc；
｝
／／查找最早到达作业，若全部到达返回-1、
int ｆiｎdreａrlyjoｂ（job jobs［],int　coｕnｔ）
{
int reaｒlyｌoc=—１；
ｉｎt　reaｒｌyjob=－１；
int i;
for（i=０;i〈ｃｏｕnｔ；ｉ＋＋）
｛
iｆ（rｅａrlyｌoc==—1）{
if（jｏbs［i］、viｓiteｄ==0）{
reａｒlyｌｏc=i;
rｅarlｙjoｂ=jobｓ[i]、reａch＿time;
｝
｝
eｌse　if（rearlyjob〉jｏbｓ［i］、ｒeach_timｅ＆＆ｊｏbs［ｉ]、ｖｉsitｅd==0）
｛
rｅarｌyjoｂ=jｏbs［i]、rｅacｈ_time；
rearｌylｏc=ｉ；
}
｝
return ｒeａrlｙloc;
}
/／读取作业数据
vｏid reａｄＪobｄａta（）
｛
FＩLE ＊fｐ；
char fnaｍe［20］;
ｉｎt i；
　　 ／/输入测试文件文件名
prinｔf(”please inpｕt job data \ｎ”）;
scaｎf（"％s",fｎａme）；
if((ｆp=fopen(fname，＂ｒ＂）)==NＵLL)
｛
printf（”ｅrror， ｏｐeｎ　，　ｐｌeａse check :\n＂)；
｝
elｓｅ
{
//依次读取作业信息
ｗｈile（！fｅof（fp)）
{
if(fsｃanf(ｆｐ，"％ｄ　％d　%ｄ ％d”，＆ｊobs［quantity］、numｂer,＆jobs［ｑｕａntity]、reach_tｉmｅ，&jobs[quａnｔity]、ｎｅｅｄ＿ｔime,＆joｂs［qｕaｎtｉty］、ｐrivilege）＝=４)
quantity＋+;
}
//打印作业信息
ｐrｉntf（＂outｐｕt the　orｉｇｉｎ job data＼n”）；
priｎｔf（”－—－———-—-—－--－－--—-－－-—－－—－-——－－---－——-－—-——-—---—-—－－-——--—-－-—－-－——\n”)；
pｒｉnｔf("\tjｏbID\treacｈtiｍe\tｎeedtime＼ｔpriｖilege\n”)；
for(i=0；i〈ｑｕａnｔｉｔy；ｉ++）
{
printf(”\t%—８d\t％-8ｄ\ｔ%－8ｄ＼ｔ％－８ｄ＼n",jｏbｓ[ｉ］、numｂｅr，jobｓ［i］、reach＿time，jobs[i]、nｅed_tiｍe,ｊobs［i]、priviｌｅgｅ)；
｝
｝
}
//FＣFＳ
void　FCＦＳ()
｛
ｉnt　ｉ;
int cuｒrenｔ_time=0；
iｎt loｃ;
iｎｔ toｔal＿waitiｍe=０;
inｔ　toｔａl_rｏｕndtime=0；
//获取最近到达得作业
loｃ=ｆｉndrｅaｒlyｊoｂ（ｊobｓ,quａnｔiｔｙ）；
／/输出作业流
pｒiｎtf(”\n\nFCＦS算法作业流\n”)；
prｉnｔf（"--－—－－-－-—－——-－－—－——-—－－—-－----———-－-----——-－—-———-－－-—－--—－—---—-—－－-－-\n”)；
prｉntf("\tjｏbIＤ\treachｔｉme\tsｔarttiｍｅ\twaittime\troundtiｍe\n”);
current＿timｅ=jobｓ［lｏｃ］、ｒｅacｈ_ｔiｍe;　
//每次循环找出最先到达得作业并打印相关信息
ｆｏr(i=０;i＜quaｎtitｙ；ｉ++)
{
if（joｂs［loc］、ｒeach_time＞currｅｎt_tｉｍe）
｛
joｂｓ［loｃ］、staｒt＿tｉmｅ=ｊoｂｓ［loc］、reａｃh_ｔimｅ；
curreｎt＿tｉme=jobs［ｌｏｃ]、reａch_tiｍe；
｝
ｅlse
｛
jobs［lｏc]、starｔ_ｔime=current＿tｉmｅ；
}
ｊobｓ［loc]、wait＿tiｍe=cｕrrｅnt_time-ｊobs［loc］、ｒeach_ｔimｅ；
priｎtｆ(＂＼t%-8d\t%-8d＼t%—8ｄ\t%-8d\t％－8d\n＂,lｏc+1，jobs［lｏｃ］、rｅach_tｉｍe，ｊobs[ｌoc]、stａrt_time，joｂs［loc]、waｉｔ_ｔiｍe,
ｊoｂs[ｌｏｃ]、wａit＿time+jobs[ｌｏc］、neeｄ_tｉｍｅ）；
jobs[lｏc]、viｓｉtｅd＝1;
cｕｒrent＿tｉｍe+=jobs［loｃ]、need＿ｔime;
total_waitime+=jｏｂs［loｃ］、wａit＿ｔime；
tｏtaｌ_rｏｕｎdtｉｍe＝tｏtaｌ_rｏｕndtime+joｂs[lｏc]、wａｉt_tiｍe+jobs[lｏc］、nｅｅd_tiｍe;
//获取剩余作业中最近到达作业
loc=ｆindreａｒlｙjｏｂ（jobｓ,quaｎtity);
｝
printf（”总等待时间：％—8d　总周转时间：％-８d＼n"，ｔoｔal_ｗaitｉme,total_roｕnｄtime）；　
ｐrintf(“平均等待时间： %4、2f 平均周转时间: %４、2f\n”floａt)totａl_waitime／（ｑuaｎtiｔy)，（floａt）total＿ｒounｄtime／（ｑuantity））；
}
//短作业优先作业调度
vｏid SFJｓｃhｄulejoｂ(ｊｏb joｂs［］,inｔ cｏunt）
{
｝
ｉnt maｉｎ（)
｛
initial_jobs(）；　
ｒeadJobdata（）;
FCFS（）;
ｒeset＿ｊiｎfo（)；
SＦJschdｕｌeｊoｂ(ｊobs，quaｎtiｔｙ）;
ｓysｔｅm("paｕse”）；
return 0；
｝
实验结果：

实验五 　Ｌinｕx内存分配

一、 实验目得
1、了解Linux内存得分配与虚拟内存管理得原理，学习如何使用ｍaｌlｏｃ动态申请内存，了解动态申请与静态申请得区别。
2、深入理解Linuｘ得内存布局：代码段、数据段、ＢSS段、堆栈段、堆
二、实验环境
硬件环境:计算机一台，局域网环境;
软件环境：Linｕx Ｕbuntu操作系统,ｇｃc编译器。
三、实验内容与步骤
第一部分:编程分析Liｎuｘ中内存动态申请与内存静态申请得区别ﻫ 要求:
1、编写一个Lｉnux C程序，在该程序中使用定义一个全局变量，以及使用mａlloc申请一段内存（可大于物理内存大小，理论上在３２位系统中可以申请小于３G空间，但由于ｍalｌoc要求申请连续得空间，所以能申请到得空间一般在2G以下）。
2、打印出全局变量得起始地址，以及mａｌｌoc分配得内存得地址；
3、观察运行结果，并分析说明结果得地址就是否就是物理地址.
代码：
＃iｎｃｌude〈stｄiｏ、h>
＃iｎcludeｂｕf)
｛
ｐｒｉnｔｆ（"ｔｈe addresｓ of pbuf ｉs　％x\n”,pｂuf）；
｝
if（pbuｆ）
｛
fｒee（pｂuf);
ｐbuf=ＮULL；
｝
retuｒｎ　0；
｝
实验结果:

第二部分：进一步了解Lｉnuｘ内存得分配与虚拟内存管理得原理、了解Ｌinux得内存布局:代码段、数据段、BSＳ段、堆栈段、堆.
要求：
1、编写一个Linux C程序,在该程序中定义初始化全局变量、未初始化全局变量、初始化静态变量、未初始化静态变量、局部变量、使用malloc分配得局部变量
2、打印出各种变量得得起始地址
代码：
#include　 ｉnｔ stack＿vａr１ ＝ １;
　 iｎt stack_var２ = １；
　pｒintf(”———－--－－－－——TEXT Segmeｎｔ－--——-－—-—-\n");　
　 　　 prｉntf(”Ａddreｓｓ of　mａin： ％p\n"， main）;
　 　 priｎtf（＂—－-—-－－———－－DATA Seｇment—--－-－－——-－\n”);
　　 　 　printｆ(”Ａｄｄrｅss ｏf dａta_vａr0： %p＼n”, ＆data_ｖａr0);
　 　 ｐrintf（”Adｄresｓ oｆ daｔa_var1: ％p＼n"， &dａｔa_var1）；　
　　 ｐrｉｎtf("Ａｄdress ｏf dａｔa＿ｖａr2: ％p＼ｎ"， ＆data_vａr2);　
　 ｐrintf（”——－--—-—--—-BSS Segment—--—－——————\n”)；
　　　　 　prｉntf（”Ａddress　of　bss_var0（BSS　Sｅｇmeｎt）： %p\n”， ＆bｓs＿ｖａr0）；
　 　 prｉnｔf（”Adｄrｅsｓ of bsｓ＿var1(BSS Ｓｅgment）： %p\n”， ＆ｂss_var1）；

prｉntｆ("Addrｅsｓ of bss_vａｒ2(BSS Segmｅｎt)：　％p＼n”, ＆bss_var２）；
　 　 priｎｔf（"－－——－——－———-STAＣK Segment—--－-—－—-—－\ｎ”）；
　 　 printf（”Adｄrｅss of　sｔａｃk_ｖａｒ0： ％ｐ\n", ＆stacｋ_var0）;
　 　pｒintｆ(＂Aｄdｒeｓs ｏf ｓtaｃk＿var１： ％p＼n”， &ｓtack_vaｒ1）；
　　 pｒintf（”Address　of　staｃk_var2： %p\n” ＆sｔack_vａｒ2)； /／使用mａlｌoc分配三个大小为102４B得内存
　 　cｈａｒ＊ heap_vａr０ =　（cｈar＊）ｍalｌoc（1024）；
　 　　 char＊ heａｐ_var1 ＝ （char＊）ｍalloｃ（10２４）;
　 　 char＊ heaｐ_var2 ＝ （chaｒ＊)mａｌlｏc（102４)； ／／使用mａllｏc分配三个大小为512MＢ得内存
　 　 　 ｃhａｒ＊　mｍaｐ＿var0 ＝　(ｃhar*)maｌloc（1024 ＊　10２4 ＊ ５12)；
char* mmap＿var1　= (chaｒ＊）ｍａｌｌｏc(1０２４　* 1０２4 ＊ ５1２)；　
　 　 char＊ mｍap_var2 =　(chaｒ*）maｌloc（１０2４ ＊ 102４ * 512)；
　 ｐｒintf（"-－－－—-—-－—-—ＨEAP Segment—-——-——－-－-＼n”)；
ｉf（heap＿vａr０){　
　 　　 　 　　ｐrintf（"Ａddrｅss of　heａp＿var0：％p\n”,　ｈeaｐ_vａr0）;
　　 　　 　 ｆrｅe（heap_var0)；
　 　　 　 　 ｈeaｐ_ｖar０ =　NULL；
　 　 　 　 }　
　 　　 if(hｅaｐ＿vaｒ1）{　
　 　priｎtf（"Ａddｒesｓ　of heａｐ_var1:%p＼n”, heap＿vａr1);
　ｆrｅe(heap＿vａr1）；
hｅap_ｖar１ = ＮUＬL；　
　　 　 　 　 　 　　　 }
　 　 iｆ(heap_var２){
　 　 　printf（”Aｄdｒｅss ｏf ｈeaｐ＿ｖar2：％ｐ＼n＂，　ｈeaｐ_ｖar2）;　
　 　 　 frｅｅ（heaｐ_ｖａr２);
　 　 　 heaｐ_var2 = NＵLL;
　 　 　 ｝
　 　 　 prｉntｆ(”—-－－—----———mｍap-－—-－—----—--－—－———\n"）;
　 　 iｆ（mmap_vaｒ0）{　
　　 　 pｒintｆ("Addresｓ ｏf mmap_var0：％p＼n”, mmａｐ_vaｒ0）；　
　 　　　　　　 　 free（mmaｐ＿ｖar0);
　 　 　 　ｍmaｐ_var0 = ＮUＬL;　
　　　　 　 　　　 }　
　 　 if（mmaｐ_vaｒ1）{
　 　 　 ｐｒｉntｆ（"Address　ｏf　mmａp_var1:%p\n"， ｍmaｐ_var1)；
　 　 　frｅe（mｍap＿var１）；
　 　 　 　 　 mｍaｐ_vaｒ1 = ＮULL；
　 　 　 　｝
　　 　 　 　 　 if(mmap＿vaｒ2）{
　　 　　 　　 ｐrintf（”Addresｓ of mmap＿vａr2：％ｐ\n＂，　mｍａｐ_var２）;
　 　 frｅe(ｍmaｐ_var2)；　
　 　 　 　 ｍmap_var２ = NULL；
　　 　 　 　 　 ｝
returｎ　0;
}
实验结果：

实验六 　页面置换模拟程序设计
一、 实验目得
1、通过软件模拟页面置换过程,加深对请求页式存储管理实现原理得理解
2、理解与掌握OPT、ＦIFＯ与LRＵ三种页面置换算法，深入分析三者之间得优缺点.
二、实验环境
硬件环境：计算机一台,局域网环境；
软件环境：Linｕｘ Ｕｂuｎｔu操作系统，ｇcc编译器。
三、实验内容与步骤
代码：
＃inclｕde＜ｓtdｉo、h＞
＃iｎｃluｄe〈stdlib、ｈ＞
＃ｉｎｃlｕde〈string、ｈ〉
#ｉncluｄｅ〈unｉｓtｄ、h〉
#defiｎe VM＿PＡGＥ　3２
#dｅfine PM_PAGＥ 4
＃ｄｅｆｉne ＴOＴAL_INSTR 320
＃defiｎｅ ＩNＳTR_PＥR_PAGE 1０
＃dｅfine　OPT　１
＃ｄｅfine ＦIFO 2
＃definｅ LRＵ 3
tyｐedｅf struｃｔ{
　　int vｍn;
　　 ｉnt pmn；
　 int exist；
　ｉｎt timｅ;
　 　｝vｐage＿iｔem；
vｐagｅ_item page_table［VＭ_PＡGＥ］；
　 　vpａｇe_item＊ ｐpaｇｅ_biｔmaｐ［PM＿PAＧE］；
typｅdeｆ　ｓtｒuct{
int nｕm;
　 int vpage;
　 iｎt　ｏffsｅt;
　 int infｌow；
　 　 ｝instr_itｅm；
　instｒ＿itｅm ｉnｓｔr＿arｒay[TOTＡL＿IＮSＴＲ］;
struｃｔ ｉnsｔｒ_flow｛
　 inｓtr_ｉｔem＊iｎstr；
sｔruct　inｓｔr_flow＊nexｔ;
　 ｝；
ｓｔｒｕct instｒ_ｆloｗ_heａd{
　 　 iｎｔ nｕm；
　 　ｓtrucｔ instr_fｌｏｗ＊nｅxt；
　 ｝;
struct ｉnｓtｒ_fｌow_ｈead ifｌow＿head；
　int pｆaiｌ＿nｕm=０;
　　ｉnt　ｃｕr＿repｌａce_alg＝1;
　 　 void ｉnit_ｄata(）；
　　 ｖoｉd