Experiment # 9: Familiarize Semaphore Operation
AIM: To write a program in C to illustrate basic Semaphore operation.
THEORY:
A semaphore is a protected variable or abstract data type that constitutes a
classic method of controlling access by multiple processes to a common resource
in a parallel programming environment. A semaphore generally takes one of two
forms: binary and counting. A binary semaphore (flag) is a simple "true/false"
(locked/unlocked) variable that controls access to a single resource. A counting
semaphore is a counter for a set of resources. Either type may be employed to
prevent a race condition. On the other hand, a semaphore is of no value in
preventing resource deadlock, such as illustrated by the dining philosophers
problem.
A semaphore is an integer variable with two atomic operations wait and signal.
Other names for wait are down, P and lock. Other names for signal are up, V,
unlock and post.Main use of semaphores is to synchronize the access to shared
memory segments
int semget(key_t, int nsems, int semflag);
A semaphore is created or an existing semaphore is accessed with semget
system call.The value returned by semget is the semaphore identifier, semid or
1 if an error occurred.nsems argument specifies the number of semaphores in
the set.If we are not creating
a new semaphore set, but only accessing an
existing set then we can specify semflag argument as zero instead of ipc_creat.
int semop(int semid,struct sembuf **opsptr, unsigned int nops);
once the semaphore set is opened with semget, operations are performed on
one or more of the semaphore values in the set by using semop system call
To lock the semaphore we call semop to do two operations atomically
1)wait for semaphore value to become zero
2)increment the value to one
static struct sembuf op-lock[2]=
{
0, 0, 0, /*wait for sem#0 to become 0*/
0, 1, 0 /*then increment sem#0 by 1*/
};
To unlock the resource , we call semop to decrement the semaphore value
Static struct sembuf op-unlock[1]=
{
0, -1, IPC-NOWAIT /*decrement sem#0 by 1
(sets it to 0)*/
};
Fig: Basic Semaphore Operations
REQUIREMENTS:
HARDWARE
SOFTWARE
: PIII Processor , 128 MB RAM, 10GB
: OS: LINUX
ALGORITHM:
STEP 1: Create sembuf structures for locking and unlocking
STEP 2: Create a semaphore using semget() system call
STEP 3: Now first perform the lock operation and then unlock it
Familiarize Semaphore Operation
// File 1: smop.h
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#define SEMKEY 1234L
#define PERMS 0666
static struct sembuf lock0[2]=
{
0,0,0,
0,1,0
};
static struct sembuf unlock0[1]=
{
0,-1,IPC_NOWAIT
};
static struct sembuf lock1[2]=
{
1,0,0,
1,1,0
};
static struct sembuf unlock1[2]=
{
1,-1,IPC_NOWAIT
};
static struct sembuf lock2[2]=
{
2,0,0,
2,1,0
};
static struct sembuf unlock2[1]=
{
2,-1,IPC_NOWAIT
};
int semlock0(int semid)
{
semop(semid,&lock0[0],2);
}
int semunlock0(int semid)
{
semop(semid,&unlock0[0],1);
}
int semlock1(int semid)
{
semop(semid,&lock1[0],2);
}
int semunlock1(int semid)
{
semop(semid,&unlock1[0],1);
}
int semlock2(int semid)
{
semop(semid,&lock2[0],2);
}
int semunlock2(int semid)
{
semop(semid,&unlock2[0],1);
}Familiarize
Semaphore Operation
PROGRAM:
#include "smop.h"
#include<stdio.h>
main()
{
int semid;
char res;
semid=semget(SEMKEY,1,IPC_CREAT | PERMS);
semunlock0(semid);
printf("\nlocked");
printf("\ndo u want to unlock?(Y/N)");
res=getchar();
semunlock0(semid);
printf("\nunlocked\n");
}
RESULT: A Program using C to illustrate semaphore operations is executed
successfully.
Experiment #9(a): IMPLEMENTATION OF DINING
PHILOSOPHER PROBLEM USING SEMAPHORES.
AIM:
To write a c program to Implement Dining Philosopher Problem Using
Semaphores
THEORY:
The dining-philosophers problem is considered a classic synchronization
problem, because it is an example for a large class of concurrency-control
problems. It is a simple representation of the need to allocate several
resources among several processes in a deadlock and starvation free manner.
One simple solution is to represent each chopstick by a semaphore. A
philosopher
Tries to grab the chopstick by executing a wait operation on that semaphore;
she releases her chopstick by executing the signal operation on the
appropriate semaphores. Thus the shared data are
var chopstick: array[0..4] of semaphore
where all the elements of the chopstick are initialized to 1.The structure of
philosopher i is shown below.
repeat
Wait(chopstick[i]);
Wait(chopstick[i+1 mod 5]);
eat
signal(chopstick[i]);
signal(chopstick[i+1 mod 5]]);
think
until false;
figure illustrating dining philosophers problem
REQUIREMENTS:
HARDWARE
: PIII Processor , 128 MB RAM, 10GB
SOFTWARE
: OS: LINUX
PROGRAM:
#include <stdio.h>
#include "smop.h"
main()
{
int pno, semid,tmp;
semid=semget(SEMKEY,3,PERMS|IPC_CREAT);
printf("\n\t\tEnter Philosopher Number(0-2): ");
scanf("%d",&pno);
switch(pno)
{
case 0: printf("\n\n\tPhilosopher %d thinking...",pno);
printf("\n\tEnter 0 to start eating ...");
scanf("%d",&tmp);
semlock0(semid);
semlock1(semid);
printf("\n\n\tPhilosopher %d eating...",pno);
printf("\n\tPress 1 to stop eating ...");
scanf("%d",&tmp);
semunlock0(semid);
semunlock1(semid);
printf("\n\n\tPhilosopher %d thinking...",pno);
break;
case 1: printf("\n\n\tPhilosopher %d thinking...",pno);
printf("\n\tEnter 0 to start eating ...");
scanf("%d",&tmp);
semlock1(semid);
semlock2(semid);
printf("\n\n\tPhilosopher %d eating...",pno);
printf("\n\tPress 1 to stop eating ...");
scanf("%d",&tmp);
semunlock1(semid);
semunlock2(semid);
printf("\n\n\tPhilosopher %d thinking...",pno);
break;
case 2: printf("\n\n\tPhilosopher %d thinking...",pno);
printf("\n\tEnter 0 to start eating ...");
scanf("%d",&tmp);
semlock2(semid);
semlock0(semid);
printf("\n\n\tPhilosopher %d eating...",pno);
printf("\n\tPress 1 to stop eating ...");
scanf("%d",&tmp);
semunlock2(semid);
semunlock0(semid);
printf("\n\n\tPhilosopher %d thinking...",pno);
break;
}
}
RESULT: A program to Implement Dining Philosopher Problem Using Semaphores
in C is executed successfully.
Experiment #9(b): IMPLEMENTATION OF READER WRITER PROBLEM USING SEMAPHORES.
AIM: To write a c program To Implement Reader-Writer Problem Using Semaphores.
THEORY:
A data object such as file or a record is to be shared among several
concurrent processes.Some of the processes may want only to read the
content of the shared object, and are called as readers whereas others may
want to update that is, to read and write and are called as writers
The first readers-writers problem, requires that no reader will be kept
waiting unless a writer has already obtained permission to use the shared
object.The second readers-writers problem requires that, once a writer is
ready that writer performs its write as soon as possible
Figure illustrating readers writers problem
The structure of a writer process
wait(wrt);
writing is performed
signal(wrt);
The structure of a reader process
wait(mutex);
readcount=readcount+1;
if readcount=1 then wait(wrt);
signal(mutex);
reading is performed
wait(mutex);
readcount:=readcount-1;
if(readcount=0 then signal(wrt);
signal(mutex);
REQUIREMENTS:
HARDWARE
SOFTWARE
: PIII Processor , 128 MB RAM, 10GB
: OS: LINUX
PROGRAM:
// File 1: smop.h
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#define SEMKEY 223010L
#define PERMS 0666
static struct sembuf lock0[2]=
{
0,0,0,
0,1,0
};
static struct sembuf unlock0[1]=
{
0,-1,IPC_NOWAIT
};
static struct sembuf lock1[2]=
{
1,0,0,
1,1,0
};
static struct sembuf unlock1[1]=
{
1,-1,IPC_NOWAIT
};
static struct sembuf lock2[2]=
{
2,0,0,
2,1,0
};
static struct sembuf unlock2[1]=
{
2,-1,IPC_NOWAIT
};
int semlock0(int semid)
{
semop(semid,&lock0[0],2);
}
int semunlock0(int semid)
{
semop(semid,&unlock0[0],1);
}
int semlock1(int semid)
{
semop(semid,&lock1[0],2);
}
int semunlock1(int semid)
{
semop(semid,&unlock1[0],1);
}
int semlock2(int semid)
{
semop(semid,&lock2[0],2);
}
int semunlock2(int semid)
{
semop(semid,&unlock2[0],1);
}
/ /File 2: Reader.c
#include <stdio.h>
#include "smop.h"
#define nreaders 2
main()
{
int semid=semget(SEMKEY,2,PERMS|IPC_CREAT);
int rno,tmp;
printf("\n\n\t\tEnter Reader Number : ");
scanf("%d",&rno);
printf("\n\n\t\tPress 0 to start reading: ");
scanf("%d",&tmp);
switch(rno)
{
case 0: semlock0(semid);
break;
case 1: semlock1(semid);
break;
}
printf("\n\n\t\t%d Reader reading.....",rno);
printf("\n\t\tEnter 1 to stop reading");
scanf("%d",&tmp);
switch(rno)
{
case 0: semunlock0(semid);
break;
case 1: semunlock1(semid);
break;
}
}
/ /File 3: Writer.c
#include <stdio.h>
#include "smop.h"
main()
{
int semid=semget(SEMKEY,2,PERMS|IPC_CREAT);
int tmp;
printf("\n\n\t\tEnter 0 to start writing : ");
scanf("%d",&tmp);
semlock0(semid);
semlock1(semid);
printf("\n\n\t\t Writer writing.....");
printf("\n\t\tEnter 1 to stop writing: ");
scanf("%d",&tmp);
semunlock0(semid);
semunlock1(semid);
}
RESULT: A program in c to implement readers writers problem using
semaphores is implemented successfully.
