操作系统linux版实验报告

1、操作系统实验报告(Linux版)网络142 潘豹 实验一 观察Linux进程状态一、 实验目的在本实验中学习Linux操作系统的进程状态，并通过编写一些简单代码来观察各种情况下，Linux进程的状态，进一步理解进程的状态及其转换机制。二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Linux Ubuntu操作系统，gcc编译器。（四）查看“不可中断阻塞”状态（D）创建一个C程序，如uninter_status.c，让其睡眠30s代码：#include#includeint main() int i=0,j=0,k=0; for(i=0;i;i+) for(j=0;j;j+) k+; k

2、-; 实验结果:（二）查看“暂停”状态（T）运行run_status进程，其进入R状态：代码同上:（三）查看“可中断阻塞”状态（S）创建一个C程序，如interruptiblie_status.c，让其睡眠30s编译链接，后台运行该程序（后接&符号），并使用ps命令查看运行状态代码:#include#includeint main() sleep(30); return;实验结果:（四）查看“不可中断阻塞”状态（D）创建一个C程序，如uninter_status.c，让其睡眠30s编译链接，后台运行该程序（后接&），并使用ps命令查看运行状态代码:#include#includeint mai

3、n() if(vfork()=0) sleep(300); return;实验结果：（五）查看“僵尸”进程（Z）创建一个C程序，如zombie_status.c，在其中创建一个子进程，并让子进程迅速结束，而父进程陷入阻塞编译链接，后台运行该程序（后接&），并使用ps命令查看运行状态（30s内）代码：#include#incldueint main() if(fork() sleep(300);实验结果：实验二 观察Linux进程/线程的异步并发执行一、实验目的通过本实验学习如何创建Linux进程及线程，通过实验，观察Linux进程及线程的异步执行。理解进程及线程的区别及特性，进一步理解进程是资

4、源分配单位，线程是独立调度单位。二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Linux Ubuntu操作系统，gcc编译器。三、实验内容和步骤1、进程异步并发执行编写一个C语言程序，该程序首先初始化一个count变量为1，然后使用fork函数创建两个子进程，每个子进程对count加1后，显示“I am son, count=x”或“I am daughter, count=x”,父进程对count加1之后，显示“I am father, count=x”,其中x使用count值代替。最后父进程使用waitpid等待两个子进程结束之后退出。编译连接后，多次运行该程序，观察屏幕上显示结

5、果的顺序性，直到出现不一样的情况为止，并观察每行打印结果中count的值。代码：#include#includeint main() pid_t son_pid,daughter_pid; int count=1; son_pid=fork(); if(son_pid=0) count+; printf(i am son,count=%dn,count); else daughter_pid=fork(); if(daughter_pid=0) count+; printf(i am daughter,count=%dn,count); else count+; printf(i am fat

6、her,count=%dn,count); waitpid(son_pid,NULL,0); waitpid(daughter_pid,NULL,0); 2、线程异步并发执行编写一个C语言程序，该程序首先初始化一个count变量为1，然后使用pthread_create函数创建两个线程，每个线程对count加1后，显示“I am son, count=x”或“I am daughter, count=x”,父进程对count加1之后，显示“I am father, count=x”,其中x使用count值代替。最后父进程使用pthread_join等待两个线程结束之后退出。编译连接后，多次运行

7、该程序，观察屏幕上显示结果的顺序性，直到出现不一样的情况为止，并观察每行打印结果中count的值。代码：#include#include#includevoid *daughter(void *num)int* a=(int *)num;*a+=1;printf(i am daughter,count=%dn,*a);void *son(void *num)int* a=(int *)num;*a+=1;printf(i am son,count=%dn,*a);int main()pthread_t son_tid,daughter_tid;int count=1;pthread_creat

8、e(&son_tid,NULL,son,&count);pthread_create(&daughter_tid,NULL,daughter,&count);count+;printf(i am parent,count:=%dn,count);pthread_join(son_tid,NULL);pthread_join(daughter_tid,NULL);return 0;实验结果：实验三 使用信号量进行互斥与同步 一、 实验目的本实验介绍在Linux中使用信号量进行进程同步、互斥的方法。读者可以通过实验进一步理解进程间同步与互斥、临界区与临界资源的概念与含义，并学会Linux信号量的基

9、本使用方法。二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Linux Ubuntu操作系统，gcc编译器。三、实验内容和步骤三、实验内容和步骤（一）参考：POSIX以及System VSystem V：Unix众多版本中的一支，最初由AT&T定义，目前为第四个版本，其中定义了较为复杂的API。POSIX：Portable Operating System Interface，IEEE为了统一Unix接口而定义的标准，定义了统一的API接口。Linux即支持System API，又支持POSIX API（二）实验步骤step1：通过实例查看不使用互斥时的情况 (假设文件命名为no_se

10、m.c)编译链接，同时运行两个进程，显示结果代码：#include#includeint main(int argc,char *argv)char message=x;int i=0;if(argc1)message=argv10;for(i=0;i10;i+)printf(%c,message);fflush(stdout);sleep(rand()%3);printf(%c,message);fflush(stdout);sleep(rand()%2);sleep(10);exit;实验结果：step2：使用信号量来对临界资源进行互斥 (假设文件命名为with_sem.c)编译链接，同时

