操作系统实验报告.docx

操作系统实验报告.docx

《操作系统实验报告.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告.docx（26页珍藏版）》请在冰豆网上搜索。

操作系统实验报告

《操作系统》实验报告

2014/2015学年第2学期

系别计算机学院

专业计算机科学与技术

班级2014级专升本班

姓名龚毓秀

学号1410211040

授课老师赵群礼

实验一：

熟悉LINUX基本命令及编程环境

1、实验内容

1.练习使用Gedit编辑器

使用Gedit编辑器用C语言编写一个HelloWorld程序，并保存。

具体操作：

点击“任务栏→位置→主文件夹”，打开主文件夹位置文件浏览器，空白处右键单击，弹出菜单选择“创建文档→空文件”，新建一个空文件，并命名为“hello.c”，右键单击“hello.c”，选择“使用Gedit打开”，在Gedit编辑器中编辑代码如下：

#include

intmain（）

{

printf（"Hello,Wrold!

\n"）;

}

编辑完成后，点击“保存”，保存文件。

2.使用gcc编译源程序。

gcc是linux下的一种c程序编译工具，使用方法如下：

编译：

gcc-ofilename1filename.c（或者gccfilename.c-ofilename1），其中:

filename.c是源文件名，filename1是目标文件名，o代表object

具体操作：

点击“任务栏→应用程序→附件→终端”，当前默认路径即为主文件夹，输入“gcchello.c-ohello”，回车运行后，若无任何提示，怎说明编译成功，已生成可执行文件“hello“，若提示有错误，则根据具体提示回到Gedit中修改源程序，保存后重新编译。

3.执行程序

执行：

./filenamel其中:

filename1是目标文件名。

具体操作：

在“终端”中输入“./hello”，回车后运行，若无错误，终端中将显示运行结果“Hello,Wrold!

”。

2、实验结果

实验二：

进程管理

一、实验目的

（1）理解进程的概念，掌握父、子进程创建的方法。

（2）认识和了解并发执行的实质，掌握进程的并发及同步操作。

二、实验环境

微型计算机，UbuntuLinux10.04，gedit，gcc

三、实验内容

1.编写一C语言程序，实现在程序运行时通过系统调用fork（）创建两个子进程，使父、子三进程并发执行，父亲进程执行时屏幕显示“Iamfather”，儿子进程执行时屏幕显示“Iamson”，女儿进程执行时屏幕显示“Iamdaughter”。

2.多次连续反复运行这个程序，观察屏幕显示结果的顺序，直至出现不一样的情况为止。

记下这种情况，试简单分析其原因。

3.修改程序，在父、子进程中分别使用wait（）、exit（）等系统调用“实现”其同步推进，并获取子进程的ID号及结束状态值。

多次反复运行改进后的程序，观察并记录运行结果。

四、实验结果

1.

2第一次：

第二次：

第三次：

第四次：

3.第一次：

第二次：

第三次：

第四次：

五、源代码

1.

#include

#include

#include

#include

intmain（）

{

pid_tpid;

char*message;

intn;

printf（"forkprogramstarting\n"）;

pid=fork（）;

if（pid==-1）

{

perror（"forkfailed"）;

exit

（1）;

}

elseif（pid==0）

{

message="Iamson";

n=2;

}

else

{

message="Iamfather";

n=1;

pid=fork（）;

if（pid==-1）

{

perror（"forkfailed"）;

exit

（1）;

}

elseif（pid==0）

{

message="Iamdaughter";

n=3;

}

}

for（;n>0;n--）

{

puts（message）;

sleep

（1）;

}

exit（0）;

}

2.

#include

#include

#include

#include

intmain（）

{

pid_tpid;

char*message;

intn;

printf（"forkprogramstarting\n"）;

pid=fork（）;

if（pid==-1）

{

perror（"forkfailed"）;

exit

（1）;

}

elseif（pid==0）

{

message="Iamson";

nice（5）;

n=5;

}

else

{

message="Iamfather";

n=4;

pid=fork（）;

if（pid==-1）

{

perror（"forkfailed"）;

exit

（1）;

}

elseif（pid==0）

{

message="Iamdaughter";

nice（10）;

n=3;

}

}

for（;n>0;n--）

{

puts（message）;

sleep

（1）;

}

exit（0）;

}

3.

#include

#include

#include

#include

#include

intmain（）

