操作系统linux版实验报告材料

1、标准操作系统实验报告（LinUX版）网络142 潘豹142999文案实验一观察LinUX进程状态一、实验目的在本实验中学习LinUX操作系统的进程状态，并通过编写一些简单代码来观察各种情况 下，LinUX进程的状态，进一步理解进程的状态及其转换机制。二、实验环境硬件环境：计算机一台，局域网环境；软件环境：LinUX UbUntu 操作系统，gcc编译器。（四）查看不可中断阻塞”状态（D）创建一个 C程序，如Uninter_status.c,让其睡眠30s代码：#in ClUdev Uni std.h>#in cUde<stdio.h>int mai n()int i=0,j=

2、0,k=0;for(i=0;i<1000000;i+) for(j=0;j<1000000;j+)k+;k-;实验结果：0 StUdentt: 桌面StUdetlab-soft:IS“exanples i desktop 模扯 视類 图月 下H 音乐 桌面StUdentlab-soft:$ Cd 桌面StUdenttab-soft:桌面$ gcc 1 * 1 .c -o 1.1StudentfLab -SOft:-/桌面$ ,/1.1 & PS1 3821PIDTTYTlMECMD3757pts/109:00:00bash3821ptl1*13822pts/1pStuden

3、tlab-SOft:桌而$ |（二）查看“暂停”状态（T）运行rUn_StatUS进程，其进入 R状态: 代码同上：（三）查看 可中断阻塞”状态（S）创建一个 C程序，如interrUptiblie_StatUS.c ,让其睡眠 30s编译链接，后台运行该程序（后接 &符号），并使用PS命令查看运行状态 代码：#in cUde< Uni std.h>#in cUde<stdio.h> int mai n()SleeP(30); return;实验结果：pan©Pdn-Y400; Zpanpan-V4G0 gcc 1.2»C -o 1÷

4、;21,2,Ct Tn function 'nain"：1.2»c :6:3 ； warning- * returnj With no VaILlet in functior returning non -VOid return;PanePan-Y40: $ 1.2 SPS1 452Z PID TT¥TlWE CMDash 2PS4566pt2fl00:00:004522 pts2盹：盹：朋4523 pts/20e：ee；eePanePan-Y4iS （四）查看不可中断阻塞”状态（D）创建一个 C程序，如Uninter StatUS.c,让其睡眠30s编译

5、链接，后台运行该程序（后接 &），并使用PS命令查看运行状态 代码：#in clude< Uni std.h>#in ClUdeVStdio.h>int mai n()if(vfork()=0) Seep(300); return;实验结果：静第芒 pan©Pan-Y400: «par0pa*gcc 1.4, C LO 1 i 4PanePan-Y,40:*> 1,4 aPSL 4445PlD TTYTlMECMD4425 pts/19&6Qbash4445 pts/19&0:00；01,44446 pts/19&9:

6、&0:60PS4447 pts/1999:09:601.4PanSPan-Y,4G = I（五）查看 僵尸”进程（Z）创建一个C程序，如ZOmbie_StatUS.c，在其中创建一个子进程，并让子进程迅速结束, 而父进程陷入阻塞编译链接，后台运行该程序（后接&），并使用PS命令查看运行状态（30s内）代码：#in clude< Uni Std.h>#in cldUe<Stdio.h>int mai n()if(fork()SleeP(300); 实验结果：令鲁嵋 Pan(Pan-Y400:Parl> Y400 :»$ gcc 1,5, C

7、1÷5P30p3-Yh4O:-S1.5 &1 4232PID TT¥TlME4214 pts/O4232 pts/O；00:fid4233 pts/O4234 pts90:00:60paSpan-Yh40z-SIPSCMDZsh1.5PS1-5 <defunct>实验二观察LinUX进程/线程的异步并发执一、实验目的通过本实验学习如何创建 LinUX进程及线程，通过实验，观察 LinUX进程及线程的异步 执行。理解进程及线程的区别及特性， 进一步理解进程是资源分配单位，线程是独立调度单位。二、实验环境硬件环境：计算机一台，局域网环境；软件环境：LinUX

