东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 linux环境可运行 有截图Word文档下载推荐.docx

东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 linux环境可运行 有截图Word文档下载推荐.docx

《东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 linux环境可运行 有截图Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《东北大学操作系统实验 绝对自创 实验报告 含可执行源代码 linux环境可运行 有截图Word文档下载推荐.docx（21页珍藏版）》请在冰豆网上搜索。

intmain（）

{

ready.push（'

A'

）;

B'

C'

running.push（'

D'

block.push（'

E'

F'

print（）;

intp;

while（scanf（"

%d"

&

p）!

=EOF）

{

switch（p）

case2:

f2（）;

break;

case3:

f3（）;

case4:

f4（）;

default:

}

return0;

}

voidf1（）

charc=ready.front（）;

ready.pop（）;

running.push（c）;

voidf2（）

charc=running.front（）;

running.pop（）;

ready.push（c）;

f1（）;

voidf3（）

block.push（c）;

if（!

ready.empty（））

voidf4（）

charc=block.front（）;

block.pop（）;

if（running.empty（））

voidprint（）

intn1,n2,n3;

charch;

n1=ready.size（）;

n2=running.size（）;

n3=block.size（）;

cout<

<

"

___________________"

<

endl;

ready:

;

for（inti=0;

i<

n1;

i++）

ch=ready.front（）;

ch;

ready.push（ch）;

running:

n2;

ch=running.front（）;

running.push（ch）;

block:

n3;

ch=block.front（）;

block.push（ch）;

三、实验结果

实验二进程同步和通信棗生产者和消费者问题模拟

这是一个验证型实验。

通过对给出的程序进行验证、修改，进一步加深理解进程的概念，了解同步和通信的过程，掌握进程通信和同步的机制，特别是利用缓冲区进行同步和通信的过程。

通过补充新功能，加强对知识的灵活运用，培养创新能力。

cstdlib>

voidproducer（）;

//生产者

//显示缓冲区

voidconsumer（）;

//消费者

int>

buffer;

//缓冲区

blockp;

//等待进入缓冲区的数据

intdata=0;

//生产者生产的数据

intnum=0;

//缓冲区元素个数

intnp=0;

//正在等待的生产者

intnc=0;

//正在等待的消费者

charc;

%c"

c）!

='

e'

）

switch（c）

{

case'

p'

:

producer（）;

print（）;

c'

consumer（）;

break;

exit（0）;

}

}

voidproducer（）//生产者

if（num<

8）

if（nc>

0）

data++;

printf（"

\t\t\t\t\t正在等待的消费者数量为：

%d\n"

--nc）;

else

{

buffer.push（data++）;

num++;

}

else

blockp.push（data++）;

printf（"

\t\t\t\t\t正在等待的生产者数量为：

++np）;

voidconsumer（）//消费者

if（num>

buffer.pop（）;

num--;

if（np>

buffer.push（blockp.front（））;

blockp.pop（）;

--np）;

++nc）;

voidprint（）//显示缓冲区

intch;

intn=buffer.size（）;

printf（"

\t\t\t\t\t缓冲区状态%d：

\t\t\t\t\t"

num）;

n;

ch=buffer.front（）;

%d\t"

ch）;

buffer.push（ch）;

\n"

实验三进程的管道通信

一、实验目的

加深对进程概念的理解，明确进程和程序的区别。

学习进程创建的过程，进一步认识进程并发执行的实质。

分析进程争用资源的现象，学习解决进程互斥的方法。

学习解决进程同步的方法。

掌握Linux系统中进程间通过管道通信的具体实现。

二、实验内容

unistd.h>

string>

cstring>

sys/wait.h>

ctime>

sys/types.h>

charchild_1[20]="

Thisisprocess1"

charchild_2[20]="

Thisisprocess2"

charchild_3[20]="

Thisisprocess3"

charfather[20];

intfd[2];

intre=pipe（fd）;

pid_tp1,p2,p3;

int*status=NULL;

p1=fork（）;

if（p1==0）

lockf（fd[1],1,0）;

子进程一正在写入,prd=:

getpid（））;

write（fd[1],child_1,17）;

lockf（fd[1],0,0）;

exit（0）;

elseif（p1>

p2=fork（）;

if（p2==0）

lockf（fd[1],1,0）;

子进程二正在写入,pid=:

write（fd[1],child_2,17）;

lockf（fd[1],0,0）;

exit（0）;

elseif（p2>

{

p3=fork（）;

if（p3==0）

{

lockf（fd[1],1,0）;

printf（"

子进程三正在写入,prd=:

write（fd[1],child_3,27）;

lockf（fd[1],0,0）;

exit（0）;

}

elseif（p3>

wait（status）;

read（fd[0],father,17）;

cout<

father<

三、实验结果

实验四页面置换算法

进一步加深理解父子进程之间的关系及其并发执行。

理解内存页面调度的机理。

掌握页面置换算法及其实现方法。

培养综合运用所学知识的能力。

intflag_f=0;

intflag_l=0;

floatfifo_ok=0;

//fifo命中数

floatfifo_miss=0;

//fifo缺页数

floatlru_ok=0;

//lru命中数

floatlru_miss=0;

//lru缺页数

intframe_num;

//内存中分配页面个数

请输入内存中分配页面个数：

"

cin>

>

frame_num;

intM_Frame[frame_num]={0};

inttotal_instruction;

//随机数组长度

请输入随机数数组长度:

;

total_instruction;

intAcess_Series[total_instruction];

intAcess_Num;

//页程序个数

请输入页程序个数：

Acess_Num;

srand（time（NULL））;

//初始化随机数组

访问页的顺序为：

Acess_Series[i]=rand（）%Acess_Num+1;

cout<

Acess_Series[i]<

intp1=fork（）;

//创建子进程一

if（p1>

intp2=fork（）;

//创建子进程二

if（p2==0）//子进程二LRU

cout<

这里是子进程二:

LRU算法"

for（inti=0;

for（intj=0;

j<

j++）

{

if（Acess_Series[i]==M_Frame[j]）//命中

{

cout<

子程序2命中：

lru_ok++;

intt;

t=M_Frame[frame_num-1];

M_Frame[frame_num-1]=M_Frame[j];

M_Frame[j]=t;

for（intn=0;

n<

n++）

{

cout<

M_Frame[n]<

}

flag_l=1;

//表示命中

break;

}

elseflag_l=0;

}

if（flag_l==0）

cout<

子程序2缺页：

lru_miss++;

//缺页

for（intk=0;

k<

frame_num-1;

k++）

M_Frame[k]=M_Frame[k+1];

M_Frame[frame_num-1]=Acess_Series[i];

for（intn=0;

LRU:

命中数：

lru_ok<

缺页数：

lru_miss<

命中率：

lru_ok/（lru_ok+lru_miss）<

elseif（p1==0）//子进程一FIFO

这里是子进程一:

FIFO算法"

for（inti=0;

for（intj=0;

if（Acess_Series[i]==M_Frame[j]）//命中

子程序1命中：

fifo_ok++;

flag_f=1;

break;

elseflag_f=0;

if（flag_f==0）

子程序1缺页：

fifo_miss++;

for（intk=0;

M_Frame[k]=M_Frame[k+1];

M_Frame[frame_num-1]=Acess_Series[i];

for（intn=0;

FIFO"

fifo_ok<

fifo_miss<

fifo_ok/（fifo_ok+fifo_miss）<