{

pid_tpid;

char*message;

intn;

intexit_code;

printf（"forkprogramstarting\n"）;

pid=fork（）;

if（pid==-1）

{

perror（"forkfailed"）;

exit

（1）;

}

elseif（pid==0）

{

message="Iamson";

n=2;

exit_code=42;

}

else

{

message="Iamfather";

n=1;

exit_code=0;

pid=fork（）;

if（pid==-1）

{

perror（"forkfailed"）;

exit

（1）;

}

elseif（pid==0）

{

message="Iamdaughter";

n=3;

exit_code=43;

}

}

for（;n>0;n--）

{

puts（message）;

sleep

（1）;

}

if（pid!

=0）

{

intstat_val;

pid_tchild_pid;

child_pid=wait（&stat_val）;

printf（"childhasfinished:

PID=%d\n",child_pid）;

if（WIFEXITED（stat_val））

printf（"childexitedwithcode%d\n",WEXITSTATUS（stat_val））;

else

printf（"childterminatedabnormally"）;

}

exit（exit_code）;

}

实验三：

进程调度

一、实验目的

（1）理解进程控制块和进程组织方式；

（2）掌握时间片轮转调度算法实现处理机调度。

二、实验环境

微型计算机，UbuntuLinux10.04，gedit，gcc

三、实验内容

1建立合理的PCB数据结构，建立含有8个进程结点的就绪队列，每个进程的要求运行时间随机产生，要求每个进程的要求运行时间不大于15。

2设置时间片大小（3~6），使用时间片轮转调度算法实现处理机调度。

四、实验结果

五、源代码

#include

#include

#include

#include

#defineNUM8

#defineLENsizeof（PCB）

typedefstructPCB

{

intname;

intruntime;

intrunedtime;

intkilltime;

structPCB*next;

}PCB;

voidmain（）

{

inttimeslice=5,i;

PCB*top,*tail,*temp,*runqueue;

srand（（int）time（0））;

for（i=0;i

{temp=（PCB*）malloc（LEN）;

temp->name=i;

temp->runtime=rand（）%15;

temp->runedtime=0;

temp->next=NULL;

temp->killtime=0;

if（i==0）

{

top=temp;

tail=temp;

}

else{

tail->next=temp;

tail=temp;

}

printf（"processname%d,runtime=%d,runedtime=%d,killtime=%d\n",

tail->name,tail->runtime,tail->runedtime,tail->killtime）;

}

printf（"************************************\n"）;

while（top!

=NULL）{

runqueue=top;

top=top->next;

runqueue->next=NULL;

runqueue->runtime=runqueue->runtime-timeslice;

if（runqueue->runtime<=0）

{

runqueue->killtime=runqueue->runtime+timeslice;

runqueue->runedtime=runqueue->killtime+runqueue->runedtime;

runqueue->runtime=0;

printf（"processname%d;runtime=%d,runedtime=%d,killtime=%d（finished）\n";

runqueue->name,runqueue->runtime;

runqueue->runedtime,runqueue->killtime）;

}

else{

runqueue->killtime=timeslice;

runqueue->runedtime=runqueue->runedtime+runqueue->killtime;

printf（"processname%d,runtime=%d,runedtime=%d,killtime=%d\n",

runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime）;

tail->next=runqueue;

tail=tail->next;

}

}

}

实验四：

进程通信

一、实验目的

（1）了解什么是消息，熟悉消息传送原理；

（2）了解和熟悉共享存储机制；

（3）掌握消息的发送与接收的实现方法。

二、实验环境

微型计算机，UbuntuLinux10.04，gedit，gcc

三、实验内容

1．根据消息传送机理，使用系统调用msgget（）,msgsnd（）,msgrev（）,及msgctl（）编制一长度为１k的消息发送和接收的程序，要求在程序中完成10次消息的发送和接收，每次发送消息结束和接收消息结束都需给出相应的屏幕提示，且每次发送的的内容不少于一个字符，并能在接收端输出。

2．根据共享存储区原理，使用系统调用shmget（）,shmat（）,shmdt（）,及shctl（）编制程序，要求创建一个长度为１k的共享存储区，并完成10次数据的发送和接收，每次发送数据结束和接收数据结束都需给出相应的屏幕提示，且每次发送的的数据应能在接收端输出。

四、实验结果

1.

2.

五、源代码

1.①client1.c

#include

#include

#include

#defineMSGKEY75

struct  msgform

  {  long  mtype;

    char  mtext[1000];

}msg;

int  msgqid;

voidclient（）

{

inti;

msgqid=msgget（MSGKEY,0777）;  /*打开75#消息队列*/

for（i=10;i>=1;i--）

{

  msg.mtype=i;

printf（‘（client）sent\n’）;

msgsnd（msgqid,&msg,1024,0）;    /*发送消息*/

}

exit（0）;}

main（）

{client（）;}

②server1.c

#include

#include

#include

#defineMSGKEY75

struct  msgform

  {  long  mtype;

    char  mtext[1000];

}msg;

int  msgqid;

voidserver（）

{

  msgqid=msgget（MSGKEY,0777|IPC_CREAT）;  /*创建75#消息队列*/

do{

msgrcv（msgqid,&msg,1030,0,0）;  /*接收消息*/

    printf（“（server）received\n”）;

}while（msg.mtype!

=1）;

msgctl（msgqid,IPC_RMID,0）;  /*删除消息队列，归还资源*/

exit（0）;

}

