In 1965, Dijkstra proposed a new and very significant technique for managing concurrent processes by using the value of a simple integer variable to synchronize the progress of interacting processes. This integer variable is called semaphore. So it is basically a synchronizing tool and is accessed only through two low standard atomic operations, wait and signal designated by P() and V() respectively. The classical definition of wait and signal are : Wait : decrement the value of its argument S as soon as it would become non-negative. Signal : increment the value of its argument, S as an individual operation.

1. Operating System 27
Semaphores
Prof Neeraj Bhargava
Vaibhav Khanna
Department of Computer Science
School of Engineering and Systems Sciences
Maharshi Dayanand Saraswati University Ajmer

2. Process Synchronization
• Process Synchronization means sharing system resources by
processes in a such a way that, Concurrent access to shared
data is handled thereby minimizing the chance of inconsistent
data.
• Maintaining data consistency demands mechanisms to
ensure synchronized execution of cooperating processes.
• Process Synchronization was introduced to handle problems
that arose while multiple process executions.

3. Critical Section Problem
• A Critical Section is a code segment that accesses
shared variables and has to be executed as an atomic
action.
• It means that in a group of cooperating processes, at a
given point of time, only one process must be executing
its critical section.
• If any other process also wants to execute its critical
section, it must wait until the first one finishes.

4. Critical Section Problem

5. Solution to Critical Section Problem
• A solution to the critical section problem must satisfy the following three
conditions :
• Mutual Exclusion Out of a group of cooperating processes, only one
process can be in its critical section at a given point of time.
• Progress If no process is in its critical section, and if one or more threads
want to execute their critical section then any one of these threads must be
allowed to get into its critical section.
• Bounded Waiting After a process makes a request for getting into its
critical section, there is a limit for how many other processes can get into
their critical section, before this process's request is granted.
• So after the limit is reached, system must grant the process permission to
get into its critical section.

6. Synchronization Hardware
• Many systems provide hardware support for critical section code. The critical
section problem could be solved easily in a single-processor environment if we
could disallow interrupts to occur while a shared variable or resource is being
modified.
• In this manner, we could be sure that the current sequence of instructions would
be allowed to execute in order without pre-emption. Unfortunately, this solution
is not feasible in a multiprocessor environment.
• Disabling interrupt on a multiprocessor environment can be time consuming as
the message is passed to all the processors.
• This message transmission lag, delays entry of threads into critical section and
the system efficiency decreases.

7. Mutex Locks
• As the synchronization hardware solution is not easy to
implement for everyone, a strict software approach called
Mutex Locks was introduced.
• In this approach, in the entry section of code, a LOCK is
acquired over the critical resources modified and used inside
critical section, and in the exit section that LOCK is released.
• As the resource is locked while a process executes its critical
section hence no other process can access it.

8. Semaphores
• In 1965, Dijkstra proposed a new and very significant technique for
managing concurrent processes by using the value of a simple
integer variable to synchronize the progress of interacting
processes.
• This integer variable is called semaphore. So it is basically a
synchronizing tool and is accessed only through two low standard
atomic operations, wait and signal designated by P() and V()
respectively.
• The classical definition of wait and signal are :
 Wait : decrement the value of its argument S as soon as it would
become non-negative.
• Signal : increment the value of its argument, S as an individual
operation.

9. Semaphores
• Semaphores are signaling mechanisms which can allow one or more
threads/processors to access a section.
• A Semaphore has a flag which has a certain fixed value associated with it and
each time a thread wishes to access the section, it decrements the flag.
• Similarly, when the thread leaves the section, the flag is incremented. If the flag
is zero, the thread cannot access the section and gets blocked if it chooses to
wait.
• Some semaphores would allow only one thread or process in the code section.
Such Semaphores are called binary semaphore and are very similar to Mutex.
Here, if the value of semaphore is 1, the thread is allowed to access and if the
value is 0, the access is denied

10. Properties of Semaphores
1. Simple
2. Works with many processes
3. Can have many different critical sections with different
semaphores
4. Each critical section has unique access semaphores
5. Can permit multiple processes into the critical section at once,
if desirable.

11. Types of Semaphores
• Semaphores are mainly of two types:
1. Binary Semaphore
• It is a special form of semaphore used for implementing mutual
exclusion, hence it is often called Mutex. A binary semaphore is
initialized to 1 and only takes the value 0 and 1 during execution of a
program.
1. Counting Semaphores
• These are used to implement bounded concurrency.

12. Limitations of Semaphores
1. Priority Inversion is a big limitation os semaphores.
2. Their use is not enforced, but is by convention only.
3. With improper use, a process may block indefinitely. Such a situation is
called Deadlock. We will be studying deadlocks in details in coming lessons

13. Mathematical foundations
• Synchronization was originally a process-based concept whereby a
lock could be obtained on an object.
• Its primary usage was in databases. There are two types of (file)
lock; read-only and read–write. Read-only locks may be obtained by
many processes or threads.
• Readers–writer locks are exclusive, as they may only be used by a
single process/thread at a time.
• Although locks were derived for file databases, data is also shared
in memory between processes and threads. Sometimes more than
one object (or file) is locked at a time. If they are not locked
simultaneously they can overlap, causing a deadlock exception.
• Java and Ada only have exclusive locks because they are thread
based and rely on the compare-and-swap processor instruction.

14. Assignment
• Explain the usage of Semaphores as
signaling mechanisms to allow one or
more threads/ processors to access a
section.