11、运行两个进程。观察X和O的出现规律，并分析原因。代码：#include#include#include#include#include#include#includeint main(int argc,char *argv)char message=x;int i=0;if(argc1)message=argv10;sem_t *mutex=sem_open(mysem,O_CREAT,0666,1);for(i=0;i10;i+)sem_wait(mutex);printf(%c,message);fflush(stdout);sleep(rand()%3);printf(%c,messag

12、e);fflush(stdout);sem_post(mutex);sleep(rand()%2);sleep(10);sem_close(mutex);sem_unlink(mysem);exit(0);实验结果：step3：使用信号量来模拟下象棋红黑轮流走子的情况编写两个C语言程序black_chess.c以及red_chess.c，分别模拟下象棋过程中红方走子和黑方走子过程。走子规则：红先黑后，红、黑双方轮流走子，到第10步，红方胜，黑方输。代码:红色棋#include#include#include#include#include#include#includeint main(int

13、 argc,char *argv)int i=0;sem_t *hei=sem_open(chess_black_sem,O_CREAT,0666,1);sem_t *hong=sem_open(chess_red_sem,O_CREAT,0666,0);for(i=0;i10;i+)sem_wait(hei);if(i!=9)printf(Red chess had moved,black,chess go!n);elseprintf(Red chess win!n);fflush(stdout);sem_post(hong);sleep(10);sem_close(hei);sem_clo

14、se(hong);sem_unlink(chess_red_sem);sem_unlink(chess_black_sem);exit(0);黑色棋 ：#include#include#include#include#include#include#includeint main(int argc,char *argv)int i=0;sem_t *hei=sem_open(chess_black_sem,O_CREAT,0666,1);sem_t *hong=sem_open(chess_red_sem,O_CREAT,0666,0);for(i=0;i10;i+)sem_wait(hong