8、 UbUntu 操作系统，gcc编译器。三、实验内容和步骤1进程异步并发执行编写一个C语言程序，该程序首先初始化一个 count变量为1 ,然后使用fork函数创 建两个子进程， 每个子进程对 CoUnt力口 1后，显示"I amson, count=x ”或“I amdaughter, CoUnt=x ” ,父进程对 count 力口 1 之后，显示"I am father, count=x” ,其中 X 使用 count值代替。最后父进程使用 WaitPid等待两个子进程结束之后退出。编译连接后，多次运行该程序，观察屏幕上显示结果的顺序性，直到出现不一样的情 况为止，并

9、观察每行打印结果中count的值。代码：#in clude< Uni std.h>#in clude<stdio.h>int mai n()pid_t SOn _pid,daughter_pid; int coun t=1;SOn _pid=fork();if(son _pid=O)COUn t+;Prin tf("i am son,coun t=%d n",co Un t);elsedaughter_pid=fork();if(daughter_pid=0)COUn t+;Prin tf("i am daughter,co Un t=%d

10、 n",co Un t);elseCOUn t+;Prin tf("i am father,co Un t=%dn",co Un t);WaitPid(SOn_pid,NULL,0);WaitPid(daughter_pid,NULL,O);Q令* PanbaaideCiPad-y4CO:屮車面 pabotdepad<y4B0: -S Cd 虞直 pt>aoidcapad-y466; gcc X ÷ C o X x.c: In function rnin,ix,C!ZSr5t earning: Vmpltctt deckaratto Of f

11、unction jwatt>td , - WtrnPItC-Lt-fuctt o-dcclarationWAltPId (SOnVPid a Ml LL , O );JRPMIbllOQideflPI>d-y400: 桌面$ JXI an father f COUnt=2i an sonlcont-2i. an daughter,cot-2PanbdO Idea pad-y3D0:$ . xi an Ilather,cout-21. art son COUritI an daughter jc0t=2 panbotdcapad-y4Q6: -/桌面帛 x i an father,C

12、OUt2 t an daughtrcojt=2 t an SOnJCOUnt=2Danbg Id 已日 utad -桌面 $ 2、线程异步并发执行编写一个C语言程序，该程序首先初始化一个 CoUnt变量为1,然后使用Pthread_Create 函数创建两个线程， 每个线程对CoUnt力口 1后，显示"I amson, count=x "或“I amdaughter, CoUnt=x ” ,父进程对 count 力口 1 之后，显示"I am father, count=x” ,其中 X 使用 count值代替。最后父进程使用Pthread_join等待两个线程结

13、束之后退出。编译连接后，多次运行该程序，观察屏幕上显示结果的顺序性，直到出现不一样的情 况为止，并观察每行打印结果中CoUnt的值。代码：#in ClUdeV Uni std.h>#in CIUdeVStdio.h>#i nclude<pthread.h>void *daughter(void *num)int* a=(i nt *)num;*a+=1;Prin tf("i am daughter,co Un t=%d n",*a);void *son( void *num)int* a=(i nt *)num;*a+=1;Prin tf("

14、;i am son,coun t=%d n",*a);int mai n()Pthread_t SOn _tid,daughter_tid;int coun t=1;Pthread_Create(&son _tid,NULL,so n,&coun t);Pthread_Create(&daughter_tid,NULL,daughter, &coun t);COUn t+;Prin tf("i am Pare nt,co Un t:=%dn",co Un t);PthreadOin (son_tid,NULL);PthreadLjO