main（）

{  

server（）;

}

2.①client.c

#include

#include

#include

#include

#include

#defineSHMKEY75

intmain（）

{

intshmid;

int*addr;

inti=0;

shmid=shmget（SHMKEY,1024,0777）;

addr=shmat（shmid,0,0）;

while（i<10）

{

if（*addr==0）

{

*（addr+1）='a'+i;

printf（"clientsendmessage__%c\n",*（addr+1））;

i++;

*addr=1;

}

else

sleep

（1）;

}

return0;

}

②server.c

#include

#include

#include

#include

#include

#defineSHMKEY75

intmain（）

{

intshmid;

inti=0;

int*addr;

shmid=shmget（SHMKEY,1024,0777|IPC_CREAT）;

addr=shmat（shmid,0,0）;

*addr=0;

while（i<10）

{if（*addr==0）

sleep

（1）;

else

{printf（"servergetmessage__%c\n",*（addr+1））;

*addr=0;

i++;

}}

shmctl（shmid,IPC_RMID,0）;

exit（0）;

}

实验五：

存储管理

一、实验目的

（1）熟悉内存空闲分区的分配方式；

（2）理解动态分区存储管理方式；

（3）掌握动态分区的分配与回收的过程。

二、实验环境

微型计算机，UbuntuLinux10.04，gedit，gcc

三、实验内容

根据流程图和参考程序，完成模拟内存分配和回收过程。

内存空间大小为100，进程数为5，每个进程所需空间为随机产生，大小为1~20，编制程序，首先对5个进程进行内存分配，然后回收指定的进程空间，并进行适当的空闲分区合并操作，要求每次操作结束后都能显示当前的内存分配情况。

四、实验结果

截图一

截图二

截图三

五、源代码

#include

#include

typedefstructMEMORY_BLOCK{

intname;//进程名

intaddress;//起始地址

intlength;//长度

intflag;//标志,表示该块是否被分配。

structMEMORY_BLOCK*next;//指向下一个进程

}MEMORY_BLOCK;

#defineNUM5

#defineLENsizeof（MEMORY_BLOCK）

voidallocation（MEMORY_BLOCK*Header,intname,intlength_p）{

MEMORY_BLOCK*temp,*t,*tt;

intminsize=2;//不可切割的分区阈值

t=Header;

while（t!

=0）{

if（t->length>length_p&&t->flag==0）break;

t=t->next;

}if（t->length-length_p>minsize）{//分割

temp=（MEMORY_BLOCK*）malloc（LEN）;

temp->name=-1;

temp->flag=0;

temp->length=t->length-length_p;

temp->address=t->address+length_p;

t->name=name;

t->flag=1;

t->length=length_p;

temp->next=t->next;

t->next=temp;

}else{//直接分配

t->name=name;

t->flag=1;

}

}

voidreclaim（intprocessname,MEMORY_BLOCK*Header）{

MEMORY_BLOCK*temp,*t,*tt;

t=Header;

temp=t;

while（t->name!

=processname）{

temp=t;

t=t->next;

}if（t->next!

=NULL）{//t非尾结点

if（temp->flag==0&&t->next->flag==0）{//左右为空

temp->name=-1;

temp->length=temp->length+t->length+t->next->length;

tt=t->next;

temp->next=tt->next;

}elseif（temp->flag==0）{//左为空

temp->name=-1;

temp->length=temp->length+t->length;

temp->next=t->next;

}elseif（t->next->flag==0）{//右为空

t->name=-1;

t->length=t->length+t->next->length;

t->flag=0;

tt=t->next;

t->next=tt->next;

}else{//左右不为空

t->name=-1;

t->flag=0;

}else{//t是尾结点

if（temp->flag==0）{//左为空

temp->name=-1;

temp->length=temp->length+t->length;

temp=t->next;

}else{//左不为空

t->name=-1;

t->flag=0;

}

}

}

voidmain（）{//主函数

intlength_p,i,processname;

MEMORY_BLOCK*Header,*t;

Header=（MEMORY_BLOCK*）malloc（LEN）;//初始化存储空间

Header->name=-1;

Header->address=0;

Header->length=100;

Header->flag=0;

Header->next=NULL;

srand（（int）time（0））;

for（i=1;i<=NUM+1;i++）{

length_p=rand（）%20+1;//随机产生进程所需存储空间，至少为1

allocation（Header,i,length_p）;

}printf（"当前内存分配情况：

\n"）;

t=Header;

while（t!

=0）{

printf（"process_name:

%d,address:

%d,length:

%d,flag:

%d\n",t->name,t->address,t->length,t->flag）;

t=t->next;

}printf（"请输入回收的进程号（输入0结束）:

\n"）;

scanf（"%d",&processname）;

while（processname!

=0）{

printf（"