Download Lecture 10 - Suraj @ LUMS

Wednesday, June 21, 2006
"The future belongs to him who
knows how to wait. "
- Russian Proverb
1
 Race conditions must be avoided on
kernel data structures
 Handling of critical sections in an
operating system:


Preemptive kernels
Non-preemptive kernels (yield, block, exit)
• prevent interrupts from occurring while shared
data is accessed.
2


Preemptive kernels
• Solaris
Non-preemptive kernels
• Windows, Unix, Linux 2.6 and above
3
Problems of Synchronization
 Bounded buffer problem
4
 A lock that uses busy waiting is called a
spinlock
 Synchronization tool that allow a process
to block instead of wasting CPU time,
when the process is not allowed to enter
its critical region.
5
6
Semaphore
Semaphore is an integer variable that apart
from initialization is accessed only through
two atomic operations
 wait
 signal
7
Semaphore Implementation
 Define a semaphore as a record
typedef struct {
int value;
struct process *L;
} semaphore;
 Assume two system calls:


block suspends the process that invokes it.
wakeup(P) resumes the execution of a
blocked process P.
8
Implementation
 Semaphore operations now defined as
wait(S):
S.value--;
if (S.value < 0) {
add this process to S.L;
block;
}
signal(S):
S.value++;
if (S.value <= 0) {
remove a process P from S.L;
wakeup(P);
}
9
Critical Section of n Processes
 Shared data:
semaphore mutex; //initially mutex = 1
 Process Pi:
do {
wait(mutex);
critical section
signal(mutex);
remainder section
} while (1);
How do we
ensure Bounded
Waiting?
10
 Modification to the integer value of the
semaphore in the wait and signal operations
must be executed indivisibly (i.e. when one
process modifies the semaphore value, no
other process can simultaneously modify it)
 Proper initialization of semaphore is very
important.
 Solution to milk problem?
11
wait operation: - waiting queue associated with semaphore
signal operation: - change from waiting state to ready state
Negative value of semaphore indicates what?
12
Binary & Counting Semaphores
 Counting Semaphore’s integer value can
range over an unrestricted domain
 Binary Semaphore is a semaphore with an
integer value that can range only between 0
and 1 (mutex)
13
Binary Semaphores
struct Binary_Semaphore {
value (0,1)
queue: list of processes
} s;
waitB(s):
if s.value ==1
then s.value =0;
else place this process in s.queue
block this process
end
14
Binary Semaphores (continued)
signalB(s):
if s.queue is empty
then s.value =1;
else remove a process from s.queue
place process P on ready list
end
Do Yourself: Article 7.4.4
15
Semaphore as a General Synchronization Tool
 Execute B in Pj only after A executed
in Pi
16
Semaphore as a General Synchronization Tool
 Execute B in Pj only after A executed
in Pi
 Use semaphore flag initialized to 0
 Code:
Pi
Pj


A
wait(flag)
signal(flag)
B
17
Sequencing example
 There are three processes, each produces
balls of some color (e.g. Red, Green, Blue)
Sequencing required:
 Red ball followed by Green followed by
Blue and so-on
 Initialization of semaphores for above
problem?
18
What happens here?
 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);
19
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 20
which it is suspended.
Classical Problems of Synchronization
 Bounded-Buffer Problem
 Readers and Writers Problem
 Dining-Philosophers Problem
Used for testing new synchronization
mechanisms
21
Bounded-Buffer Problem
 Shared data
semaphore full, empty, mutex;
Initially:
full = 0, empty = n, mutex = 1
22
Producer Process
Consumer Process
do {
do {
wait(full)
…
wait(mutex);
produce an item in nextp
…
…
remove an item from buffer
wait(empty);
to nextc
wait(mutex);
…
…
signal(mutex);
add nextp to buffer
signal(empty);
…
…
signal(mutex);
consume the item in nextc
signal(full);
…
} while (1);
} while (1);
23
What happens here?
Producer Process
Consumer Process
do {
do {
wait(mutex);
…
wait(full)
produce an item in nextp
…
…
remove an item from buffer
wait(mutex);
to nextc
wait(empty);
…
…
signal(empty);
add nextp to buffer
signal(mutex);
…
…
signal(full);
consume the item in nextc
signal(mutex);
…
} while (1);
24
} while (1);
Readers-Writers Problem
 Data object (e.g. file, record etc.) is
shared among several concurrent
processes (could be readers or writers)
 Two or more readers can access shared
data simultaneously
 Only one writer can access it at a time
25
Readers-Writers Problem
 Shared data
semaphore mutex, wrt;
Initially
mutex = 1, wrt = 1, readcount = 0
26
Writer Process
wait(wrt);
…
writing is performed
…
signal(wrt);
27
Reader Process
wait(mutex);
readcount++;
if (readcount == 1)
wait(wrt);
signal(mutex);
…
reading is performed
…
wait(mutex);
readcount--;
if (readcount == 0)
signal(wrt);
signal(mutex);
28
 Deadlock free does not imply
starvation free.
29
Dining-Philosophers Problem
Allocate
several
resources
among
processes in
deadlock-free,
starvation-free
manner
 Shared data
semaphore chopstick[5];
Initially all values are 1
30
Dining-Philosophers Problem
 Philosopher i:
do {
wait(chopstick[i])
wait(chopstick[(i+1) % 5])
…
eat
…
signal(chopstick[i]);
signal(chopstick[(i+1) % 5]);
…
think
…
} while (1);
31