Mutex
Expt No: 5 Mutual Exclusion
Date: (Producer
Consumer Problem)
Aim:
To demonstrate mutual exclusion using mutex in Producer Consumer application.
Program :
// Producer Consumer Problem
#include
<pthread.h>
#include
<stdio.h>
#include
<stdlib.h>
#include
</usr/include/semaphore.h>
#include
<unistd.h> // for sleep
#define
BUFSIZE 5 /* total number of
slots */
#define
NP 1 /* total number of producers */
#define
NC 1 /* total number of consumers */
#define
NITEMS 5 /* number of items produced/consumed */
typedef
struct
{
int buf[BUFSIZE]; /* shared var */
int in; /*
buf[in%BUFSIZE] – first empty slot */
int out; /*
buf[out%BUFSIZE] – first full slot */
sem_t full; /*
keep track of number of full spots */
sem_t empty; /*
keep track of number of empty spots */
/* enforce mutual exclusion to shared data
*/
pthread_mutex_t mutex;
}
sbuf_t;
sbuf_t
shared;
void
*Producer(void *arg)
{
int i, item;
for (i=1; i <=NITEMS; i++)
{
item = i; /* Produce item */
/* Prepare to write item to buf */
/* If there are no empty slots, wait */
sem_wait(&shared.empty);
/* If another thread uses the buffer,
wait */
pthread_mutex_lock(&shared.mutex);
shared.buf[shared.in] = item;
shared.in = (shared.in+1)%BUFSIZE;
printf("Produced : %d\n",
item);
fflush(stdout);
/* Release the buffer */
pthread_mutex_unlock(&shared.mutex);
/* Increment the number of full slots */
sem_post(&shared.full);
/* Interleave producer and consumer execution */
sleep(1);
}
return NULL;
}
void
*Consumer(void *arg)
{
int
i, item;
for
(i=NITEMS; i > 0; i--)
{
sem_wait(&shared.full);
pthread_mutex_lock(&shared.mutex);
item=i;
item=shared.buf[shared.out];
shared.out
= (shared.out+1)%BUFSIZE;
printf("\tConsumed
: %d\n", item);
fflush(stdout);
/*
Release the buffer */
pthread_mutex_unlock(&shared.mutex);
/*
Increment the number of full slots */
sem_post(&shared.empty);
/*
Interleave producer and consumer
execution */
sleep(1);
}
return
NULL;
}
int
main()
{
pthread_t
idP, idC;
sem_init(&shared.full,
0, 0);
sem_init(&shared.empty,
0, BUFSIZE);
pthread_mutex_init(&shared.mutex,
NULL);
/*
Create a new producer */
pthread_create(&idP,
NULL, Producer, (void*)NP);
/*create
a new Consumer*/
pthread_create(&idC,
NULL, Consumer, (void*)NC);
pthread_exit(NULL);
}
Result:
Thus the program to demonstrate mutual exclusion using mutex was written and
executed.
InterProcess Communication
Expt No: 4 Inter–Process
Communication
Date:
Aim:
To develop application to illustrate Inter Process Communication among
processes using Shared memory, Pipes and Message Queue.
Program :
// 1. IPC Using Shared Memory –
Server Program
#include
<sys/shm.h>
#include
<stdio.h>
#include
<stdlib.h>
#include
<string.h>
#define
MAXSIZE 128
void
die(char *s) {
perror(s);
exit(1);
}
int
main() {
int shmid;
key_t key;
char *shm;
key = 5678;
if ((shmid = shmget(key, MAXSIZE, IPC_CREAT | 0666)) < 0)
die("shmget");
if ((shm = shmat(shmid, NULL, 0)) == (char *) -1)
die("shmat");
printf("Enter a message: ");
fgets(shm, MAXSIZE, stdin);
shm[strcspn(shm, "\n")] = 0; // Remove newline character
printf("Message written to shared memory.\n");
exit(0);
}
// 1. IPC Using Shared Memory –
Client Program
#include
<sys/shm.h>
#include
<stdio.h>
#include
<stdlib.h>
#define
MAXSIZE 27
void
die(char *s)
{
perror(s);
exit(1);
}
int
main()
{
int shmid;
key_t key;
char *shm, *s;
key = 5678;
if ((shmid = shmget(key, MAXSIZE, 0666)) < 0)
die("shmget");
if ((shm = shmat(shmid, NULL, 0)) == (char *) -1)
die("shmat");
printf("\nMessage read from shared memory - ");
for (s = shm; *s != '\0'; s++)
putchar(*s);
putchar('\n');
exit(0);
}
// 2. IPC Using Message Queue
// Sender Program
#include
<sys/msg.h>
#include
<stdio.h>
#include
<string.h>
#include
<stdlib.h>
#define
MAXSIZE 128
struct
msgbuf {
long mtype;
char mtext[MAXSIZE];
};
int
main() {
int msqid;
key_t key = 1234;
struct msgbuf sbuf;
size_t buflen;
if ((msqid = msgget(key, IPC_CREAT | 0666))
< 0) {
perror("msgget");
exit(1);
}
sbuf.mtype = 1;
printf("Enter a message: ");
fgets(sbuf.mtext, MAXSIZE, stdin);
buflen = strlen(sbuf.mtext) + 1;
if (msgsnd(msqid, &sbuf, buflen,
IPC_NOWAIT) < 0) {
perror("msgsnd");
exit(1);
}
printf("Message Sent\n");
return 0;
}
// 2. IPC Using Message Queue
// Receiver Program
#include
<sys/msg.h>
#include
<stdio.h>
#include
<stdlib.h>
#define
MSGSZ 128
struct
msgbuf {
long mtype;
char mtext[MSGSZ];
};
int
main() {
int msqid;
key_t key = 1234;
struct msgbuf rbuf;
if ((msqid = msgget(key, 0666)) < 0) {
perror("msgget");
exit(1);
}
if (msgrcv(msqid, &rbuf, MSGSZ, 1, 0)
< 0) {
perror("msgrcv");
exit(1);
}
printf("Received Message: %s\n",
rbuf.mtext);
return 0;
}
// 3. IPC Using Pipes
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/wait.h>
int
main()
{
int p1[2], p2[2];
char str[25];
printf("\nIPC USING PIPES\n");
printf("Enter Message to send :
");
scanf("%s",str);
pipe(p1);
pipe(p2);
write(p1[1],str,sizeof(str));
int a=fork();
if(a==0)
{
printf("\n Child Process :");
printf("\n Child process pid=%d
", getpid());
printf("\n Parent process pid=%d
", getppid());
read(p1[0],str,sizeof(str));
printf("\n\tMessage received from
Parent process : %s\n",str);
write(p2[1],str,sizeof(str));
}
else
{
wait(NULL);
printf("\n Parent Process :");
printf("\n Parent process pid=%d
", getpid());
read(p2[0],str,sizeof(str));
printf("\n\tMessage returned from
Child process : %s\n\n",str);
}
}
Result:
Thus the programs to demonstrate Inter Process Communication among processes
using Shared memory, Message Queue and Pipes were written and executed.
Subscribe to:
Comments (Atom)