操作系统linux版实验报告

1、操作系统linux版实验报告 操作系统实验 报告 （i ux 版） 网络 142 潘豹 1 1 999 实验一 观察 li u 进程状态 一、实验目得 在本实验中学习 lix 操作系统得进程状态，并通过编写一些简单代码来观察各种情况下，lux 进程得状态,进一步理解进程得状态及其转换机制。 二、实验环境 硬件环境：计算机一台,局域网环境; 软件环境:linx buntu 操作系统，cc 编译器。 （四）查瞧"不可中断阻塞'状态(d) 创建一个 c 程序,如nnetus、c，让其睡眠 30 代码： #ncludeunisd、 #incdestdo、h int mai（） it

2、=0,j=0,k=0; for(i=0;i00000；i+） or（j；j0000;j+） k+； -; 实验结果: （二)查瞧"暂停'状态（) 运行 run_ttu进程,其进入 r 状态： 代码同上： （三）查瞧"可中断阻塞'状态() 创建一个 c 程序,如 intrrptibiestatus、c,让其睡眠 3s 编译链接,后台运行该程序（后接符号），并使用 ps 命令查瞧运行状态 代码: #icludunist、h ncludestdio、 int mai（） sleep（0）； rturn； 实验结果: （四)查瞧"不可中断阻塞'状态

3、（d) 创建一个 c 程序，如 uinter_stas、c，让其睡眠0s 编译链接，后台运行该程序(后接）,并使用 p命令查瞧运行状态 代码： #nudeunistd、h iludestdo、h in ain（) f(vfork（)=0） sleep(30）; rer； 实验结果: （五）查瞧"僵尸'进程(z) 创建一个 c 程序,如omi_statu、c,在其中创建一个子进程,并让子进程迅速结束,而父进程陷入阻塞 编译链接,后台运行该程序（后接)，并使用 ps 命令查瞧运行状态（30s 内） 代码： icdeunt、h incduestdo、h nt man() i（for

4、k(）) sleep（300); 实验结果： 实验二 观察 l ux 进程/ 线程得异步并发执行 一、实验目得 通过本实验学习如何创建 linux 进程及线程，通过实验，观察inux 进程及线程得异步执行。理解进程及线程得区别及特性，进一步理解进程就是资源分配单位，线程就是独立调度单位。 二、实验环境 硬件环境:计算机一台,局域网环境; 软件环境：linux ubu操作系统,cc 编译器. 三、实验内容与步骤 、进程异步并发执行 编写一个 c 语言程序,该程序首先初始化一个nt 变量为 1,然后使用 fork 函数创建两个子进程，每个子进程对nt 加 1 后,显示"i m son，

5、con=x'或"i am dauhter， count='，父进程对 count 加 1 之后,显示"i am ath, cn=',其中使用 cunt 值代替。最后父进程使用 waitd 等待两个子进程结束之后退出。 编译连接后，多次运行该程序，观察屏幕上显示结果得顺序性，直到出现不一样得情况为止，并观察每行打印结果中 cout 得值。 代码： inludeistd、h #incdstdio、h nt main（） pd_ son_pid，augtr_pd； int cout1; so_pdfork（）； f（onp=0） count+; pint(

