东北大学 操作系统实验三报告.docx
《东北大学 操作系统实验三报告.docx》由会员分享,可在线阅读,更多相关《东北大学 操作系统实验三报告.docx(14页珍藏版)》请在冰豆网上搜索。
东北大学操作系统实验三报告
操作系统实验报告
班级
物联网1302班
学号
姓名
实验3进程同步和通信-生产者和消费者问题模拟
1.目的:
调试、修改、运行模拟程序,通过形象化的状态显示,使学生理解进程的概念,了解同步和通信的过程,掌握进程通信和同步的机制,特别是利用缓冲区进行同步和通信的过程。
通过补充新功能,使学生能灵活运用相关知识,培养创新能力。
2.内容及要求:
1)调试、运行模拟程序。
2)发现并修改程序中不完善的地方。
3)修改程序,使用随机数控制创建生产者和消费者的过程。
4)在原来程序的基础上,加入缓冲区的写互斥控制功能,模拟多个进程存取一个公共缓冲区,当有进程正在写缓冲区时,其他要访问该缓冲区的进程必须等待,当有进程正在读取缓冲区时,其他要求读取的进程可以访问,而要求写的进程应该等待。
5)完成1)、2)、3)功能的,得基本分,完成4)功能的加2分,有其它功能改进的再加2分
3.程序说明:
本程序是模拟两个进程,生产者(producer)和消费者(Consumer)工作。
生产者每次产生一个数据,送入缓冲区中。
消费者每次从缓冲区中取走一个数据。
缓冲区可以容纳8个数据。
因为缓冲区是有限的,因此当其满了时生产者进程应该等待,而空时,消费者进程应该等待;当生产者向缓冲区放入了一个数据,应唤醒正在等待的消费者进程,同样,当消费者取走一个数据后,应唤醒正在等待的生产者进程。
就是生产者和消费者之间的同步。
每次写入和读出数据时,都将读和写指针加一。
当读写指针同样时,又一起退回起点。
当写指针指向最后时,生产者就等待。
当读指针为零时,再次要读取的消费者也应该等待。
为简单起见,每次产生的数据为0-99的整数,从0开始,顺序递增。
两个进程的调度是通过运行者使用键盘来实现的。
4.程序使用的数据结构
进程控制块:
包括进程名,进程状态和执行次数。
缓冲区:
一个整数数组。
缓冲区说明块:
包括类型,读指针,写指针,读等待指针和写等待指针。
5.程序使用说明
启动程序后,如果使用'p'键则运行一次生产者进程,使用'c'键则运行一次消费者进程。
通过屏幕可以观察到两个进程的状态和缓冲区变化的情况。
6.实验流程图
源程序
#include
#include
#include
#definePIPESIZE8
enumStatus{RUN,WAIT,READY};
#defineNORMAL0
#defineSLEEP1
#defineAWAKE2
structPCB
{
charname[3];
enumStatusstatus;
inttime;
};
structwaitqueue
{
structPCBpcb;
structwaitqueue*next;
};
structPCB*producer;/*writewaitpoint*/
structPCB*consumer;/*readwaitpoint*/
structwaitqueue*headerqueue,*tailqueue;
intwriteptr;
intreadptr;
intwritein,readout;
intbuffer[PIPESIZE];
intempty,full;
voidrunp(charin[3]),runc(charin[3]),print();
intmain()
{
charin[3];
writeptr=0;
readptr=0;
writein=0;
empty=PIPESIZE;
full=0;
producer=(structPCB*)malloc(sizeof(structPCB));
consumer=(structPCB*)malloc(sizeof(structPCB));
headerqueue=(structwaitqueue*)malloc(sizeof(structwaitqueue));
headerqueue->next=NULL;
tailqueue=headerqueue;
producer->status=READY;
consumer->status=WAIT;
producer->time=consumer->time=0;
printf("Nowstartingtheprogram!
\n");
printf("Press'p1'torunPRODUCER1,Press'p1'torunPRODUCER2\n");
printf("Press'c1'torunCONSUMER1,Press'c2'torunCONSUMER2\n");
printf("Press'e'toexitfromtheprogram.\n");
while
(1)
{
strcpy(in,"N");
while(!
strcmp(in,"N"))
{
printf("\n");
scanf("%s",in);
if(strcmp(in,"e")&&strcmp(in,"p1")&&strcmp(in,"p2")&&strcmp(in,"c1")&&strcmp(in,"c2"))
{
printf("error,pleaseinputagain!
!
!
\n");
strcpy(in,"N");
}
}
if('p'==in[0])
{
runp(in);
producer->time++;
}
elseif('c'==in[0])
{
runc(in);
consumer->time++;
}
else
{
//printf("PRODUCERproduct%dtimes\n",producer->time);
//printf("CONSUMERconsumer%dtimes\n",consumer->time);
exit(0);
}
print();
printf("\n");
}
}
voidrunp(charin[3])
{
if(full>=8)
{
structwaitqueue*search;
search=headerqueue->next;
while(search!
=NULL)
{
if(!
strcmp(in,search->pcb.name))
{
printf("error!
!
!
\n");
exit
(1);
}
search=search->next;
}
producer->status=WAIT;
printf("PRODUCER%sprocessiswaiting,can'tbescheduled.\n",in);
structwaitqueue*p=(structwaitqueue*)malloc(sizeof(structwaitqueue));
strcpy(p->pcb.name,in);
p->pcb.status=WAIT;
p->pcb.time=producer->time+1;
p->next=NULL;
tailqueue->next=p;
tailqueue=p;
full++;
}
else
{
writein=(writein+1)%100;
producer->status=RUN;
printf("runPRODUCER%sprocess.product%d",in,writein);
buffer[writeptr]=writein;
if(empty>8)
{
structwaitqueue*p;
p=headerqueue->next;
printf("runCONSUMER%sprocess.use%d",p->pcb.name,buffer[writeptr]);
if(tailqueue==p)
{
tailqueue=headerqueue;
}
headerqueue->next=p->next;
free(p);
consumer->status=WAIT;
empty--;
}
else
{
if(writeptr>readptr)
{
writeptr++;
if(writeptr>=PIPESIZE)
{
writeptr=0;
if(readptr==0)
producer->status=WAIT;
elseproducer->status=READY;
}
}
else
{
writeptr++;
if(writeptr==readptr)
producer->status=WAIT;
elseproducer->status=READY;
}
consumer->status=READY;
empty--;
full++;
}
}
}
voidrunc(charin[3])
{
if(empty>=8)
{
structwaitqueue*search;
search=headerqueue->next;
while(search!
=NULL)
{
if(!
strcmp(in,search->pcb.name))
{
printf("error!
!
!
\n");
exit
(1);
}
search=search->next;
}
consumer->status=WAIT;
printf("CONSUMER%siswaiting,can'tbescheduled.\n",in);
structwaitqueue*p=(structwaitqueue*)malloc(sizeof(structwaitqueue));
strcpy(p->pcb.name,in);
p->pcb.status=WAIT;
p->pcb.time=consumer->time+1;
p->next=NULL;
tailqueue->next=p;
tailqueue=p;
empty++;
}
else
{
consumer->status=RUN;
readout=buffer[readptr];
printf("runCONSUMER%sprocess.use%d",in,readout);
if(full>8)
{
writein=(writein+1)%100;
buffer[writeptr]=writein;
structwaitqueue*p;
p=headerqueue->next;
printf("runPRODUCER%sprocess.product%d",p->pcb.name,buffer[writeptr]);
if(tailqueue==p)
{
tailqueue=headerqueue;
}
headerqueue->next=p->next;
free(p);
producer->status=WAIT;
full--;
writeptr++;
readptr++;
}
else
{
if(readptr>writeptr)
{
readptr++;
if(readptr>=PIPESIZE)
{
readptr=0;
if(writeptr==0)
consumer->status=WAIT;
else
consumer->status=READY;
}
elseconsumer->status=READY;
}
else
{
readptr++;
if(readptr==writeptr)
{
consumer->status=WAIT;
writeptr=readptr=0;
}
elseconsumer->status=READY;
producer->status=READY;
}
full--;
empty++;
}
}
}
voidprint()
{
inti=0;
intj=0;
intlow=0;
inthigh=0;
printf("\n");
for(i;iprintf("--------");
printf("\n");
if(readptr{
for(low=0;lowprintf("||");
for(low=readptr;low{
printf("|%2d|",buffer[low]);
}
for(low=writeptr;lowprintf("||");
}
elseif(readptr>writeptr)
{
for(low=0;lowprintf("|%2d|",buffer[low]);
for(low=writeptr;lowprintf("||");
for(low=readptr;low{
printf("|%2d|",buffer[low]);
}
}
elseif(producer->status==WAIT)
{
for(low=0;low{
printf("|%2d|",buffer[low]);
}
}
else
{
for(low=0;low{
printf("||");
}
}
printf("\n");
for(i=0;iprintf("--------");
printf("\n");
if(producer->status==WAIT&&NULL!
=headerqueue->next)
{
structwaitqueue*p=headerqueue->next;
while(NULL!
=p)
{
printf("PRODUCER%sprocessarewaitting\n",p->pcb.name);
p=p->next;
}
}
else
printf("PRODUCERready\n");
if(consumer->status==WAIT&&headerqueue->next)
{
structwaitqueue*p=headerqueue->next;
while(NULL!
=p)
{
printf("CONSUMER%sprocessarewaitting\n",p->pcb.name);
p=p->next;
}
}
else
printf("CONSUMERready\n");
}
实验结果: