鸿胤操作系统Linux.docx
《鸿胤操作系统Linux.docx》由会员分享,可在线阅读,更多相关《鸿胤操作系统Linux.docx(51页珍藏版)》请在冰豆网上搜索。
![鸿胤操作系统Linux.docx](https://file1.bdocx.com/fileroot1/2023-3/30/fc275f3d-1c5c-4f09-b2a3-ae1ce3315b15/fc275f3d-1c5c-4f09-b2a3-ae1ce3315b151.gif)
鸿胤操作系统Linux
《操作系统课外作业》
【实验题目】1.熟悉Linux/UNIX操作系统
【实验目的】1.熟悉Linux/UNIX操作系统的基本操作;
2.掌握常用基本命令和系统调用。
【实验内容】1.学会开机、退出、登陆与关机;
2.了解窗口工作方式与中断工作方式;
3.熟悉常用命令和系统调用列表;
4.熟悉外存目录树结构;
5.熟悉程序开发工具:
编辑、编译、连接、调试;
6.学会获得帮助信息。
代码:
#include
intmain(){
printf("HelloWorld\n");
return0;
}
【实验结果】
【实验题目】2进程的创建和控制
【实验目的】1.加深对进程概念的理解,明确进程和程序的区别;
2.进一步认识并发执行的实质;
3.加深对进程管理概念的理解;
4.分析进程的创建过程。
【实验内容】1.进程的创建;
2.进程的控制。
【实验结果】
#include
main()
{
intp1,p2;
while((pl=fork())==-1);/*创建子进程p1*/
if(pl==0)/*子进程创建成功*/
putchar(‘b’);
else
{
while((p2=fork())==-1);/*创建另一个子进程*/
if(p2==0)/*子进程创建成功*/
putchar(‘c’);
elseputchar(‘a’);/*父进程执行*/
}
}
#include
main()
{
intp1,p2,i;
while((pl=fork())==-1);
if(pl==0)
{
lockf(1,1,0),
for(i=0;i<500;i++)printf((“child%d/n”,i);
lockf(1,0,0);
}
else
{
while((p2=fork())==-1);
if(p2==0)
{
lockf(1,1,0);
for(i=0;i<500;i++)printf(“son%d\n”,i);
lockf(1,0,0);
}
else
{
lockf(1,1,0);
for(i=0;i<500;i++)printf(“daughter%d\n”,i);
lockf(1,0,0);
}
}
}
【实验题目】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)分别为忽略Del键信号以及忽略中断信号。
【实验结果】
#include
#include
#include
voidwaiting(),stop();
intwait_mark;
main()
{
intpl,p2,stdout;
while((p1=fork())==-1);/*创建进程p1*/
if(p1>0)
{
while((p2=fork())==-1);
if(p2>0)
{
wait_mark=1;
signal(SIGINT,stop);/*接收Del信号,并转stop*/
waiting(0);
kill(p1,16);/*向p1发中断信号16*/
kill(p2,17);/*向p2发中断信号17*/
wait(0);/*同步*/
wait(0);
printf(“parentprocessiskilled!
\n”)
exit(0);
}
else
{
wait_mark=1;
signal(SIGINT,SIG_IGN);********
signal(17,stop);
printf(“%d”,SIG_DFL);
waiting();
lockf(stdout,1,0);
printf(“childprocess2iskilledbyparent!
\n”);
lockf(stdout,0,0);
exit(0);
}
}
else
{
wait_mark=l;
signal(SIGINT,SIG_IGN);********
signal(16,stop);
printf(%d”,SIG_DEL);
waiting();
lockf(stdout,1,0);
printf("childprocess1iskilledbyparent!
\n”);
1ockf(stdout,0,0);
exit(0);
}
}
voidwaiting()
{
while(wait_mark!
=0);
}
voidstop()
{
wait_mark=0;
}
2.在上面的程序中增加语句signal(SIGINT,SIG_IGN)和signal(SIGQUIT,SIG_IGN),观察执行结果,并分析原因。
这里,signal(SIGINT,SIG_IGN)和signal(SIGQUIT,SIG_IGN)分别为忽略Del键信号以及忽略中断信号。
【实验结果】
源代码:
<任务2程序>
#include
#includc
#include
intpid1,pid2;
intEndFlag=0;
pf1=0;
pf2=0;
voidIntDelete()
{
kill(pidl,16);
kill(pid2,17);
EndFlag=1;
}
voidIntl()
{
printf(“childprocessliskilled!
byparent\n”);
exit(0);
}
voidInt2()
{
printf(“childprocess2iskilled!
byparent\n”);
exit(0);
}
main()
{
intexitpid;
signal(SIGINT,SIG_IGN);
signal(SIGQUIT,SIG_IGN);
while((pid1=fork())=-1);
if(pid=0)
{
signal(SIGUSRl,Intl);
signal(SIGINT,SIG_IGN);
pause();
exit(0);
}
else
{
while((pid=fork())=-1);
if(pid2=0)
{
signal(SIGUSRl,Intl);
signal(SIGINT,SIG_IGN);
pause();
exit(0);
}
else
{
signal(SIGINT,IntDelete);
waitpid(-1,&exitcode,0);
printf(“parentprocessiskilled\n”);
exit(0);
}
}
}
【实验题目】4进程的管道通信
【实验目的】1.了解系统调用pipe()的功能;
2.掌握进程的管道通信的实现;
3.进一步理解进程通信的基本原理。
【实验内容】编制一段程序,实现进程的管道通信。
使用系统调用pipe()建立一条管道线;两个子进程P1和P2分别向管道各写一句话
Child1issendingamessage!
Child2issendingamessage!
而父进程则从管道中读出来自于两个子进程的信息,显示在屏幕上。
要求父进程先接收子进程P1发来的消息,然后再接收子进程P2发来的消息。
【实验结果】
<程序>
#include
#include
#include
intpidl,pid2;
main()
{
intfd[2];
charOutPipe[l00],InPipe[l00];
pipe(fd);
while((pidl=fork())==-1);
if(pidl==0)
{
lockf(fd[1],1,0);
sprintf(OutPipe,“child1processissendingmessage!
”);
write(fd[1],OutPipe,50);
sleep(5);
lockf(fd[1],0,0);
exit(0);
}
else
{
while((pid2=fork())==-1);
if(pid2==0)
{
1ockf(fd[1],1,0);
sprintf(OutPipe,“child2processissendingmessage!
“);
write(fd[1],OutPipe,50);
sleep(5);
lockf(fd[l],0,0);
exit(0);
}
else
{
wait(0);
read(fd[0],InPipe,50);
printf(“%s\n”,InPipe);
wait(0);
read(fd[0],InPipe,50);
printf(“%s\n”,InPipe);
exit(0);
}
}
}
【实验题目】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();
printf("Time:
%d\n",Time);
sort();
print();
while
(1){
Time++;
getchar();
printf("Time:
%d\n",Time);
if(run(Time))
break;
//sort();
}
//print(Time);
return0;
}
voidinit()
{
inti;
//printf("Inputpropertiesof%dprocess(PRIORITY,ALLTIME,STARTBLOCK,BLOCKTIME):
\n",
//N);
for(i=0;iREADY[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;
/*printf("Number%d:
",i);
scanf("%d,%d,%d,%d",&Process[i].Priority,&Process[i].Alltime,
&Process[i].Startblock,&Process[i].Blocktime);
*/
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()
{
inti;
if(getRunning()>=0)
printf("\tRUNNINGPROG:
%d\n",getRunning());
printf("\tREADY_QUEUE:
");
for(i=0;iif(READY[i]>=0)
printf("->%d",Process[READY[i]].ID);
else{
break;
}
}
printf("\n\tBLOCK_QUEUE:
");
for(i=0;iif(BLOCK[i]>=0)
printf("->%d",Process[BLOCK[i]].ID);
else{
break;
}
}
printf("\n=====================================================\n");
printf("ID\t");
for(i=0;iprintf("\t%d",Process[i].ID);
}
printf("\nPRIORITY");
for(i=0;iprintf("\t%d",Process[i].Priority);
}
printf("\nCPUTIME\t");
for(i=0;iprintf("\t%d",Process[i].Cputime);
}
printf("\nALLTIME\t");
for(i=0;iprintf("\t%d",Process[i].Alltime);
}
printf("\nSTARTBLOCK");
for(i=0;iprintf("\t%d",Process[i].Startblock);
}
printf("\nBLOCKTIME");
for(i=0;iprintf("\t%d",Process[i].Blocktime);
}
printf("\nSTATE\t");
for(i=0;iswitch(Process[i].State){
case0:
printf("\tReady");break;
case1:
printf("\tRun");
if(Process[i].Alltime==0)
{
Process[i].State=RunOut;
}
elseProcess[i].State=Ready;
break;
case2:
printf("\tBlock");break;
case3:
printf("\tRunOut");break;
}
}
printf("\n");
printf("\tRUNOUTLIST:
");
for(i=0;iif(RUNOUT[i][0]>=0)
printf("->%d(%d)",Process[RUNOUT[i][0]].ID,RUNOUT[i][1]);
else{
printf("\n");
break;
}
}
printf("\n");
}
intgetRunning()
{
inti;
for(i=0;iif(Process[i].State==Run)
returni;
}
for(i=0;iif(Process[i].Startblock==0)
returni;
}
return-1;
}
voidsort()
{
inti,j,k;
for(i=0;iREADY[i]=-1;
BLOCK[i]=-1;
}
for(i=0;iif(Process[i].State==Ready||Process[i].State==Run){
//Process[i].State=Ready;
if(Process[i].Alltime==0)
continue;
for(j=0;jif(READY[j]<0)
{
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];
}
READY[j]=i;
break;
}
}
}
elseif(Process[i].State==Block){
for(j=0;jif(BLOCK[j]<0)
{
BLOCK[j]=i;
break;
}
elseif(Process[i].Blocktime>=Process[BLOCK[j]].Blocktime)
{
continue;
}
else{
for(k=N-1;k>j;--k){
BLOCK[k]=BLOCK[k-1];
}
BLOCK[j]=i;
break;
}
}
}
}
}
intrun(inttime)
{
inti,runNum;
runNum=READY[0];
if(runNum<0&&BLOCK[0]<0){
printf("EveryprocessisOVER!
\n"