6、'i a so,ont=dn，oun）； lse augterpifork(）； if（dauhtpid=0） count+; printf('i m dauhter,ct=，cnt）; else count+； printf(i a father，countn'，cont); watpid（sn_pid,ull，0）； waipid(aughterpid,ul，)； 2、线程异步并发执行 编写一个语言程序，该程序首先初始化一个 count 变量为 1，然后使用 phed_ceat函数创建两个线程，每个线程对 cou加 1 后，显示"i a son, cux&

7、#39;或" am daghr, cotx，父进程对 cnt 加 1 之后，显示"i am father， count=x',其中使用 coun值代替。最后父进程使用 pthred_jn 等待两个线程结束之后退出。 编译连接后,多次运行该程序,观察屏幕上显示结果得顺序性，直到出现不一样得情况为止,并观察每行打印结果中 cun得值。 代码： inclueunstd、h incuesio、h cdepthe、h vid dagh(vid *nm) it a=（int ）num; *a+=1; prn('i am daugher，untd,*a）; void o（

8、oid *nu) nt* a=（nt ）num； *a+=1; ritf（i m son，co%d,*a）; int main(） pthread_ sn_tid，dahertd; int cun=1； pthrad_cet(son_td,nul,sn,coun）； prad_eate(ghtrt，null,dagter,t）； coun+； pintf（i m parent，cot：=%dn'，con); ead_joi(ontid,nul)； thread_join（dauhter_tid，ul）; ret ； 实验结果： 实验三 使用信号量进行互斥与同步 一、实验目得 本实验介绍

9、在 linu中使用信号量进行进程同步、互斥得方法。读者可以通过实验进一步理解进程间同步与互斥、临界区与临界资源得概念与含义,并学会 liux 信号量得基本使用方法。 二、实验环境 硬件环境：计算机一台,局域网环境; 软件环境：linux uunu 操作系统，gcc 编译器. 三、实验内容与步骤 三、实验内容与步骤 （一)参考:psix 以及sm v syte v:u众多版本中得一支，最初由 att 定义，目前为第四个版本,其中定义了较为复杂得 api。 posx：rtale oprating sste interfac，ieee 为了统一 unx 接口而定义得标准，定义了统一得 ap接口。li

10、nux 即支持 system pi,又支持 psix pi (二)实验步骤 st1：通过实例查瞧不使用互斥时得情况 (假设文件命名为_sem、c） 编译链接，同时运行两个进程，显示结果 代码： #icudstdi、h #incluesli、h int min(it ac，char argv） chr mesae=x; int i=0; if(arg1) mesage=rv1； or（i=0;i；i+) prtf（'%c，messag）； fs（stdou)； slee(rad()%3）; pntf(c'，me)； fflush（stu）； slp(n（）2）; sep（0）;

11、exit； 实验结果: stp2:使用信号量来对临界资源进行互斥 （假设文件命名为 witsem、c） 编译链接,同时运行两个进程。 观察 x 与 o 得出现规律,并分析原因。 代码： #inludestdi、h incluesdlib、 inldesystypes、h icludesys/ic、 incldsemaphore、h #incdefcnl、h #incluss/stt、h it main(int arg,ch *rg） car essge=x; nt i=0； i(rg1） msage=argv10； sem_ *mutex=sem_open（mye'，o_crea,06

12、，1）; fr(i=0；1；i+) sem_wait（ute）; rtf（c'，message）； flush（stdut）; sleep(rand(）； rint(c,msage）; ffls(stdou）； sem_post（te); le（an（）)； le（10); smcle(utex); semnln('s'); exi（0）; 实验结果: tep3：使用信号量来模拟下象棋红黑轮流走子得情况 编写两个 c 语言程序 blackhess、以及 red_chess、c,分别模拟下象棋过程中红方走子与黑方走子过程。走子规则:红先黑后，红、黑双方轮流走子，到第 1步

13、,红方胜，黑方输。 代码： 红色棋 icluest、 includestdib、h #incluesys/types、h includeys/pc、h ncludesmpoe、h cludefcn、h #icldesys/st、h int main（int arc，ca argv) nt i=0; sem_ hei=semope(chessbse'，ocreat,066，）； sem_t ngsemopn（ss_resem，o_reat，66,)； for(i=0；i10；i+） swat（hei）； if(!9) printf(red css hd move,blac，chess g

14、o！n)； els rintf（ed cess win!n）; flsh（sou)； sem_post（hon)； seep（10); se_lose（hei）; sem_close(hong)； seulik（'cess_redsem); m_nlnk(ches_blackem'); ext(0）； 黑色棋 ： #ncludestdo、 inluestdlb、 icudsyste、h inludesy/pc、h includsemaphore、h includefntl、h icludess/tat、 int main（int ar,char *argv） t i=0； se

15、mt *heisem_open(chessback_em',ocreat，06,1）; sem_t *hongsm_open('ces_rede,o_creat,066,）; for(=0；10;） sem_wait(hog）; i(i!=) pritf（ack chess ha movd,red chess go!'）; else rint(blak che win！）； fflh（stdut); m_ot（ei)； slee(10）； sm_cl（hi)； sem_clse(hong）; seunlik（'chess_edse); sem_unn（'

16、ches_lack_sm')； exit（0)； 实验结果： 实验四 作业调度算法模拟 一、实验目得 （1）掌握周转时间、等待时间、平均周转时间等概念及其计算方法。 （2）理解五种常用得进程调度算法(ffs、sjf、hrf、pf、r）,区分算法之间得差异性，并用 c 语言模拟实现各算法。 (3）了解操作系统中高级调度、中级调度与低级调度得区别与联系. 二、实验环境 硬件环境：计算机一台,局域网环境； 软件环境：linux unt操作系统,gcc 编译器。 三、实验内容与步骤 本实验所选用得调度算法均默认为非抢占式. 实验所用得测试数据如下表所示。 本实验所用得测试数据如下表所示 表 实

17、验测试数据 作业 id 到达时间 执行时间 优先权 8 50 0 2 815 30 1 3 830 25 2 20 5 845 15 0 10 1 7 820 5 作业得数据结构： typde struct no 号业作 / ；rebmun tni int rhtime；/ 作业抵达时间 int edtme;/ 作业得执行时间 int piviege；/ 作业优先权 比应响 /;tnelcxe taolf int srt_tim；/ 作业开始时间 nt wit_te;/ 等待时间 it vised；/ 作业就是否被访问过 bool isreached;/ 作业就是否已经抵达 jo； 代码: #

18、ince stdo、h lud strin、h #nclue sti、h #icudstdol、h /最大作业数量 cot int axob=0； /作业得数据结构 typedef suct node in nuber；/作业号 t reachtm;/作业抵达时间 it needtm；/作业得执行时间 nt pivilege;作业优先权 float excllnt;/响应比 n tar_time；/作业开始时间 it wit_time；/等待时间 visted；/作业就是否被访问过 bool srached；/作业就是否抵达 jo； ob jobs50；作业序列 i uanti；/作业数量 /

19、初始化作业序列 voi iialjobs(） int i； r（0;imaxjob;+) jbi、mber0； jbi、rachtim=0； jobsi、ivleg=; jobsi、xcllnt=0； jobsi、strt_time=; obs、wat_time=0； osi、isited=； obsi、iseche=lse; uantity0； /重置全部作业信息 vd reset_ino（） i i； fr(=0；imaxjb;i） jobsi、startie0； joi、wit_tie=0； obsi、ised=； /查找当前 curent_tim已到达未执行得最短作业，若无返回1 in

20、t fimijob（job job,nt u) int minob=1；/jbs0、ned_time； it inlo=-； int ； for（i=0；iun；i+） if（minloc=-1) if（ obsi、sreached=true josi、sied=0) injobjbi、ee_time； iloc=i； ls i（mnjbobsi、ne_timeoi、isite=0jobs、srah=tre) minjob=jobi、nee_ime； mnloc=i; etn nloc； 查找最早到达作业，若全部到达返回-1、 int idrerlyjo（job jobs,int con） i

