IPC USING SHARED MEMORY

#include<sys/ipc.h>
#include<sys/shm.h>
#define SHMKEY 75
#define k 1024
int shmid;
main()
{
int i,*pint;
char *adr1,*adr2;
extern cleanup();
for(i=0;i<10;i++)
signal(i,cleanup);
shmid=shmget(SHMKEY,128*k,0777|IPC_CREAT);
adr1=shmat(shmid,0,0);
adr2=shmat(shmid,0,0);
printf("\n Address 1 0x%x \n Address 2 0x%x \n",&adr1,&adr2);
if(fork()==0)
{
printf("\nIn child");
pint=(int *)adr1;
for(i=0;i<11;i+=2)
*pint++=i;
}
else
{
wait(1);
printf("\tIn Parent\n");
pint=(int *)adr2;
for(i=0;i<5;i++)
printf("\n Index %d \tValue %d \t Address 0x%x\n",i,*pint,pint++);
pause();
}
}
cleanup()
{
shmctl(shmid,IPC_RMID,0);

}

IPC USING MESSAGE

#include<stdio.h>
#include<sys/types.h>
#include<sys/msg.h>
#include<sys/ipc.h>
#include<string.h>
struct que_structure
{
long num;
char msg[100];
};
int err_sys(char s[])
{
perror(s);exit(1);
}
int makque(int n)
{
int qid;
if((qid==msgget((key_t)n,IPC_CREAT|0666))<0)
err_sys("\nQueue failed\n");
return(qid);
}
int name_to_num(char name[])
{
int x=1,s=0,i;
for(i=0;i<strlen(name);i++)
{
s+=x*(toascii(name[i]));
x*=10;
}
return(s);
}
int send(int qid,char name[])
{
struct que_structure que;
que.num=name_to_num(name);
printf("\n Enter the message :");
scanf("%s",que.msg);
if(msgsnd(qid,&que,sizeof(que),0)<0)
err_sys("\n Send error");
else
printf("\n Message sent successfully\n ");
}
int receive(int qid,char name[])
{
struct que_structure que;
if((msgrcv(qid,&que,sizeof(que),name_to_num(name),0))<0)
err_sys("\n Receive Error");
else
printf("\n Record Message :%s\n",que.msg);
}
main()
{
int i,mid;
char name[20];
mid=makque(46);
printf("1.Send   2.Receive \n");
scanf("%d",&i);
printf("\n Enter name :");
scanf("%s",name);
if(i==1)
send(mid,name);
else if(i==2)
receive(mid,name);
else err_sys("\n Error");
}

OUTPUT

./a.out

1 2 ?

enter name abel

enter message : what deepak(--|--)

message send successfully

1 2 ?

2

enter name abel

  received message : what deepak (--|--)

IPC USING UNNMAED PIPES

#include<sys/types.h>
        #include<stdio.h>
        #include<sys/stat.h>
        #include<unistd.h>
        #include<fcntl.h>
        main()
        {
        int id,desc,i,p[2];
        char buf[50];
pipe(p);
       
        id=fork();
        if(id==0)
        {
        char y[10]="child";
        printf("\n ipc using unnamed pipes (via systemcall)");
        //write(STDOUT_FILENO,y,5);
printf("\n child says");


        i=scanf("%s",buf);
        write(p[1] ,&i,sizeof(int));
        write(p[1],buf,i);
        }
        else
        {
               
                read(p[0],&i,sizeof(int));
                read(p[0],buf,i);
                printf("\n parent says: the data from pipe is:\n");
                write(STDOUT_FILENO,buf,i);
          }
printf("\n");
}                                                    

OUTPUT
./a.out

IPC USING NAMED PIPES

#include<sys/types.h>
#include<stdio.h>
#include<sys/stat.h>
#include<unistd.h>
#include<fcntl.h>
main()
{
int id,desc,i;

char buf[50];

 
mknod("pipe",010777,0);
id=fork();
if(id==0)
{
      desc=open("pipe",O_WRONLY);
printf("\n ipc using named pipes (custom inode)\n");
printf("\n child says:ENTER THE DATA TO PIPE\n ");


i=read(STDIN_FILENO,buf,sizeof(buf));
write(desc ,&i,sizeof(int));
write(desc,buf,i);
}
else
{
desc=open("pipe",O_RDONLY);
read(desc,&i,sizeof(int));
read(desc,buf,i);
printf("\n parent says: the data from pipe is:\n");
write(STDOUT_FILENO,buf,i);
 }
}

READERS WRITERS PROBLEM

//Program to implement readers writers problem
#include<stdio.h>
#include<pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int nreaders=0,writing=0;

void acquire_read_lock()
{
  pthread_mutex_lock(&mutex);
  while(writing)
  pthread_cond_wait(&cond,&mutex);
  ++nreaders;
  pthread_mutex_unlock(&mutex);
}

void release_read_lock()
{
  pthread_mutex_lock(&mutex);
  --nreaders;
  if(nreaders==0)
  pthread_cond_broadcast(&cond);
  pthread_mutex_unlock(&mutex);
}

void acquire_write_lock()
{
  pthread_mutex_lock(&mutex);
  while(writing||nreaders>0)
  pthread_cond_wait(&cond,&mutex);
  writing=1;
  pthread_mutex_unlock(&mutex);
}

void release_write_lock()
{
  pthread_mutex_lock(&mutex);
  writing=0;
  pthread_cond_broadcast(&cond);
  pthread_mutex_unlock(&mutex);
}

