东秦操作系统实验报告Word下载.docx
《东秦操作系统实验报告Word下载.docx》由会员分享，可在线阅读，更多相关《东秦操作系统实验报告Word下载.docx（57页珍藏版）》请在冰豆网上搜索。
while（（pl=fork（））==-1）；
/*创建子进程p1*/
if（pl＝=0）/*子进程创建成功*/
putchar（‘b’）；
else
while（（p2=fork（））==-1）；
/*创建另一个子进程*/
if（p2==0）/*子进程创建成功*/
putchar（‘c’）;
elseputchar（‘a’）;
/*父进程执行*/
}
2.进程的控制。
stdio．h>
intpl，p2，i;
while（p1=fork（））==-1）;
if（p1==0）
for（i＝0;
i<
500；
i++）
printf（"
child％d\n”，i）;
while（p2=fork（））==-1）;
if（p2==0）
for（i=0;
500;
i++）
printf（“son％d\n”,i）
for（i＝0，i<
500;
printf（"
daughter％d\n”，i）;
1、进程的创建
2、进程的控制
实验3实现进程的软中断通信
1．掌握基本的软中断通信方法；
2．利用系统调用signal（）捕捉中断信号；
3．理解Linux系统中的进程通信的基本原理。
1.编制一段程序，使其实现进程的软中断通信；
要求：
使用系统调用fork（）创建两个子进程，再用系统调用signal（）让父进程捕捉键盘上来的中断信号（即按^C键）；
当捕捉到中断信号后，父进程用系统调用Kill（）向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止：
ChildProcessllisKilledbyParent!
ChildProcessl2isKilledbyParent!
父进程等待两个子进程终止后，输出如下的信息后终止：
ParentProcessisKilled!
2.在上面的程序中增加语句signal（SIGINT，SIG_IGN）和signal（SIGQUIT，SIG_IGN），观察执行结果，并分析原因。
这里,signal（SIGINT,SIG_IGN）和signal（SIGQUIT,SIG_IGN）分别为忽略Dfl键信号以及忽略中断信号。
内容一源代码：
#include<
signal.h>
unistd.h>
stdlib.h>
voidwaiting（）,stop（）;
intwait_mark;
main（）
intp1,p2,stdout;
while（（p1=fork（））==-1）;
if（p1>
0）
{
while（（p2=fork（））==-1）;
if（p2>
wait_mark=1;
signal（SIGINT,stop）;
waiting（0）;
kill（p1,16）
kill（p2,17）;
wait（0）;
printf（"
parentprocessiskilled!
\n"
）;
exit（0）;
}
else
signal（SIGINT,SIG_IGN）;
signal（17,stop）;
%d"
SIG_DFL）;
waiting（）;
lockf（stdout,1,0）;
childprocess2iskilledbyparent!
lockf（stdout,0,0）;
signal（16,stop）;
childprocess1iskilledbyparent!
}
voidstop（）
wait_mark=0;
运行结果：
内容二源代码
intpid1,pid2;
intEndFlag=0;
pid1=0;
pid2=0;
voidIntDelete（）
kill（pid1,16）;
kill（pid2,17）;
EndFlag=1;
voidInt1（）
childprocess1iskilledbyparent!
voidInt2（）
childprocess2iskilledbyparent!
intexitipid;
signal（SIGQUIT,SIG_IGN）;
while（（pid1=fork（））==-1）;
if（pid1==0）
signal（SIGUSR1,Int1）;
signal（SIGINT,SIG_IGN）;
pause（）;
exit（0）;
while（（pid2=fork（））==-1）;
if（pid2==0）
{
signal（SIGUSR2,Int2）;
signal（SIGINT,SIG_IGN）;
pause（）;
exit（0）;
}
else
signal（SIGINT,IntDelete）;
waitpid（-1,&
exit,0）;
printf（"
实验4进程的管道通信
1.了解系统调用pipe（）的功能；
2.掌握进程的管道通信的实现；
3.进一步理解进程通信的基本原理。
编制一段程序，实现进程的管道通信。
使用系统调用pipe（）建立一条管道线；
两个子进程P1和P2分别向管道各写一句话
Child1issendingamessage!
Child2issendingamessage！
而父进程则从管道中读出来自于两个子进程的信息，显示在屏幕上。
要求父进程先接收子进程P1发来的消息，然后再接收子进程P2发来的消息
实验5使用动态优先权的进程调度算法模拟
通过动态优先权算法的模拟加深对进程概念进程调度过程的理解。
1．用C语言来实现对N个进程采用动态优先权优先算法的进程调度。
2．每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：
进程标识数ID。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
进程已占用的CPU时间CPUTIME。
进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，将进入阻塞状态。
进程被阻塞的时间BLOCKTIME，表示已足赛的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
进程状态START。
队列指针NEXT，用来将PCB排成队列。
3.优先数改变的原则：
进程在就绪队列中呆一个时间片，优先数加1。
进程每运行一个时间片，优先数减3。
4.假设在调度前，系统中有5个进程，它们的初始状态如下：
ID01234
PRIORITY93830290
CPUTIME00000
ALLTIME33634
STARTBLOCK2-1-1-1-1
BLOCKTIME30000
STATEREADYREADYREADYREADYREADY
5.为了清楚的观察各进程的调度过程，程序应将每个时间片内的情况显示出来，参照的具体格式如下：
RUNNINGPROG：
i
READY-QUEUE：
-〉id1-〉id2
BLOCK-QUEUE：
-〉id3-〉id4
=======================================
ID01234
PRIORITYP0P1P2P3P4
CUPTIMEC0C1C2C3C4
ALLTIMEA0A1A2A3A4
STARTBLOCKT0T1T2T3T4
BLOCKTIMEB0B1B2B3B4
STATES0S1S2S3S4
#include<
#defineN5
voidinit（）;
voidprint（）;
intgetRunning（）;
voidsort（）;
intrun（inttime）;
enumSTATE{Ready,Run,Block,RunOut};
structPROCESS{
intID;
intPriority;
intCputime;
intAlltime;
intStartblock;
intBlocktime;
enumSTATEState;
}Process[N];
intREADY[N];
intBLOCK[N];
intRUNOUT[N][2];
intmain（）{
intTime=0;
init（）;
Time:
%d\n"
Time）;
sort（）;
print（）;
while
（1）{
Time++;
getchar（）;
printf（"
if（run（Time））
break;
return0;
voidinit（）
inti;
for（i=0;
i<
N;
++i）{
READY[i]=-1;
BLOCK[i]=-1;
RUNOUT[i][0]=-1;
RUNOUT[i][1]=-1;
Process[i].ID=i;
Process[i].Cputime=0;
Process[i].State=Ready;
Process[i].Startblock=-1;
Process[i].Blocktime=0;
Process[0].Priority=9;
Process[0].Alltime=3;
Process[0].Startblock=2;
Process[0].Blocktime=3;
Process[1].Priority=38;
Process[1].Alltime=3;
Process[2].Priority=30;
Process[2].Alltime=6;
Process[3].Priority=29;
Process[3].Alltime=3;
Process[4].Priority=0;
Process[4].Alltime=4;
voidprint（）
if（getRunning（）>
=0）
\tRUNNINGPROG:
%d\n"
getRunning（））;
\tREADY_QUEUE:
"
if（READY[i]>
->
Process[READY[i]].ID）;
else{
break;
}
\n\tBLOCK_QUEUE:
if（BLOCK[i]>
Process[BLOCK[i]].ID）;
\n=====================================================\n"
ID\t"
\t%d"
Process[i].ID）;
\nPRIORITY"
Process[i].Priority）;
\nCPUTIME\t"
Process[i].Cputime）;
\nALLTIME\t"
Process[i].Alltime）;
\nSTARTBLOCK"
Process[i].Startblock）;
\nBLOCKTIME"
Process[i].Blocktime）;
\nSTATE\t"
switch（Process[i].State）{
case0:
printf（"
\tReady"
break;
case1:
\tRun"
if（Process[i].Alltime==0）
{
Process[i].State=RunOut;
}
elseProcess[i].State=Ready;
case2:
\tBlock"
case3:
\tRunOut"
\tRUNOUTLIST:
if（RUNOUT[i][0]>
%d（%d）"
Process[RUNOUT[i][0]].ID,RUNOUT[i][1]）;
intgetRunning（）
if（Process[i].State==Run）
returni;
if（Process[i].Startblock==0）
return-1;
voidsort（）
inti,j,k;
if（Process[i].State==Ready||Process[i].State==Run）{
//Process[i].State=Ready;
continue;
for（j=0;
j<
++j）{
if（READY[j]<
{
READY[j]=i;
break;
}
elseif（Process[i].Priority<
=Process[READY[j]].Priority）
{continue;
else{
for（k=N-1;
k>
j;
--k）{
READY[k]=READY[k-1];
}
elseif（Process[i].State==Block）{
if（BLOCK[j]<
BLOCK[j]=i;
elseif（Process[i].Blocktime>
=Process[BLOCK[j]].Blocktime）
BLOCK[k]=BLOCK[k-1];
intrun（inttime）
{inti,runNum;
runNum=READY[0];
if（runNum<
0&
&
BLOCK[0]<
0）{
EveryprocessisOVER!
return1;
else{
if（runNum>
=0）{
Process[runNum].Priority-=3;
Process[runNum].Alltime-=1;
Process[runNum].Cputime+=1;
Process[runNum].State=Run;
for（i=0;
if（i!
=runNum）{
if（Process[i].State==Ready）{
Process[i].Priority+=1;
elseif（Process[i].State==Block）{
Process[i].Blocktime-=1;
if（Process[i].Blocktime==0）{
Process[i].State=Ready;
}
if（Process[runNum].Alltime==0）
{for（i=0;
if（RUNOUT[i][0]<
RUNOUT[i][0]=runNum;
RUNOUT[i][1]=time;
break;
elseif（Process[runNum].Startblock>
Process[runNum].Startblock-=1;
if（Process[runNum].Startblock==0）{
Process[runNum].State=Block;
elseif（BLOCK[0]>
if（Process[i].State==Block）{
Process[i].Startblock=-1;
Process[i].Blocktime-=1;
if（Process[i].Blocktime==0）{
Process[i].State=Ready;
实验6使用动态优先权的进程调度算法模拟
进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，将进
升级会员 