21、nt realyoc=； t reayjob=； int i; for（i=;in；） i（rrlyoc=1） if（jbsi、viite=0） relyc=i; rarljo=jobi、rechtime; ese if（rearlyjobjbi、each_timbs、sitd=0） raryjo=jbsi、rac_time； rearylc=； return erlloc; /读取作业数据 vid reobta（） fle f； char fnae20; t i； /输入测试文件文件名 prinf('please inpt job data '）; scaf（s,fme）；

22、if(p=fopen(fname，）)=nll) printf（'rror， e ， ese check :n)； el /依次读取作业信息 ile（！fof（fp)） if(fsanf(， d % d'，obsquantity、numer,jobsntity、reach_tm，jobsqunity、ime,josqatty、rivilege）=) quantity+; /打印作业信息 rntf（outt the or job datan'）； prif（'-n')； pnf(tjbidtreactieteedtimepriilegen')； f

23、or(i=0；iny；+） printf('t%dt-8%8n,jb、numr，jobi、reachtime，jobsi、ned_tie,obsi、privig)； /ff void fc() nt ; int curen_time=0； it lo; i toalwaitie=; in tol_rndtime=0； /获取最近到达得作业 lo=ndralyo（ob,quni）； /输出作业流 pitf('nnfcs 算法作业流n')； prnf（-n')； prntf(tjbitreachmetsarttitwaittimetroundtien');

24、currenttim=jobl、ac_ie; /每次循环找出最先到达得作业并打印相关信息 r(i=;iquatit；+) if（josloc、each_timecurrt_te） jolo、stattm=oloc、reh_im； currettme=jobs、rech_tie； lse jobslc、star_ime=currenttm； obloc、waittie=crrnt_time-obsloc、each_im； prit(t%-8dt%-8dt%8t%-8dt8dn,lc+1，jobsl、rach_te，obsoc、strt_time，josloc、wa_ie, os、wittime+

25、jobsc、nee_t）； jobslc、vitd1; crentte+=jobslo、needime; total_waitime+=jslo、witime； tta_rdtetta_rndtime+joslc、wt_tie+jobslc、nd_tie; /获取剩余作业中最近到达作业 loc=indrelj（job,quatity); printf（'总等待时间：8d 总周转时间：-dn，oal_aitme,total_rontime）； rintf("平均等待时间： %4、2f 平均周转时间: %、2fn'，（flot)totl_waitime（uatiy)，（f

