Embed Size (px)
Citation preview
Process SynchronizationProcess Synchronization
Topics:
1.Background
2.The critical-section problem
3.Semaphores
4.Critical Regions
5.Monitors
Topics:
1.Background
2.The critical-section problem
3.Semaphores
4.Critical Regions
5.Monitors
Background Background
Concurrent access to Data may result in data inconsistency
To maintain data consistency we should have orderly execution of co-operating processes
In the bounded buffer example, what happens I we maintain a counter to keep track of number of items produced common to producer and consumer
Concurrent access to Data may result in data inconsistency
To maintain data consistency we should have orderly execution of co-operating processes
In the bounded buffer example, what happens I we maintain a counter to keep track of number of items produced common to producer and consumer
Bounded BufferBounded Buffer
Shared Data: buffer[n],in,out,counter
Producer Process:
repeat
produce an item in nextp
while counter==n wait
buffer[in]=nextp;in=(in+1)%n;counter++;
until false
Shared Data: buffer[n],in,out,counter
Producer Process:
repeat
produce an item in nextp
while counter==n wait
buffer[in]=nextp;in=(in+1)%n;counter++;
until false
Bounded Buffer (continued)Bounded Buffer (continued)
Consumer Process
repeat
while counter==0 do no-op
nextc=buffer[out];
counter--; consume item nextc
until false
Statements counter++ and counter-- have to be done atomically - no interrupt
Consumer Process
repeat
while counter==0 do no-op
nextc=buffer[out];
counter--; consume item nextc
until false
Statements counter++ and counter-- have to be done atomically - no interrupt
Critical Section ProblemCritical Section Problem
n processes competing to use shared data
Each process has a code segment called critical section in which shared data is accessed
Issue: When one process is in critical section, no other process is in critical section
n processes competing to use shared data
Each process has a code segment called critical section in which shared data is accessed
Issue: When one process is in critical section, no other process is in critical section
Structure of ProcessStructure of Process
repeat repeat
Critical sectionCritical section
Remainder section
until false
Remainder section
until false
Solution to Critical Section Problem
Solution to Critical Section Problem
1. Mutual Exclusion: No two processes are in the critical section at the same time.
2. Progress: If no process is in the critical section and a process wishes to enter, that process cannot be postponed indefinitely
3. Bounded waiting: A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its cs and that process is granted.
1. Mutual Exclusion: No two processes are in the critical section at the same time.
2. Progress: If no process is in the critical section and a process wishes to enter, that process cannot be postponed indefinitely
3. Bounded waiting: A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its cs and that process is granted.
Initial Attempts to solve Problem
Initial Attempts to solve Problem
Only 2 Processes P_0 and P_1
General Structure of Process P_j (other is P_i)
repeat
entry section; critical section;
exit section;remainder section;
until false;
Processes may share some common variables to synchronize their actions.
Only 2 Processes P_0 and P_1
General Structure of Process P_j (other is P_i)
repeat
entry section; critical section;
exit section;remainder section;
until false;
Processes may share some common variables to synchronize their actions.
Algorithm 1Algorithm 1
Shared variables: int turn /* turn=j it P_jth turn*/
Process P_j
repeat
while (turn <> j) wait
critical section;
turn=I; remainder section;
umtil false
Shared variables: int turn /* turn=j it P_jth turn*/
Process P_j
repeat
while (turn <> j) wait
critical section;
turn=I; remainder section;
umtil false
Algorithm 2Algorithm 2
Shared variables: boolean flag[2] /*flag[j]=true means jth turn */
Process P_j
entry section: flag[j]=true; while (flag[i]) wait;
exit section: flag[j]=false;
As before satisfies mutual exclusion but no progress.
Shared variables: boolean flag[2] /*flag[j]=true means jth turn */
Process P_j
entry section: flag[j]=true; while (flag[i]) wait;
exit section: flag[j]=false;
As before satisfies mutual exclusion but no progress.
Algorithm 3Algorithm 3
Shared variables: flag[2] , turn;
Process P_j
entry section: flag[j]=true; turn=j; while (flag[i] and turn==i) wait;
exit section: flag[j]=false;
Satisfies all three requirements- critical thing to note is turn is a shared variable.
Shared variables: flag[2] , turn;
Process P_j
entry section: flag[j]=true; turn=j; while (flag[i] and turn==i) wait;
exit section: flag[j]=false;
Satisfies all three requirements- critical thing to note is turn is a shared variable.
Bakery AlgorithmBakery Algorithm
Critical Section for n processors
Before entering the critical section, process receives a number. Holder of the smallest number enters its critical section.
If processes P_i and P_j receive the same number, if i<j, then P_i is served first else p_j is served.
Numbering scheme always generates numbers in non-decreasing order.
Critical Section for n processors
Before entering the critical section, process receives a number. Holder of the smallest number enters its critical section.
If processes P_i and P_j receive the same number, if i<j, then P_i is served first else p_j is served.
Numbering scheme always generates numbers in non-decreasing order.
Bakery Algorithm (continued)Bakery Algorithm (continued)
We use lexicographic order. (a,b) < (c,d) is either a< c or a=c b< d.
Shared data: Boolean choosing[n]
int number[n]
they are initialized to false and 0 resply.
We use lexicographic order. (a,b) < (c,d) is either a< c or a=c b< d.
Shared data: Boolean choosing[n]
int number[n]
they are initialized to false and 0 resply.
Bakery Algorithm (continued)Bakery Algorithm (continued)
Enter section:choosing[j] = true; number[j]=max of numbers +1choosing[j]=false;
for (k=0;k<n;k++) {while(choosing[k]) wait;while(number[k] <>0) and(number[k],k) <number[j],j) wait;
}Leave Section: number[j]=0;
Enter section:choosing[j] = true; number[j]=max of numbers +1choosing[j]=false;
for (k=0;k<n;k++) {while(choosing[k]) wait;while(number[k] <>0) and(number[k],k) <number[j],j) wait;
}Leave Section: number[j]=0;
Synchronization HardwareSynchronization Hardware
Test and modify the content of a word atomically
boolean Test-and-set(boolean target){Test-and-set = target; target = true;}
Test and modify the content of a word atomically
boolean Test-and-set(boolean target){Test-and-set = target; target = true;}
Mutual Exclusion with Test-and-set
Mutual Exclusion with Test-and-set
Shared data: boolean lock (initially false)
Process P_j:enter section: while (Test-and-lock) wait;
leave section: lock = false;
Shared data: boolean lock (initially false)
Process P_j:enter section: while (Test-and-lock) wait;
leave section: lock = false;
SemaphoreSemaphore
Synchronization tool that does not require busy waitSemaphore S - integer variablecan only be accessed via two indivisible atomic operations
wait(s): while (s <=0) no-op; s = s-1;signal(s): s=s+1;
Synchronization tool that does not require busy waitSemaphore S - integer variablecan only be accessed via two indivisible atomic operations
wait(s): while (s <=0) no-op; s = s-1;signal(s): s=s+1;
Critical section for n processesCritical section for n processes
Shared Variable: semaphore mutex;
initial value of mutex=1;
entersection: wait(mutex);
leavesection: signal(mutex);
Shared Variable: semaphore mutex;
initial value of mutex=1;
entersection: wait(mutex);
leavesection: signal(mutex);
Semaphore ImplementationSemaphore Implementation
Semaphore as a struct
typedef semaphore struct { int value;
ProcessList L }
Two Simple operations:
block - suspends the process that invokes it
wakeup(P) resumes the execution of a blocked process P
Semaphore as a struct
typedef semaphore struct { int value;
ProcessList L }
Two Simple operations:
block - suspends the process that invokes it
wakeup(P) resumes the execution of a blocked process P
Semaphore Implementation (continued)
Semaphore Implementation (continued)
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 from P from S.L; wakeup(P);}
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 from P from S.L; wakeup(P);}
Implementation (continued)Implementation (continued)
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 from P from S.L; wakeup(P);}
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 from P from S.L; wakeup(P);}
Semaphore as General Synchronization Tool
Semaphore as General Synchronization Tool
Execute B in P_j only after A is executed in P_i
Use semaphore flag initialized to 0
code P_i: A ; signal(flag)
Code P_j: wait(flag); B;
Execute B in P_j only after A is executed in P_i
Use semaphore flag initialized to 0
code P_i: A ; signal(flag)
Code P_j: wait(flag); B;
Deadlock and StarvationDeadlock and Starvation
Deadlock - two or more processes are waiting for indefinitely for an event that can be caused by only one of the waiting processes. S and Q are semaphores.
P_0: wait(S);wait(Q); ..signal(S);signal(Q);
P_1:wait(Q);wait(S);..;signal(Q);signal(S);
Starvation: A process may never be removed from the semaphore queue .
Deadlock - two or more processes are waiting for indefinitely for an event that can be caused by only one of the waiting processes. S and Q are semaphores.
P_0: wait(S);wait(Q); ..signal(S);signal(Q);
P_1:wait(Q);wait(S);..;signal(Q);signal(S);
Starvation: A process may never be removed from the semaphore queue .
Two Types of SemaphoresTwo Types of Semaphores
•Counting Semaphore - integer value can range over an unrestricted domain
•Binary Semaphore - integer value can range from 0 to 1 - easier to implement.
•Can implement (simulate) a counting semaphore using a binary semaphore.
•Counting Semaphore - integer value can range over an unrestricted domain
•Binary Semaphore - integer value can range from 0 to 1 - easier to implement.
•Can implement (simulate) a counting semaphore using a binary semaphore.
Implementing S as a binary Semaphore
Implementing S as a binary Semaphore
Data Structures:
binary_semaphore s1,s2,s3;
int c;
Initialization
s3=s1=1; s2=0;
c=initial value of semaphore
Data Structures:
binary_semaphore s1,s2,s3;
int c;
Initialization
s3=s1=1; s2=0;
c=initial value of semaphore
Implementing S (continued)Implementing S (continued)
Wait operation
wait(s3);wait(s1);c=c-1; if (c<0) {signal(s1);wait(s2); else {signal(s1);}
signal(s3);
Signal Operation: wait(s1); c=c+1; if (c<=0) {signal(s2);} signal(s1);
Wait operation
wait(s3);wait(s1);c=c-1; if (c<0) {signal(s1);wait(s2); else {signal(s1);}
signal(s3);
Signal Operation: wait(s1); c=c+1; if (c<=0) {signal(s2);} signal(s1);
Classical Problems of Synchronization
Classical Problems of Synchronization
Bounded Buffer Problem
Readers and writers Problem
Dining Philosopher
Bounded Buffer Problem
Readers and writers Problem
Dining Philosopher
Bounded Buffer ProblemBounded Buffer Problem
Shared Data
String Item;
String buffer[];
semaphore full,empty,mutex;
item nextp,nextc;
full=0;empty=n;mutex=1
Shared Data
String Item;
String buffer[];
semaphore full,empty,mutex;
item nextp,nextc;
full=0;empty=n;mutex=1
Producer ProcessProducer Process
Repeat
{ produce an item in nextp;
wait(empty);wait(mutex);
add nextp to buffer; signal(mutex); signal(full);
} until false;
Repeat
{ produce an item in nextp;
wait(empty);wait(mutex);
add nextp to buffer; signal(mutex); signal(full);
} until false;
Consumer ProcessConsumer Process
Repeat {
wait(full);wait(mutex);
remove an item from buffer in nextc; signal(mutex); signal(empty);
consume an item in nextc;
} until false;
Repeat {
wait(full);wait(mutex);
remove an item from buffer in nextc; signal(mutex); signal(empty);
consume an item in nextc;
} until false;
Readers and Writers ProblemReaders and Writers Problem
Shared Data: Semaphore mutex,wrt;(=1)
int readcount;
Writer Process:
wait(wrt); write; signa(wrt);
Shared Data: Semaphore mutex,wrt;(=1)
int readcount;
Writer Process:
wait(wrt); write; signa(wrt);
Reader ProcessReader Process
Entersection:
wait(mutex); readcount++;
if (readcount==1) wait(wrt);
signal(mutex);
leavesection:
wait(mutex);readcount-; if(reacount==0) signal(wrt); signal(mutex);
Entersection:
wait(mutex); readcount++;
if (readcount==1) wait(wrt);
signal(mutex);
leavesection:
wait(mutex);readcount-; if(reacount==0) signal(wrt); signal(mutex);
Dining Philosopher ProblemDining Philosopher Problem
Shared data: Semaphore chopstick[5](=1);
Philosopher_j
entersection: wait(chopstick[j]); wait(chopstick[(j+1)%5]);
Leavesection: signal(chopstick[j]); signal(chopstick[(j+1)%5]);
Shared data: Semaphore chopstick[5](=1);
Philosopher_j
entersection: wait(chopstick[j]); wait(chopstick[(j+1)%5]);
Leavesection: signal(chopstick[j]); signal(chopstick[(j+1)%5]);
