The document discusses process synchronization and coordination between independent processes. It covers concepts like race conditions, critical sections, solutions like Peterson's algorithm using shared variables, synchronization primitives like semaphores, and classical synchronization problems like the bounded buffer, producer-consumer, readers-writers, and dining philosophers problems. Implementation techniques like busy waiting, signaling with wait/signal operations, and avoidance of starvation and deadlock are described. Examples of solutions to these classic problems using semaphores and other synchronization methods are outlined.
2. Disclaimer
This is NOT A COPYRIGHT MATERIAL
Content has been taken mainly from the following books:
Operating Systems Concepts By Silberschatz & Galvin ,
Operating systems By D M Dhamdhere,
System Programming By John J Donovan
etc…
VA.
CSED,TU
3. Process & Synchronization
Process – Program in Execution.
Synchronization – Coordination.
Independent process cannot affect or be affected by the execution of another
process
Cooperating process can affect or be affected by the execution of another
process
Advantages of process cooperation
Information sharing
Computation speed-up
Modularity
Convenience
VA.
CSED,TU
5. Bounded-Buffer – Shared-Memory Solution
Shared Data
#define BUFFER_SIZE 10
typedef struct {
...
} item;
item buffer [BUFFER_SIZE];
int in = 0;
int out = 0;
Can only use BUFFER_SIZE-1 elements
VA.
CSED,TU
7. Bounded-Buffer – Producer
while (true) {
/* Produce an item */
while (((in = (in + 1) % BUFFER SIZE count) == out)
; /* do nothing -- no free buffers */
buffer[in] = item;
in = (in + 1) % BUFFER SIZE;
}
VA.
CSED,TU
8. Bounded Buffer – Consumer
while (true) {
while (in == out)
; // do nothing -- nothing to consume
// remove an item from the buffer
item = buffer[out];
out = (out + 1) % BUFFER SIZE;
return item;
}
VA.
CSED,TU
10. Buffer Types
Paradigm for cooperating processes, producer process produces information that
is consumed by a consumer process
Unbounded-buffer places no practical limit on the size of the buffer
Bounded-buffer assumes that there is a fixed buffer size
VA.
CSED,TU
11. RC & CS
Race Condition – Where several processes access and manipulate the same data
concurrently and the outcome of the execution depends on the particular order
in which access takes place.
Critical Section – Segment of code in which Process may be changing common
variables, updating a table, writing a file and so on.
VA.
CSED,TU
15. Synchronization Hardware
Many Systems provide hardware support for critical section code
Uni-Processors – Could disable Interrupts
Currently running code would execute without preemption
Generally too inefficient on multiprocessor systems
Modern machines provide special atomic hardware instructions
Atomic :- Uninterruptible
Either Test memory word and Set value
Or Swap contents of two memory words
VA.
CSED,TU
19. Solution using Swap
Shared Boolean variable lock initialized to FALSE, Each process has a
local Boolean variable key.
Solution:
do {
key = TRUE;
while ( key == TRUE)
Swap (&lock, &key );
// critical section
lock = FALSE;
// remainder section
} while ( TRUE);
VA.
CSED,TU
20. Semaphore
Synchronization tool that does not require busy waiting
Semaphore S – Integer Variable
Two standard operations modify S: wait() and signal()
Originally called P() and V()
Less complicated
Can only be accessed via two indivisible (atomic) operations
wait (S) {
while S <= 0
; // no-op
S--;
}
signal (S) {
S++;
}
VA.
CSED,TU
21. Semaphore as General Synchronization Tool
Counting Semaphore – Integer value can range over an unrestricted domain
Binary Semaphore – Integer value can range only between 0 and 1, Can be
simpler to Implement
Also known as Mutex locks
Can implement a counting semaphore S as a binary semaphore
Provides mutual exclusion
Semaphore S; // initialized to 1
wait (S);
Critical Section
signal (S);
VA.
CSED,TU
22. Semaphore Implementation
Must guarantee that no two processes can execute wait () and signal ()
on the same semaphore at the same time
Thus, implementation becomes the critical section problem where the
wait and signal code are placed in the critical section.
Could now have busy waiting in critical section implementation
But implementation code is short
Little busy waiting if critical section rarely occupied
Note that applications may spend lots of time in critical sections and
therefore this is not a good solution.
VA.
CSED,TU
23. Semaphore Implementation with no Busy waiting
With each Semaphore there is an associated waiting queue. Each entry in a
waiting queue has two data items:
Value (of type Integer)
Pointer to next record in the list
Two operations:
Block – Place the Process invoking the operation on the appropriate waiting
queue.
Wakeup – Remove one of Processes in the waiting queue and place it in the
ready queue.
VA.
CSED,TU
24. Semaphore Implementation with no Busy waiting
(Cont.)
Implementation of WAIT:
wait (S){
value--;
if (value < 0) {
add this process to waiting queue
block(); }
}
Implementation of SIGNAL:
Signal (S){
value++;
if (value <= 0) {
remove a process P from the waiting queue
wakeup(P); }
}
VA.
CSED,TU
25. Deadlock and Starvation
Deadlock – Two or more Processes are waiting Indefinitely for an event that can
be caused by only one of the waiting processes
Let S and Q be two Semaphores initialized to 1
P0 P1
wait (S); wait (Q);
wait (Q); wait (S);
. .
. .
. .
signal (S); signal (Q);
signal (Q); signal (S);
Starvation – Indefinite Blocking. A process may never be removed from the
semaphore queue in which it is suspended.
VA.
CSED,TU
37. Reference List
Operating Systems Concepts By Silberschatz & Galvin,
Operating systems By D M Dhamdhere,
System Programming By John J Donovan,
www.os-book.com
www.cs.jhu.edu/~yairamir/cs418/os2/sld001.htm
http://gaia.ecs.csus.edu/~zhangd/oscal/pscheduling.html
http://www.edugrid.ac.in/iiitmk/os/os_module03.htm
http://williamstallings.com/OS/Animations.html
etc…
VA.
CSED,TU