26、lot）totalountime（uantity）； /短作业优先作业调度 vid sfjhulejo(b jos,in cunt） nt ma（) initial_jobs(）； eadjobdata（）; fcfs（）; esetifo（)； sjschdeo(obs，quati）; ysm(pase'）； return 0； 实验结果： 实验五 in x 内存分配 一、实验目得 1、了解 linux 内存得分配与虚拟内存管理得原理，学习如何使用al动态申请内存，了解动态申请与静态申请得区别。 2、深入理解 linu得内存布局：代码段、数据段、ss 段、堆栈段、堆 二、实验环境 硬

27、件环境:计算机一台，局域网环境; 软件环境：linx buntu 操作系统,c 编译器。 三、实验内容与步骤 第一部分:编程分析 liu中内存动态申请与内存静态申请得区别 :求要1、编写一个 lnux c 程序，在该程序中使用定义一个全局变量，以及使用 mlloc 申请一段内存（可大于物理内存大小，理论上在位系统中可以申请小于g 空间，但由于aloc 要求申请连续得空间，所以能申请到得空间一般在 2g 以下）。 2、打印出全局变量得起始地址，以及 moc 分配得内存得地址； 3、观察运行结果，并分析说明结果得地址就是否就是物理地址. 代码： iudesti、h icludesdlib、h in

28、t int128； t main(） hr* puf（char *）mallc(iz（har)1024*104*102)； （pt) prinf('the ddres of pint s %n,pint）; if（f) n（e addres of pbuf s xn',puf）； if（pbu） fee（puf); buf=ull； retu 0； 实验结果: 第二部分：进一步了解 lnu内存得分配与虚拟内存管理得原理、了解inux 得内存布局:代码段、数据段、bs段、堆栈段、堆. 要求： 1、编写一个 linux c 程序,在该程序中定义初始化全局变量、未初始化全局变量、初始

29、化静态变量、未初始化静态变量、局部变量、使用 malloc 分配得局部变量 2、打印出各种变量得得起始地址 代码： #include stdi、h #inlude tlib、 /定义两个初始化得全局变量 t dat_va0 1； nt ata_ar1 = 0; 定义两个未初始化得全局变量 int bss_ar0; int bss_r1; int ain（） /分别定义一个初始化与一个未初始化得静态变量 sc in dta_vr2 = 0; stati in bssvr2；/定义两个局部变量 int stack_var = 1; n stackvr ; it stack_var = ； pint

30、f('-text segme-n); prntf('ddre of min： pn， main）; pritf（-data sement-n'); print('rss f dta_vr0： %pn', data_r0); rintf（'adres o daa_var1: pn， da_var1）； rtf(dress f dar2: p， data_vr2); rintf（'-bss segment-n')； prntf（'ddress of bss_var0（bss smet）： %pn'， bsr0）； pr

31、nf（'adrs of bsvar1(bss gment）： %pn'， ss_var1）； prnt(addrs of bss_v2(bss segmt)： pn', bss_var）； prif（-stak segment-'）； printf（'adrss of sk_0： n, stac_var0）; pint(ades f takvar： pn'， tack_va1）； pintf（'address of stak_var2： %pn'， sack_v2)； /使用 mloc 分配三个大小为 102b 得内存 c hea

32、p_vr = （car）aloc（1024）； char he_var1 （char）allo（10）; char hea_var2 （cha)mlc（102)； 使用 mllc 分配三个大小为 512m得内存 h mavar0 (har*)maloc（1024 104 12)； char* mmapvar1 = (cha）c(1 * 14 1)； char map_var2 = (cha*）maloc（2 102 * 512)； intf（-eap segment-n')； f（heapvr) rintf（ddrss of hepvar0：pn', ea_vr0）; re（h

33、eap_var0)； ea_ar = null； if(hava1） pritf（ddes of he_var1:%pn', heapvr1); re(heapvr1）； hap_ar = ul； i(heap_var) printf （'adss f eaar2：n， ea_ar2）; fr（hea_r); hea_var2 = nll; prnt('-map-n）; i（mmap_va0） pint(addres f mmap_var0：pn', mm_va0）； free（mmaar0); ma_var0 = ul; if（mma_va1） nt（addr

