东秦操作系统实验报告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个时间片后,将进