Operating System: Semaphor

B.Tech – CS 2nd Year Operating System (KCS- 401) Dr. Pankaj Kumar
Operating System
KCS – 401
Semaphores
Dr. Pankaj Kumar
Associate Professor – CSE
SRMGPC Lucknow

Outline of the Lecture
Semaphore – Introduction
Characteristic of Semaphore
Type of Semaphore

Semaphore
A semaphore is a variable or abstract data type used to control access to a common resource by
multiple processes and avoid critical section problems in a concurrent system such as
a multitasking operating system. A trivial semaphore is a plain variable that is changed (for
example, incremented or decremented, or toggled) depending on programmer-defined conditions.
A semaphore is a variable that indicates the number of resources that are available in a system at
a particular time and this semaphore variable is generally used to achieve the process
synchronization. It is generally denoted by "S".

Semaphore
A semaphore uses two functions i.e. wait() and signal(). Both these functions are used to change
the value of the semaphore but the value can be changed by only one process at a particular time
and no other process should change the value simultaneously.
The wait() function is used to decrement the value of the semaphore variable "S" by one if the
value of the semaphore variable is positive. If the value of the semaphore variable is 0, then no
operation will be performed.
wait(S) {
while (S == 0); //there is ";" sign here S--;
}
The signal() function is used to increment the value of the semaphore variable by one.
signal(S) {
S++;
}

Semaphore
Characteristic of Semaphore
• It is a mechanism that can be used to provide synchronization of tasks.
• It is a low-level synchronization mechanism.
• Semaphore will always hold a non-negative integer value.
• Semaphore can be implemented using test operations and interrupts, which should be executed
using file descriptors.

Semaphore
Types of Semaphore
The two common kinds
• Counting semaphores
• Binary semaphores
Counting Semaphores:
In Counting semaphores, firstly, the semaphore variable is initialized
with the number of resources available. After that, whenever a
process needs some resource, then the wait() function is called and
the value of the semaphore variable is decreased by one. The process
then uses the resource and after using the resource,
the signal() function is called and the value of the semaphore variable
is increased by one.
So, when the value of the semaphore variable goes to 0 i.e all the
resources are taken by the process and there is no resource left to be
used, then if some other process wants to use resources then that
process has to wait for its turn. In this way, we achieve the process
synchronization.

Semaphore
Types of Semaphore
The two common kinds
• Counting semaphores
• Binary semaphores
Binary Semaphores: In Binary semaphores, the value of the
semaphore variable will be 0 or 1. Initially, the value of semaphore
variable is set to 1 and if some process wants to use some resource
then the wait() function is called and the value of the semaphore is
changed to 0 from 1. The process then uses the resource and when it
releases the resource then the signal() function is called and the value
of the semaphore variable is increased to 1.
If at a particular instant of time, the value of the semaphore variable
is 0 and some other process wants to use the same resource then it has
to wait for the release of the resource by the previous process. In this
way, process synchronization can be achieved.

Test and Set Lock
Test and Set Lock (TSL) is a synchronization mechanism.
It uses a test and set instruction to provide the synchronization among the processes executing
concurrently.
It is an instruction that returns the old value of a memory location and sets the memory location
value to 1 as a single atomic operation.
If one process is currently executing a test-and-set, no other process is allowed to begin another
test-and-set until the first process test-and-set is finished.

Test and Set Lock
Initially, lock value is set to 0.
● Lock value = 0 means the critical section
is currently vacant and no process is
present inside it.
● Lock value = 1 means the critical section
is currently occupied and a process is
present inside it.

Semaphore Usage
Consider P1 and P2 that require S1 to happen before S2
Create a semaphore “synch” initialized to 0
P1:
S1;
signal(synch);
do {
wait(mutex):
critical Section
signal(mutex);
Remainder section
}while(1)
P2:
wait(synch);
S2;

Dining-Philosophers Problem
Philosophers spend their lives alternating thinking and eating
Don’t interact with their neighbors, occasionally try to pick up 2
chopsticks (one at a time) to eat from bowl
Need both to eat, then release both when done
In the case of 5 philosophers
Shared data
Bowl of rice (data set)
Semaphore chopstick [5] initialized to 1