34、ess f mmp_var1:%pn， ma_var1)； fre（mapvar）； ma_va1 = ull； if(mmapva2） rintf（'addres of mmapvr2：n， m_var）; fre(ma_var2)； map_var = null； retur 0; 实验结果： 实验六 页面置换模拟程序设计 一、实验目得 1、通过软件模拟页面置换过程,加深对请求页式存储管理实现原理得理解 2、理解与掌握 opt、if与 lr三种页面置换算法，深入分析三者之间得优缺点. 二、实验环境 硬件环境：计算机一台,局域网环境； 软件环境：lin uu 操作系统，cc 编译器。

35、 三、实验内容与步骤 代码： incldetdo、h iluestdlib、 ldestring、 #ncluunt、h #defie vmpg 3 #dfine pm_pag 4 ne oal_instr 320 defi ntr_pr_page 1 dfine opt fine ifo 2 defin lr 3 tyedf stru int vn; nt pmn； int exist； t tim; vageiem； vag_item page_tablev_pg； vpe_item pa_bimapmpae； typde tuct int nm; int vpage; it ffst;

36、int infow； instr_itm； institm nraraytotlis; stru ns_flow intr_emistr； sruct inr_flownex; ； ct inst_lo_hed i nm； truc instr_fnxt； ; struct nt_fow_ead ifowhead； int painm=; nt rrepce_alg1; void nit_ata(）； od resetage_tbl（）； int ado_flo(it n）; int gen_ist_flow()； int allocppae(stru insr_lw*cur,int cp)；

37、 oi u（）; n opt（stuct inrflow*cur）; int fifo（struct ins_flowc）； int lru(struc instrflow*cur); vo ln（); int main(） nit_dat； gen_ns_ow(）； ritf(-he esu of opt-n）; cur_elc_al=opt； run（）; rin（-the result f fo-n')； urrepa_al=f; rset_pae_table（）； run(）； rintf（'-the esult of lru-n')； cr_reple_alg

38、r; reset_pgetabl()； rn(); lean(）; /3、数据初始化 vd iidat(） int i=0; for（i=0;vm_pge；i+) pag_tblei、vn=i; page_aei、pmn; pagetabli、exi=; paeablei、time1; f(i=0；ivm_pae；i+） pag_bitapi=nu; for(i=0；iotal_instr；i+） itr_arai、nmi； inst_aryi、vpage=i/instr_per_pe； sr_arayi、offst=ist_pr_age; instr_array、ifow=0; io_ea、

39、num=0; iflw_head、nexnul; fium=0； void eet_pagetae（) nt i0; fr（=0;ivmage；i+） page_tlei、vmn=i； page_tabe、pmn=0; page_tablei、exs=0； age_abl、tme=； for（i=；ivmag；+) pagebitmpnull; pi_um=0； /、生成指令流 i ddto_flow（t n) ret=0; sruc instrlo* talull； stuct instr_flow ptrnull; tai=(strt ins_flow*)maloc(sie（rut ins

40、tfow)； ailinsr=instr_rrayn； ilxtnull； if（intr_aayn、inflo=0) insr_rrayn、iflow; et=; if(iflow_hea、nu=0flo_ead、ne=u） iflow_hed、nexttail； le t=iflow_head、ex; hil（ptrnext！=nul） r=ptr-next； pr-next=tal； fowhead、nm=1; return ret； it gen_intrflow(） in tota0; it ； ran（it)etpi（)）; s(in）ran（)ttl_sr； tal+=ad_to

41、_flow(s）; if(stoaisr1） otl+d_o_low（+1）； while（totltotal_int) i(s0) s（int)rand（)%s； totl=dd_toflow（s）; if（stt_nstr1) tal+=ad_tofow（+1)； if（talinstr-2） =(in）rnd（）%（ttal_instr2)+（s+2)； toa+=addo_flo(）； if(stotal_nst-1） ttal+=addto_fow(s+1）; etur flow_he、num; i oc_pge(strct ns_lowr，it cp） it ; int page=-1； it pag=cur-vage； for(=0；im_pae;i+） if(ppabitmapi=nll） ppge=i； be； f（page=-1) switch(cur_rplae_alg） case p： ppag=opt(cu）； break； ae ifo： ppagif（cu）; reak; case lru: a