15、i n(daughter_tid,NULL);return 0;实验结果：6 * Penbaideapad-y4QC:亠/臬tfjtpccNFtocf.c： j.!*rat*中：bc(, text+xbj ：对,thred-cretefIeh文的引鋼b÷cU , tet+ecej: TPthrad-cret,未定文的引一毋b÷ct(. rext+fcI 对*rhr羽(CjOJLfI "耒宦义前引用b.ct(. et+xied)：对*|rthrei3_Jntni未定义的引用 colltct2: error: Id rffttrred T exit StatUSPnb

16、ftoQidtoped400r而$ gcc -02 -WalI -o b b.c -Ipthreadbc: Ir function daughter,:b.c：»：l: WOriIirq: COntrQl reaches tnd of o votd function retur' type b+匸；In function * SPn t;b«c:lS;l: »dnlnq: ctrg I -EdthEL end f 4hi -VOid function -WretLr n- type pa DbacHBtdra pad 4ft:, /bR M PArentf

17、Count：?t a daughterPCaUht>41 SOn cont=3jp3nb.o<ldm吕tl卓面S . /b1 Jn SCIn ,count=2i an Parent,cut:=3jl An daughterpcout=4PaflhaoUBaMi->V400：*ASS 实验三使用信号量进行互斥与同步一、实验目的本实验介绍在LinUX中使用信号量进行进程同步、互斥的方法。读者可以通过实验进一 步理解进程间同步与互斥、临界区与临界资源的概念与含义，并学会LinUX信号量的基本使用方法。二、实验环境硬件环境：计算机一台，局域网环境；软件环境：LinUX UbUntu

18、操作系统，gcc编译器。三、实验内容和步骤三、实验内容和步骤（一）参考：PoSlX 以及 SyStem VSyStem V: UniX众多版本中的一支，最初由 AT&T定义，目前为第四个版本，其中定 义了较为复杂的 API。POSIX : POrtabIe OPerating SyStem Interface ， IEEE 为了统一 UniX 接口而定义的标准， 定义了统一的 API接口。LinUX即支持SyStem API ,又支持 POSIX API（二）实验步骤step1:通过实例查看不使用互斥时的情况（假设文件命名为n o_sem.c）编译链接，同时运行两个进程，显示结果代码：

19、#in ClUdevStdio.h>#in cUde<Stdlib.h>int main （i nt argc,char *argv）Char message='x'int i=0;if（argc>1）message=argv10;for(i=0;i<10;i+)Prin tf("%c",message); fflush(stdout);sleep(ra nd()%3);Prin tf("%c",message); fflush(stdout);sleep(ra nd()%2);sleep(10);exit;

20、实验结果：協鲁® pan®Pan-Y400:卄/事面PBnePallgedttpapA-40:gcc x.c -Q X5cc: error: x.c:没有那个文件或目录guc：. (. rr r o ipdt filesCOnP,Llatic te'iratedPanPan-Y4QQ:-$ Cd 面 panpan-Y4:*/面S get *.C -0 X x*c: In fuction *ai,x.c:13:2: Warning: implicit declaration Of function 'SIeeP' -WiPlPliCit -functi

21、on '(JeclerattQnSl PepCdIfil)；Apap*Y4B!*面S x & ./x oi Z一 _step2:使用信号量来对临界资源进行互斥(假设文件命名为With_sem.c)编译链接，同时运行两个进程。观察X和O的出现规律，并分析原因。代码：#in clude<stdio.h>#in clude<stdlib.h>#in ClUde<systypes.h>#in clude<sys/ipc.h>#in clude<semaphore.h>#in clude<fc ntl.h>#in c

22、lude<sys/stat.h>int main (i nt argc,char *argv)Char message='x'int i=0;if(argc>1)message=argv10;Sem_t *mutex=sem_ope n("mysem",O_CREAT,0666,1);for(i=0;i<10;i+) sem_wait(mutex);Prin tf("%c",message); fflush(stdout);sleep(ra nd()%3);Prin tf("%c",messag

23、e); fflush(stdout);Sem_post(mutex); sleep(ra nd()%2);sleep(10);Sem_close(mutex);Sem_u nil nk("mysem"); exit(0);实验结果：PanOPan-Y400： EFjll面x,c:： In function >vn'x÷c: 22:2; arn<5 : inplicit declaration Of function *SIeeP, l - WinPlci t-fctinr 'declarationsieep(rad0V3);:C 

24、47; tcxt+xj1b): ,6CH OlKnf 未定义的引用-'- 一丄一.,-S-诵；C text+Gdfr)I 5,senpost,耒定叉的引用'未宦义的弓用 x*c: C < xt4izd: ,sen ULnk'未定文的引用 collect?: error T Id retr ed 1 exit StdtUStpcCAkHkx?.¢1fnai*中； I _x.c; ”=_ F ,c ： C + tet+67× ,aeFt-Wsit*未定义的弓 M.cI.tt+l23 对*5F-ClS?PanPar-Y4C0: Ti5 cc Lpth

25、reod .c -o X gcc-Ipthcead:未找到命會Panpar*-V4Q0:-/貞T1$ gcc x<c -IPthreaCl o K .c: In function falt:k<:22:2: MJrning: VnpKcit decIaratLor Of function , SIeeP , l WinPIiCit-function -IjeeIJratlOnJSIJeeP(rand O K3 JPMeP>n-Y4S0i-面$ & x oJ×1 9692XXCOXXOCXXOXOOXXOOXXOOXXOXXOOXXDOKCl)+ 巳完成Pan

26、$Pan-Y40OrJS |step3 :使用信号量来模拟下象棋红黑轮流走子的情况编写两个C语言程序black_chess.c以及red_chess.c，分别模拟下象棋过程中红方走子 和黑方走子过程。走子规则：红先黑后，红、黑双方轮流走子，到第10步，红方胜，黑方输。代码： 红色棋#in clude<stdio.h> #in clude<stdlib.h>#in ClUde<systypes.h>#in clude<sys/ipc.h>#in clude<semaphore.h>#in clude<fc ntl.h>#in

27、 ClUde<sysstat.h>int main (i nt argc,char *argv)int i=0;Sem_t *hei=sem_ope n("chess_black_sem",O_CREAT,0666,1);Sem_t *ho ng=sem_ope n("chess_red_sem",0_CREAT,0666,0); for(i=0;i<10;i+)Sem_wait(hei);if(i!=9)Prin tf("Red CheSS had moved,black,chess go!n");elsePrin

28、 tf("Red CheSS win!n");fflush(stdout);Sem_post(h On g);sleep(10);Sem_close(hei);Sem_close(h On g);Sem_ Un Ii nk("chess_red_sem");Sem_ Un Ii nk("chess_black_sem");exit(0);黑色棋：#in clude<stdio.h>#in clude<stdlib.h>#in clude<sys/types.h>#in clude<sys/ip

29、c.h>#in clude<semaphore.h>#in clude<fc ntl.h>#in clude<sys/stat.h>int main (i nt argc,char *argv)int i=0;Sem_t *hei=sem_ope n("chess_black_sem",O_CREAT,0666,1);Sem_t *ho ng=sem_ope n("chess_red_sem",0_CREAT,0666,0); for(i=0;i<10;i+)Sem_wait(h On g);if(i!=9

30、)Prin tf("Black CheSS had moved,red CheSS go!n");elsePrintf("Black CheSS win!n");fflush(stdout);Sem_post(hei);sleep(10);Sem_close(hei);Sem_close(h On g);Sem_ Un Ii nk("chess_red_sem");Sem _un Ii nk("chess_black_sem"); exit(0);实验结果：pan®Pan-Y400:呼臬面 pan0pan

31、*Y466:*/桌面$ red ./black 1 3677Red chess had moved,black,chess go! BIark chess had moved, red Che-SS go! Red CheSS had movedJbla匚k*chef55 go! 6Lack 匚hess had PlOVedJred CheSS go! Red CheSS had moved J black,chess go! BIaCk CheSS had (TlOVed,red 匚hess go! Red CheSS had moved ,black,che go! BIaCk chess

32、 had moved电d CheSS go! Reel CheSS hd IlIQVed J black,ches5 go ! BlaCk CheSS had PlOVedJred CheSS go! Red CheSS had movedfblack,chess go! BIaCk 匚hes had movedFred chess go! Red CheSS had movedtbiack,chess go! BLaCk chess had moved,red ChfrSS go! Red CheSS hd moved,black,chess go! BIaCk 匚hess had oved

33、,red CheSS go! Red CheSS had moved t black, ch ess go! BlaCk CheSS had moved,red CheSS goJ Red chess Win!Black CheSS Wini1+已完成./ redPan(JPan-?4fie：/桌面$ I实验四作业调度算法模拟、实验目的(1) 掌握周转时间、等待时间、平均周转时间等概念及其计算方法。(2) 理解五种常用的进程调度算法(FCFS、SJF、HRRF、HPF、RR)，区分算法之间 的差异性，并用C语言模拟实现各算法。(3) 了解操作系统中高级调度、中级调度和低级调度的区别和联系。、实

34、验环境硬件环境：计算机一台，局域网环境；软件环境：LinUX UbUntu操作系统，gcc编译器。、实验内容和步骤本实验所选用的调度算法均默认为非抢占式。实验所用的测试数据如下表所示。本实验所用的测试数据如下表所示表实验测试数据作业Id到达时间执行时间优先权180050028153013830252483520258451526700101782050作业的数据结构：typedef StrUCt nodeint number; / 作业号int reach_time;作业抵达时间 int need_time;作业的执行时间 int privilege;/作业优先权 float excellen

35、t; 响应比 int Start_time;/作业开始时间 int Wait_time;/ 等待时间 int visited;/作业是否被访问过 bool isreached;/作业是否已经抵达 job;代码：#i nclude <stdio.h>#in clude <stri ng.h> #i nclude <stdlib.h> #in clude<stdbool.h>/最大作业数量ConStint MAXJoB=50;/作业的数据结构typedef StrUCt nodeint number;/ 作业号int reach_time;作业抵达时

36、间int need_time;/作业的执行时间int privilege;/作业优先权float excellent;/ 响应比int Start_time;/作业开始时间int Wait_time;/ 等待时间int visited;/作业是否被访问过bool isreached;/作业是否抵达job;job jobs50;/ 作业序列 int quantity;/ 作业数量/初始化作业序列void in itial_jobs()int i;for(i=0;i<MAXJOB;i+)jobsi. nu mber=0; jobsi.reach_time=0; jobsi.privilege

37、=0; jobsi.excelle nt=O; jobsi.start_time=0; jobsi.wait_time=0; jobsi.visited=0; jobsi.isreached=false;qua ntity=O;/重置全部作业信息Void resetnfo()int i;for(i=0;i<MAXJOB;i+) jobsi.start_time=0;jobsi.wait_time=0;jobsi.visited=0;/查找当前CUrrent_time已到达未执行的最短作业，若无返回-1 int fin dminjob(job jobs,i nt CoUnt)int min

38、job=-1;/=jobs0. need_time;int min IoC=-1;int i;for(i=0;i<co Un t;i+)if(mi nloc=-1)if( jobsi.isreached=true && jobsi.visited=0)minjob=jobsi. need_time;min loc=i;else if(minjob>jobsi. need_time&&jobsi.visited=0&&jobsi.isreached=true)minjob=jobsi. need_time;min loc=i;retur

39、n mi nloc;/查找最早到达作业，若全部到达返回-1.int fin drearlyjob(job jobs,i nt CoUnt)int rearlyloc=-1;int rearlyjob=-1;int i;for(i=0;i<co Un t;i+)if(rearlyloc=-1)if(jobsi.visited=0)rearlyloc=i;rearlyjob=jobsi.reach_time;else if(rearlyjob>jobsi.reach_time&&jobsi.visited=0)rearlyjob=jobsi.reach_time;rea

40、rlyloc=i;return rearlyloc;ZZ读取作业数据void readJobdata()FlLE *fp;Char fname20;int i;ZZ输入测试文件文件名Prin tf("please in PUt job data file n amen");SCa nf("%s",fname);if(fp=fope n(fname,"r")=NULL)Prin tf("error, ope n file failed, PIeaSe CheCk file name:' n");elseZZ依

41、次读取作业信息while(!feof(fp)if(fscanf(fp,"%d %d %d %d",&jobsquantity.number,&jobsquantity.reach_time,&jobsquantity. n eed_time,&jobsqua ntity.privilege)=4)qua ntity+;ZZ打印作业信息Prin tf("output the orig in job data' n");Printf("'n");Prin tf("tjoblDtre

42、achtimet needtimetprivilegen");for(i=0;i<qua ntity;i+)Prin tf("t%-8dt%-8dt%-8dt%-8d n",jobsi. number,jobsi.reach_time,jobsi. need_time,jobsi .privilege);/FCFSvoid FCFS()int i;int CUrre nt_time=0;in t loc;int total_Waitime=0;int total_r OUn dtime=0;/获取最近到达的作 业loc=fi ndrearlyjob(jobs

43、,qua ntity);/输出作业流Printf("nnFCFS 算法作业流 n");Printf("n");Prin tf("tjoblDtreachtimetstarttimetwaittimetro Un dtimen");CUrre nt_time=jobsloc.reach_time;/每次循环找出最先到达的作业并打印相关信息for(i=0;i<qua ntity;i+)if(jobsloc.reach_time>curre nt_time) jobsloc.start_time=jobsloc.reach_ti

44、me;CUrre nt_time=jobsloc.reach_time;elsejobsloc.start_time=CUrre nt_time;jobsloc.wait_time=CUrre nt_time-jobsloc.reach_time;Prin tf("t%-8dt%-8dt%-8dt%-8dt%-8dn",loc+1,jobsloc.reach_time,jobsloc.start_time,jobs loc.wait_time,jobsloc.wait_time+jobsloc .n eed_time);jobsloc.visited=1;CUrre nt_

45、time+=jobsloc .n eed_time;total_Waitime+=jobsloc.wait_time;total_r OUn dtime=total_r OUn dtime+jobsloc.wait_time+jobsloc .n eed_time;ZZ获取剩余作业中最近到达作业loc=fi ndrearlyjob(jobs,qua ntity);Printf("总等待时间 %8d 总周转时间:%-8dn",tOtaLWaitime,total_roundtime);Printf(“平 均 等 待 时 间 ：%4.2f 平 均 周 转 时间:%4.2fn&q

46、uot;,(float)tOtaLWaitime/(quantity),(float)tOtaLroUndtime(quantity);/短作业优先作业调度void SFJSChdUlejob(job jobs,i nt CoUnt)int mai n()in itial_jobs();readJobdata();FCFS();reset_ji nfo();SFJSChdUlejob(jobs,qua ntity);SyStem("pause");return 0;实验结果：ll>d-r*tvP r - J LU 31CmI *a*Mfr-Y4M 1gcc aX -o

47、 aPaIltPall-Y4t-jK$ ÷aPIeaSe input job dntE file nameSSQUtPUt the Origin iob ClataJOblDreachtt IlgSoo81Sdttn503025201519prttlrege012221820C5S作业流JObID总等待：3Ie 平均等待时间： Eh: 1： pae：reachte reo 8Q& 815 820 830 釘5 845Starttlrle79aoe850ae8BSl693G总同转时q = us44.29平均周转时间：斫，43WaItttne&S3S備 SS7505rou

48、nctinel56S 砧809S16HOt found实验五 LinUX内存分配一、实验目的1、 了解LinUX内存的分配和虚拟内存管理的原理，学习如何使用malloc动态申请内存， 了解动态申请与静态申请的区别。2、深入理解LinUX的内存布局：代码段、数据段、 BSS段、堆栈段、堆二、实验环境硬件环境：计算机一台，局域网环境；软件环境：LinUX UbUntu 操作系统，gcc编译器。三、实验内容和步骤第一部分：编程分析 LinUX中内存动态申请与内存静态申请的区别要求：1、 编写一个LinUX C程序，在该程序中使用定义一个全局变量，以及使用malloc申请一段内存(可大于物理内存大小，

49、理论上在32位系统中可以申请小于 3G空间，但由于malloc 要求申请连续的空间，所以能申请到的空间一般在2G以下)。2、 打印出全局变量的起始地址，以及malloc分配的内存的地址；3、观察运行结果，并分析说明结果的地址是否是物理地址。代码：#in ClUdevStdio.h>#in clUde<stdlib.h>in t Pin t128;int mai n()char* PbUf=(Char *)malloc(sizeof(char)*1024*1024*1024);if(p in t)Prin tf("the address of Pint is %xn

50、",p in t);if(pbuf)Prin tf("the address of PbUf is %xn ",pbuf);if(pbuf)free(pbuf);PbUf=NULL;return 0;实验结果：PanPan-Y400:彳桌面PaPan-Y4：-$ 9cc z÷c -G Zgcc；z.c：没有那于文杵或目录9cc; f*l C rrr : no InPUIt filescpilti teriatd,panpan-Y40O Cd 臬面PanePan*Y46:gcc ZkC -a Zztc: In function dnair,ZkC:9:1

51、E w rrtr g: for31 f%x, exPeCtS arqunent Of type CUnSLgned intj f but arquent 2 hNE type ,lnt *, -wfr13t=PrIntf(Ilth总 JdcIr*ss Of Ptrt t xn, JPtntJAZ.c: 13:10： drig : FOrnat H ! , eIPeCti a rgert f type i uigMl Lftt* I but srgiEent 2 has type 'MmL *, *Wfor*t=JPrtntf("the address Of PbUf is x

52、n, fpbuf);APanPBn-Yqee tHS JZthe address Of Plnt is 61D6Othe ddd es Of PbLlF IS 24cellp2<锂pn¥40B桌而，第二部分：进一步了解LinUX内存的分配和虚拟内存管理的原理、了解LinUX的内存布局：代码段、数据段、BSS段、堆栈段、堆。要求：1、编写一个LinUX C程序，在该程序中定义初始化全局变量、未初始化全局变量、初始化静态变量、未初始化静态变量、局部变量、使用malloc分配的局部变量2、打印出各种变量的的起始地址代码：#i nclude <stdio.h>#includ

53、e <stdlib.h> /定义两个初始化的全局变量int data_varO = 10;int data_var1 = 10; /定义两个未初始化的全局变量int bss_varO;int bss_var1;int mai n()/分别定义一个初始化和一个未初始化的静态变 量StatiC int data_var2 = 10;StatiC int bss_var2;定义两个局部变 量int StaCk_var0 = 1;int StaCk_var1 = 1;int StaCk_var2 = 1;Printf("TEXT Segmentn");Prin tf(&

54、quot;Address of main: %pn", main);Printf("DATA Segmentn");Prin tf("Address of data_var0: %pn", &data_varO);Prin tf("Address of data_var1: %pn", & data_var1);Prin tf("Address of data_var2: %pn", &data_var2);Printf("BSS Segmentn");Prin

55、 tf("Address of bss_varO(BSS Segme nt): %pn", & bss_var0);Prin tf("Address of bss_VarI(BSS Segme nt): %pn", & bss_var1);Prin tf("Address of bss_var2(BSS Segme nt): %pn", & bss_var2);Printf("STACK Segmentn");Prin tf("Address of StaCk_var0: %pn&

56、quot;, &stack_var0);Prin tf("Address of StaCk_var1: %pn", &stack_var1);Printf("Address of StaCk_var2: %pn", &stack_var2); / 使用 malloc 分配三个大小为1024B的内存char* heap_var0 = (Char*)malloc(1024);char* heap_var1 = (Char*)malloc(1024);char* heap_var2 = (Char*)malloc(1024); / 使用 malloc 分配三个大小为 512MB 的内存char* mmap_var