void *reader(void *s)
{
  int i;
  while(1)
  {
   acquire_read_lock();
   for(i=0;i<5;i++)
   {
    printf("Reader id %d, count %d\n",(int)s,i);
    sleep(1);
   }
   release_read_lock();
   sched_yield();
  }
}

void *writer(void *s)
{
  int i;
  while(1)
  {
   acquire_write_lock();
   for(i=0;i<5;i++)
   {
    printf("Writer id %d, count %d\n",(int)s,i);
    sleep(1);
   }
   release_write_lock();
   sched_yield();
  }
}

main()
{
  pthread_t t[6];
  pthread_attr_t attr;
  int j;

  pthread_mutex_init(&mutex,0);
  pthread_cond_init(&cond,0);

  for(j=0;j<3;j++)
  pthread_create(&t[j],0,reader,(void*)j);
  for(;j<6;j++)
  pthread_create(&t[j],0,writer,(void*)j);
  while(1);
}

OUTPUT
gcc readerwriter.c -lpthread
./aout

Reader id 0, count 0
Reader id 1, count 0
Reader id 2, count 0
Reader id 0, count 1
Reader id 1, count 1
Reader id 2, count 1
Reader id 0, count 2
Reader id 1, count 2
Reader id 2, count 2
Reader id 0, count 3
Reader id 1, count 3
Reader id 2, count 3
Reader id 0, count 4
Reader id 1, count 4
Reader id 2, count 4
Writer id 4, count 0
Writer id 4, count 1
Writer id 4, count 2
Writer id 4, count 3
Writer id 4, count 4
Writer id 5, count 0
Writer id 5, count 1
Writer id 5, count 2
Writer id 5, count 3

BANKERS ALGORITHM

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
#include<sys/types.h>
#include<sys/stat.h>
#define N 5
#define LEFT (N+n-1)%N
#define RIGHT (n+1)%N
enum{thinking,eating,hungry};
int philstate[N];
sem_t s[N],mutex;
void think(int n)
{ sleep(1);
}
void test(int n)
{
if(philstate[LEFT]!=eating && philstate[RIGHT]!=eating)
{
philstate[n]=eating;
sem_post(s+n);
}
sem_post(&mutex);
}
void getforks(int n)
{
sem_wait(&mutex);
philstate[n]=hungry;
printf("\n PHILOSOPHER %d IS HUNGRY ",n);
sleep(1);
test(n);
sem_post(&mutex);
sem_wait(s+n);
}
void eat(int n)
{
int i;
for(i=0;i<4;i++)
{
printf("\n PHILOSOPHER %d IS EATING",n);
sleep(1);
}
printf("\nPHILOSOPHER %d HAS STOPPED EATING",n);
sleep(1);
}
void putforks(int n)
{
sem_wait(&mutex);
philstate[n]=thinking;
printf("\n PHILOSOPHER  %d IS THINKING.",n);
sleep(1);
test(LEFT);
test(RIGHT);
sem_post(&mutex);
}
void *phil(void *argc)
{
int p;
p=atoi(argc);
printf("\n PHILOSOPHER %d:\n",p);
while(1)
{
think(p);
getforks(p);
eat(p);
putforks(p);
}
}
main()
{
sem_init(&mutex,0,1);
int i;
for(i=0;i<5;i++)
sem_init(&s[i],0,0);
pthread_t t1,t2,t3,t4,t5;
pthread_create(&t1,0,phil,"0");
pthread_create(&t2,0,phil,"1");
pthread_create(&t3,0,phil,"2");
pthread_create(&t4,0,phil,"3");
pthread_create(&t5,0,phil,"4");
while(1);
}

OUTPUT

./a.out

DINING PHILOSOPHERS PROBLEM

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
#include<sys/types.h>
#include<sys/stat.h>
#define N 5
#define LEFT (N+n-1)%N
#define RIGHT (n+1)%N
enum{thinking,eating,hungry};
int philstate[N];
sem_t s[N],mutex;
void think(int n)
{ sleep(1);
}
void test(int n)
{
if(philstate[LEFT]!=eating && philstate[RIGHT]!=eating)
{
philstate[n]=eating;
sem_post(s+n);
}
sem_post(&mutex);
}
void getforks(int n)
{
sem_wait(&mutex);
philstate[n]=hungry;
printf("\n PHILOSOPHER %d IS HUNGRY ",n);
sleep(1);
test(n);
sem_post(&mutex);
sem_wait(s+n);
}
void eat(int n)
{
int i;
for(i=0;i<4;i++)
{
printf("\n PHILOSOPHER %d IS EATING",n);
sleep(1);
}
printf("\nPHILOSOPHER %d HAS STOPPED EATING",n);
sleep(1);
}
void putforks(int n)
{
sem_wait(&mutex);
philstate[n]=thinking;
printf("\n PHILOSOPHER  %d IS THINKING.",n);
sleep(1);
test(LEFT);
test(RIGHT);
sem_post(&mutex);
}
void *phil(void *argc)
{
int p;
p=atoi(argc);
printf("\n PHILOSOPHER %d:\n",p);
while(1)
{
think(p);
getforks(p);
eat(p);
putforks(p);
}
}
main()
{
sem_init(&mutex,0,1);
int i;
for(i=0;i<5;i++)
sem_init(&s[i],0,0);
pthread_t t1,t2,t3,t4,t5;
pthread_create(&t1,0,phil,"0");
pthread_create(&t2,0,phil,"1");
pthread_create(&t3,0,phil,"2");
pthread_create(&t4,0,phil,"3");
pthread_create(&t5,0,phil,"4");
while(1);
}

OUTPUT

./a.out