Operating SystemsCMPSC 473Mutual Exclusion

Lecture 13: October 12, 2010

Instructor: Bhuvan Urgaonkar

Mid-semester feedback

• On Angel, format similar to SRTEs• Please submit by end of the week

Agenda• Last class

– Condition variables– Semaphores

• Next: More on condition variables and semaphores

Issues/Questions from Last Class

• Improving concurrency of producer/consumer solution using condition variables

• Atomicity of wait() for semaphores• # inteleavings for concurrent code with synchronization constraints

cond_t not_full, not_empty;mutex_lock m;int count == 0;

Produce() { mutex_lock (m);if (count == N) wait (not_full,m);

… ADD TO BUFFER, count++ …

signal (not_empty);mutex_unlock (m);

}

Consume() {mutex_lock (m);if (count == 0) wait (not_empty,m);

… REMOVE FROM BUFFER, count-- …

signal (not_full);mutex_unlock (m);

}

NOTE: You can improve this code for more concurrency!

cond_t not_full, not_empty;mutex_lock m;int count == 0;

Produce() { mutex_lock (m);if (count == N) wait (not_full,m);

count++;find pos to add // pos local variable

mutex_unlock (m);

… ADD TO BUFFER at pos …

signal (not_empty);}

Consume() {mutex_lock (m);if (count == 0) wait (not_empty,m);count--;find pos to remove from // pos local variablemutex_unlock (m);

… REMOVE FROM BUFFER at pos …

signal (not_full);}

Semaphore Implementation:

Atomicity• With busy wait• Entire wait (S) must be atomic– Note: Error in last class slide which said only S-- needed to be atomic!

– How?•Disable interrupts•Or use another mutex solution, e.g., lock

Semaphore Implementation with no Busy waiting

• With each semaphore there is an associated waiting queue. A waiting queue has two data items:– value (of type integer)– pointer to a list of PCBs

• Introduce a pointer in the PCB structure

• 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.

• FIFO ordering => bounded-waiting Is busy waiting completely gone?

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); } }

Semaphore Implementation with no Busy waiting: Atomicity• 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); } }

How to make these atomic?

Semaphore Implementation with no Busy waiting: Atomicity

• Uniprocessors– Disable interrupts during wait and signal

• Once interrupts are disabled, instructions from different processes cannot be interleaved. Only the currently running process executes until interrupts are re-enabled and the scheduler can regain control.

• Multi-processors– Inhibiting interrupts does not work– Instructions from different processes (running on different processors) may be interleaved in some arbitrary way

– If the hardware does not provide any special instructions, we can employ any of the correct software solutions (e.g., Peterson’s, Bakery) for the critical-section problem, where the critical sections consist of the wait and signal operations (EXTREMELY COOL)

• So, we have not completely eliminated busy waiting with this definition of wait and signal– We have moved busy waiting to the critical sections– Furthermore, we have limited busy waiting to the critical sections of wait and signal

Semaphore Implementation with no Busy waiting: Atomicity

• Uniprocessors– Disable interrupts during wait and signal

• Once interrupts are disabled, instructions from different processes cannot be interleaved. Only the currently running process executes until interrupts are re-enabled and the scheduler can regain control.

• Multi-processors– Inhibiting interrupts does not work– Instructions from different processes (running on different processors) may be interleaved in some arbitrary way

– If the hardware does not provide any special instructions, we can employ any of the correct software solutions (e.g., Peterson’s, Bakery) for the critical-section problem, where the critical sections consist of the wait and signal operations (EXTREMELY COOL)

• So, we have not completely eliminated busy waiting with this definition of wait and signal– We have moved busy waiting to the critical sections– Furthermore, we have limited busy waiting to the critical sections of wait and signal

Semaphore Implementation with no Busy waiting: Atomicity

• Uniprocessors– Disable interrupts during wait and signal

• Once interrupts are disabled, instructions from different processes cannot be interleaved. Only the currently running process executes until interrupts are re-enabled and the scheduler can regain control.