Dining-Philosophers Problem
The structure of Philosopher i:
do {
wait (chopstick[i] );
wait (chopStick[ (i + 1) % 5] );
// eat
signal (chopstick[i] );
signal (chopstick[ (i + 1) % 5] );
// think
} while (TRUE);

Bounded buffer Problem
The structure of the producer process
do {
...
/* produce an item in next_produced */
...
wait(empty);
wait(mutex);
...
/* add next produced to the buffer */
...
signal(mutex);
signal(full);
} while (true);

Sleeping Barber problem
Problem : The analogy is based upon a hypothetical
barber shop with one barber. There is a barber shop
which has one barber, one barber chair, and n chairs
for waiting for customers if there are any to sit on the
chair.
•If there is no customer, then the barber sleeps in his
own chair.
•When a customer arrives, he has to wake up the
barber.
•If there are many customers and the barber is cutting
a customer’s hair, then the remaining customers
either wait if there are empty chairs in the waiting
room or they leave if no chairs are empty.

Customer {
while(true) {
sem_wait(accessseats);
if(FreeSeats > 0) {
FreeSeats--; /* sitting down.*/
sem_post(Customers); /* notify the barber. */
sem_post(accesseats); /* release the lock */
sem_wait(Barber); /* wait in the waiting room if barber is
busy. */
// customer is having hair cut
} else {
srm_post(accessSeats); /* release the lock */
// customer leaves } }}
Variables: shared data
Semaphore Customers = 0;
Semaphore Barber = 0; // sleeping
Access Mutex Seats = 1;
int FreeSeats = N;

Barber {
while(true) {
Wait (customers); /* waits for a customer (sleeps). */
wait (mutex); // whenever wait(1) is executed it decrement value 0 ie. mutex to protect the
number of available seats
Numberoffreeseat++ // a chair get free
sem_post(barber) /* bring customer for haircut.*/
sem_post(mutex) /* release the mutex on the chair.*/
/* barber is cutting hair.*/
}
}

Problem in Semaphore
1. One of the biggest limitations of semaphore is priority inversion.
2. Deadlock, suppose a process is trying to wake up another process which is not in a sleep state.
Therefore, a deadlock may block indefinitely.
3. The operating system has to keep track of all calls to wait and to signal the semaphore.
several process may active simultaneously
Signal(mutex);
……
Critical section
……..
Wait(mutex);
Deadlock may occur
wait(mutex);
……
Critical section
……..
wait(mutex);

Critical Region
One of the main problem in semaphore is that semaphore are not syntactically related to the
shared resources that they guard. In particular there are no declaration that could alert the
compiler that a specific data structure is shared and that its accessing needs to be controlled.
Acritical region protects a shared data structure by making its known to it known to the compiler
which can then generate code that maintains mutual exclusive access to the related data. The
declaration of shared variable has the following format:
V: shared : T;
Where the keyword shared informs the compiler that the variable mutes of user deifned type T, is
shared by several person. Process may acess a guarede variable by means of the region construct
as follows:
Region V when B do S;
Statement “do” is executed as a critical section.

Monitor
The monitor is one of the ways to achieve Process
synchronization. The monitor is supported by
programming languages to achieve mutual exclusion
between processes. For example Java Synchronized
methods. Java provides wait() and notify() constructs.
1.It is the collection of condition variables and
procedures combined together in a special kind of
module or a package.
2.The processes running outside the monitor can’t access
the internal variable of the monitor but can call
procedures of the monitor.
3.Only one process at a time can execute code inside
monitors.

Monitor
Key Differences Between Semaphore and Monitor
1. The basic difference between semaphore and monitor is that the semaphore is an integer
variable S which indicate the number of resources available in the system whereas,
the monitor is the abstract data type which allows only one process to execute in critical
section at a time.
2. The value of semaphore can be modified by wait() and signal() operation only. On the other
hand, a monitor has the shared variables and the procedures only through which shared
variables can be accessed by the processes.
3. In Semaphore when a process wants to access shared resources the process performs wait()
operation and block the resources and when it release the resources it performs signal()
operation. In monitors when a process needs to access shared resources, it has to access them
through procedures in monitor.
4. Monitor type has condition variables which semaphore does not have.

Operating System: Semaphor

More Related Content

What's hot (18)

Similar to Operating System: Semaphor (20)

More from Shri Ram Swaroop Memorial College of Engineering & Management (20)

Recently uploaded (20)

Operating System: Semaphor