PROGRAM: Dinning Philosopher

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>

#include<sys/ipc.h>

#include<sys/sem.h>

#include<signal.h>

int sem_wait(int,int);

int sem_signal(int,int);

void cleanup();

void philosopher(int i);

int semid;

main()

unsigned short int s=1;

signal(SIGINT,cleanup);

semid=semget((key_t)48,5,IPC_CREAT|0600);

semctl(semid,0,SETVAL,s);

semctl(semid,1,SETVAL,s);

semctl(semid,2,SETVAL,s);

semctl(semid,3,SETVAL,s);

semctl(semid,4,SETVAL,s);

int pid=fork();

if(pid==0)

philosopher(0);
else

pid=fork();

if(pid==0)

philosopher(1);

else

pid=fork();

if(pid==0)

philosopher(2);

else

pid=fork();

if(pid==0)

philosopher(3);

else

philosopher(4);

void philosopher(int i)

printf("\nphilosopher %d is hungry\n",i);

sem_wait(semid,i);
sem_wait(semid,(i+1)%5);

printf("\nphilosopher %d is eating\n",i);

sleep(rand()%10);

sem_signal(semid,i);

sem_signal(semid,(i+1)%5);

printf("\nphilosopher %d is thinking\n",i);

int sem_signal(int semid,int semname)

struct sembuf op;

op.sem_num=semname;

op.sem_op=1;

op.sem_flg=0;

return semop(semid,&op,1);

int sem_wait(int semid,int semname)

struct sembuf op;

op.sem_num=semname;

op.sem_op=-1;

op.sem_flg=0;

return semop(semid,&op,1);

void cleanup()

{
semctl(semid,5,IPC_RMID,0);

exit(0);

Producer Consumer Problem

#include<stdio.h>
#include<stdlib.h>

int mutex=1,full=0,empty=3,x=0;

int main()
{
int n;
void producer();
void consumer();
int wait(int);
int signal(int);
printf("\n1.Producer\n2.Consumer\n3.Exit");
while(1)
{
printf("\nEnter your choice:");
scanf("%d",&n);
switch(n)
{
case 1: if((mutex==1)&&(empty!=0))
producer();
else
printf("Buffer is full!!");
break;
case 2: if((mutex==1)&&(full!=0))
consumer();
else
printf("Buffer is empty!!");
break;
case 3:
exit(0);
break;
}
}

return 0;
}

int wait(int s)
{
return (--s);
}

int signal(int s)
{
return(++s);
}

void producer()
{
mutex=wait(mutex);
full=signal(full);
empty=wait(empty);
x++;
printf("\nProducer produces the item %d",x);
mutex=signal(mutex);
}

void consumer()
{
mutex=wait(mutex);
full=wait(full);
empty=signal(empty);
printf("\nConsumer consumes item %d",x);
x--;
mutex=signal(mutex);
}

Reader Writer Problem

Program:

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>

sem_t mutex,writeblock;
int data = 0,rcount = 0;

void *reader(void *arg)

{
int f;
f = ((int)arg);
 sem_wait(&mutex);
rcount = rcount + 1;
if(rcount==1)
sem_wait(&writeblock);
sem_post(&mutex);
printf("Data read by the reader%d is %d\n",f,data);
sleep(1);
sem_wait(&mutex);
rcount = rcount - 1;
if(rcount==0)
sem_post(&writeblock);
sem_post(&mutex);
}

void *writer(void *arg)

{
int f;
f = ((int) arg);
sem_wait(&writeblock);
data++;
printf("Data writen by the writer%d is %d\n",f,data);
sleep(1);
sem_post(&writeblock);
}

main()
{
int i,b;
pthread_t rtid[5],wtid[5];
sem_init(&mutex,0,1);
sem_init(&writeblock,0,1);
for(i=0;i<=2;i++)
{
pthread_create(&wtid[i],NULL,writer,(void *)i);
pthread_create(&rtid[i],NULL,reader,(void *)i);
}
for(i=0;i<=2;i++)
{
pthread_join(wtid[i],NULL);
pthread_join(rtid[i],NULL);
}
}
Reader Writer Problem2

#include<stdio.h>

#include<pthread.h>

#include<semaphore.h>

sem_t mutex;

sem_t db;

int readercount=0;

pthread_t reader1,reader2,writer1,writer2;

void *reader(void *);

void *writer(void *);

main()

sem_init(&mutex,0,1);

sem_init(&db,0,1);

while(1)

pthread_create(&reader1,NULL,reader,"1");

pthread_create(&reader2,NULL,reader,"2");

pthread_create(&writer1,NULL,writer,"1");

pthread_create(&writer2,NULL,writer,"2");

void *reader(void *p)

{
printf("prevoius value %dn",mutex);

sem_wait(&mutex);

printf("Mutex acquired by reader %dn",mutex);

readercount++;

if(readercount==1) sem_wait(&db);

sem_post(&mutex);

printf("Mutex returned by reader %dn",mutex);

printf("Reader %s is Readingn",p);

//sleep(3);

sem_wait(&mutex);

printf("Reader %s Completed Readingn",p);

readercount--;

if(readercount==0) sem_post(&db);

sem_post(&mutex);

void *writer(void *p)

printf("Writer is Waiting n");

sem_wait(&db);

printf("Writer %s is writingn ",p);

sem_post(&db);

//sleep(2);