• Multi-processors– Inhibiting interrupts does not work– Instructions from different processes (running on different processors) may be interleaved in some arbitrary way

– If the hardware does not provide any special instructions, we can employ any of the correct software solutions (e.g., Peterson’s) for the critical-section problem, where the critical sections consist of the wait and signal operations (EXTREMELY COOL)

• So, we have not completely eliminated busy waiting with this definition of wait and signal– We have moved busy waiting to the critical sections– Furthermore, we have limited busy waiting to the critical sections of wait and signal

Semaphore Implementation with no Busy waiting: Atomicity

• Uniprocessors– Disable interrupts during wait and signal

• Once interrupts are disabled, instructions from different processes cannot be interleaved. Only the currently running process executes until interrupts are re-enabled and the scheduler can regain control.

• Multi-processors– Inhibiting interrupts does not work– Instructions from different processes (running on different processors) may be interleaved in some arbitrary way

– If the hardware does not provide any special instructions, we can employ any of the correct software solutions (e.g., Peterson’s) for the critical-section problem, where the critical sections consist of the wait and signal operations (EXTREMELY COOL)

• So, we have not completely eliminated busy waiting with this definition of wait and signal– We have moved busy waiting to the critical sections– Furthermore, we have limited busy waiting to the critical sections of wait and signal

Sample incorrect use of semaphores• 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 1P0 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.

Compare locks, CVs, semaphores

• Ease of use• Busy wait

– Generally, CVs/semaphores better– Locks good for small critical sections on multi-processors

• Signaling capabilities

Classical Problems of Synchronization

• Bounded-Buffer Problem• Readers and Writers Problem• Dining-Philosophers Problem

Bounded-Buffer Problem

• N buffers, each can hold one item• Semaphore mutex initialized to the value 1

• Semaphore full initialized to the value 0

• Semaphore empty initialized to the value N

Bounded Buffer Problem (Cont.)

• The structure of the producer process while (true) { // produce an item wait (empty); wait (mutex); // add the item to the buffer

signal (mutex); signal (full); }

Bounded Buffer Problem (Cont.)• The structure of the consumer process

while (true) { wait (full); wait (mutex); // remove an item from buffer

signal (mutex); signal (empty); // consume the removed item

}

Readers-Writers Problem

• A data set shared among a number of concurrent processes– Readers – only read the data set; they do not perform any updates

– Writers – can both read and write

• Problem – allow multiple readers to read at the same time. Only one writer may access the shared data at a given time

• Shared Data– Data set– Semaphore mutex initialized to 1– Semaphore wrt initialized to 1– Integer readcount initialized to 0

Readers-Writers Problem (Cont.)

• The structure of a writer process do { wait (wrt) ;

// writing is performed

signal (wrt) ;

} while (TRUE);

mutex = 1wrt = 1readcount = 0

Allow only one writer at a time to write

Readers-Writers Problem (Cont.)

• The structure of a reader processdo {

wait (mutex) ; readcount ++ ; if (readcount == 1) wait (wrt) ;

signal (mutex) // reading

wait (mutex) ; readcount - - ; if (readcount == 0)

signal (wrt) ; signal (mutex) ; } while (TRUE);

mutex = 1wrt = 1readcount = 0

Proceed only if no writer is writing; disallowwriters once weproceed

Signal a writeronly when thereare no moreactive readers

Note 1: readcountkeeps track of the number of active readers

Note 2: Understand the role of mutex (consider whathappens without it)

Readers-Writers Problem (Cont.)

• The structure of a reader processdo {

wait (mutex) ; readcount ++ ; if (readcount == 1) wait (wrt) ;

signal (mutex) // reading

wait (mutex) ; readcount - - ; if (readcount == 0)

signal (wrt) ; signal (mutex) ; } while (TRUE);

mutex = 1wrt = 1readcount = 0

Proceed only if no writer is writing; disallowwriters once weproceed

Signal a writeronly when thereare no moreactive readers

Deadlock?

Starvation?