15、);if(i!=9)printf(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(hong);sem_unlink(chess_red_sem);sem_unlink(chess_black_sem);exit(0);实验结果：实验四 作业调度算法模拟一、 实验目的（1）掌握周转时间、等待时间、平均周转时间等概念及其计算方法。（2）理解五种常用的进程调度算法（FCFS、SJF、HR

16、RF、HPF、RR），区分算法之间的差异性，并用C语言模拟实现各算法。（3）了解操作系统中高级调度、中级调度和低级调度的区别和联系。二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Linux Ubuntu操作系统，gcc编译器。三、实验内容和步骤本实验所选用的调度算法均默认为非抢占式。实验所用的测试数据如下表所示。本实验所用的测试数据如下表所示表 实验测试数据作业Id到达时间执行时间优先权180050028153013830252483520258451526700101782050作业的数据结构：typedef struct nodeint number; / 作业号int reac

17、h_time;/ 作业抵达时间int need_time;/ 作业的执行时间int privilege;/ 作业优先权float excellent;/ 响应比int start_time;/ 作业开始时间int wait_time;/ 等待时间int visited;/ 作业是否被访问过bool isreached;/ 作业是否已经抵达job;代码：#include #include #include #include/最大作业数量const int MAXJOB=50;/作业的数据结构typedef struct nodeint number;/作业号 int reach_time;/作业

18、抵达时间int need_time;/作业的执行时间int privilege;/作业优先权float excellent;/响应比int start_time;/作业开始时间int wait_time;/等待时间int visited;/作业是否被访问过bool isreached;/作业是否抵达job;job jobs50;/作业序列int quantity;/作业数量/初始化作业序列void initial_jobs()int i;for(i=0;iMAXJOB;i+)jobsi.number=0;jobsi.reach_time=0;jobsi.privilege=0;jobsi.ex

19、cellent=0;jobsi.start_time=0;jobsi.wait_time=0;jobsi.visited=0;jobsi.isreached=false;quantity=0;/重置全部作业信息void reset_jinfo() int i; for(i=0;iMAXJOB;i+) jobsi.start_time=0; jobsi.wait_time=0; jobsi.visited=0; /查找当前current_time已到达未执行的最短作业,若无返回-1int findminjob(job jobs,int count)int minjob=-1;/=jobs0.ne

20、ed_time;int minloc=-1;int i;for(i=0;ijobsi.need_time&jobsi.visited=0&jobsi.isreached=true)minjob=jobsi.need_time;minloc=i;return minloc;/查找最早到达作业，若全部到达返回-1.int findrearlyjob(job jobs,int count)int rearlyloc=-1;int rearlyjob=-1;int i;for(i=0;ijobsi.reach_time&jobsi.visited=0)rearlyjob=jobsi.reach_tim

21、e;rearlyloc=i;return rearlyloc;/读取作业数据void readJobdata()FILE *fp;char fname20;int i; /输入测试文件文件名printf(please input job data file namen);scanf(%s,fname);if(fp=fopen(fname,r)=NULL)printf(error, open file failed, please check filename:n);else/依次读取作业信息while(!feof(fp)if(fscanf(fp,%d %d %d %d,&jobsquantit

22、y.number,&jobsquantity.reach_time,&jobsquantity.need_time,&jobsquantity.privilege)=4)quantity+;/打印作业信息printf(output the origin job datan);printf(-n);printf(tjobIDtreachtimetneedtimetprivilegen);for(i=0;iquantity;i+)printf(t%-8dt%-8dt%-8dt%-8dn,jobsi.number,jobsi.reach_time,jobsi.need_time,jobsi.priv

23、ilege);/FCFSvoid FCFS() int i; int current_time=0;int loc;int total_waitime=0;int total_roundtime=0;/获取最近到达的作业loc=findrearlyjob(jobs,quantity);/输出作业流printf(nnFCFS算法作业流n);printf(-n); printf(tjobIDtreachtimetstarttimetwaittimetroundtimen);current_time=jobsloc.reach_time; /每次循环找出最先到达的作业并打印相关信息for(i=0;i

24、current_time)jobsloc.start_time=jobsloc.reach_time;current_time=jobsloc.reach_time;elsejobsloc.start_time=current_time;jobsloc.wait_time=current_time-jobsloc.reach_time; printf(t%-8dt%-8dt%-8dt%-8dt%-8dn,loc+1,jobsloc.reach_time,jobsloc.start_time,jobsloc.wait_time,jobsloc.wait_time+jobsloc.need_tim

25、e);jobsloc.visited=1;current_time+=jobsloc.need_time;total_waitime+=jobsloc.wait_time; total_roundtime=total_roundtime+jobsloc.wait_time+jobsloc.need_time;/获取剩余作业中最近到达作业loc=findrearlyjob(jobs,quantity); printf(总等待时间:%-8d 总周转时间:%-8dn,total_waitime,total_roundtime); printf(“平均等待时间: %4.2f 平均周转时间: %4.2f

26、n,(float)total_waitime/(quantity),(float)total_roundtime/(quantity); /短作业优先作业调度void SFJschdulejob(job jobs,int count)int main() initial_jobs(); readJobdata(); FCFS();reset_jinfo();SFJschdulejob(jobs,quantity);system(pause);return 0;实验结果：实验五 Linux内存分配一、 实验目的1、了解Linux内存的分配和虚拟内存管理的原理，学习如何使用malloc动态申请内存

27、，了解动态申请与静态申请的区别。2、深入理解Linux的内存布局：代码段、数据段、BSS段、堆栈段、堆二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Linux Ubuntu操作系统，gcc编译器。三、实验内容和步骤第一部分：编程分析Linux中内存动态申请与内存静态申请的区别 要求： 1、编写一个Linux C程序，在该程序中使用定义一个全局变量，以及使用malloc申请一段内存（可大于物理内存大小，理论上在32位系统中可以申请小于3G空间，但由于malloc要求申请连续的空间，所以能申请到的空间一般在2G以下）。2、打印出全局变量的起始地址，以及malloc分配的内存的地址；3、观

28、察运行结果，并分析说明结果的地址是否是物理地址。代码：#include#includeint pint128;int main()char* pbuf=(char *)malloc(sizeof(char)*1024*1024*1024);if(pint)printf(the address of pint is %xn,pint);if(pbuf)printf(the address of pbuf is %xn,pbuf);if(pbuf)free(pbuf);pbuf=NULL;return 0;实验结果：第二部分：进一步了解Linux内存的分配和虚拟内存管理的原理、了解Linux的内存

29、布局：代码段、数据段、BSS段、堆栈段、堆。要求：1、编写一个Linux C程序，在该程序中定义初始化全局变量、未初始化全局变量、初始化静态变量、未初始化静态变量、局部变量、使用malloc分配的局部变量2、打印出各种变量的的起始地址代码：#include #include /定义两个初始化的全局变量int data_var0 = 10; int data_var1 = 10; /定义两个未初始化的全局变量int bss_var0; int bss_var1; int main() /分别定义一个初始化和一个未初始化的静态变量 static int data_var2 = 10; static

30、 int bss_var2;/定义两个局部变量 int stack_var0 = 1; int stack_var1 = 1; int stack_var2 = 1; printf(-TEXT Segment-n); printf(Address of main: %pn, main); printf(-DATA Segment-n); printf(Address of data_var0: %pn, &data_var0); printf(Address of data_var1: %pn, &data_var1); printf(Address of data_var2: %pn, &d

31、ata_var2); printf(-BSS Segment-n); printf(Address of bss_var0(BSS Segment): %pn, &bss_var0); printf(Address of bss_var1(BSS Segment): %pn, &bss_var1); printf(Address of bss_var2(BSS Segment): %pn, &bss_var2); printf(-STACK Segment-n); printf(Address of stack_var0: %pn, &stack_var0); printf(Address o

32、f 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_var0 = (char*)malloc(1024 * 1024 * 512);

33、 char* mmap_var1 = (char*)malloc(1024 * 1024 * 512); char* mmap_var2 = (char*)malloc(1024 * 1024 * 512); printf(-HEAP Segment-n); if(heap_var0) printf(Address of heap_var0:%pn, heap_var0); free(heap_var0); heap_var0 = NULL; if(heap_var1) printf(Address of heap_var1:%pn, heap_var1); free(heap_var1);

34、heap_var1 = NULL; if(heap_var2) printf(Address of heap_var2:%pn, heap_var2); free(heap_var2); heap_var2 = NULL; printf(-mmap-n); if(mmap_var0) printf(Address of mmap_var0:%pn, mmap_var0); free(mmap_var0); mmap_var0 = NULL; if(mmap_var1) printf(Address of mmap_var1:%pn, mmap_var1); free(mmap_var1); m

35、map_var1 = NULL; if(mmap_var2) printf(Address of mmap_var2:%pn, mmap_var2); free(mmap_var2); mmap_var2 = NULL; return 0; 实验结果：实验六 页面置换模拟程序设计一、 实验目的1、通过软件模拟页面置换过程，加深对请求页式存储管理实现原理的理解2、理解和掌握OPT、FIFO和LRU三种页面置换算法，深入分析三者之间的优缺点。二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Linux Ubuntu操作系统，gcc编译器。三、实验内容和步骤代码：#include#includ

36、e#include#include#define VM_PAGE 32#define PM_PAGE 4#define TOTAL_INSTR 320#define INSTR_PER_PAGE 10#define OPT 1#define FIFO 2#define LRU 3typedef struct int vmn; int pmn; int exist; int time; vpage_item; vpage_item page_tableVM_PAGE; vpage_item* ppage_bitmapPM_PAGE;typedef struct int num; int vpag

37、e; int offset; int inflow; instr_item; instr_item instr_arrayTOTAL_INSTR;struct instr_flow instr_item*instr; struct instr_flow*next; ;struct instr_flow_head int num; struct instr_flow*next; ;struct instr_flow_head iflow_head; int pfail_num=0; int cur_replace_alg=1; void init_data(); void reset_page_

38、table(); int add_to_flow(int n); int gen_instr_flow(); int alloc_PPage(struct instr_flow*cur,int chip); void run(); int opt(struct instr_flow*cur); int fifo(struct instr_flow*cur); int lru(struct instr_flow*cur); void clean();int main() init_data; gen_instr_flow(); printf(-the result of OPT-n);cur_r

39、eplace_alg=OPT;run();printf(-the result of FIFO-n);cur_replace_alg=FIFO;reset_page_table();run();printf(-the result of LRU-n);cur_replace_alg=LRU;reset_page_table();run();clean();/3.数据初始化void init_data()int i=0;for(i=0;iVM_PAGE;i+)page_tablei.vmn=i;page_tablei.pmn=0;page_tablei.exist=0;page_tablei.t

40、ime=-1;for(i=0;iVM_PAGE;i+)ppage_bitmapi=NULL;for(i=0;iTOTAL_INSTR;i+)instr_arrayi.num=i;instr_arrayi.vpage=i/INSTR_PER_PAGE;instr_arrayi.offset=i%INSTR_PER_PAGE;instr_arrayi.inflow=0;iflow_head.num=0;iflow_head.next=NULL;pfail_num=0;void reset_page_table()int i=0;for(i=0;iVM_PAGE;i+)page_tablei.vmn

41、=i;page_tablei.pmn=0;page_tablei.exist=0;page_tablei.time=-1;for(i=0;iinstr=&instr_arrayn;tail-next=NULL;if(instr_arrayn.inflow=0)instr_arrayn.inflow=1;ret=1;if(iflow_head.num=0&iflow_head.next=NULL)iflow_head.next=tail; elseptr=iflow_head.next;while(ptr-next!=NULL)ptr=ptr-next;ptr-next=tail;iflow_head.num+=1;return ret;int gen_instr_flow()int total=0;int s;srand(int)getpid();s=(int)ra