Interprocess Communication (3) Operating Systems Interprocess Communication (3)

Producer/Consumer Bounded Buffer Producer puts items into a buffer Consumer removes items from buffer Producer issue: attempts to put an item in a full buffer Consumer issue: attempts to remove an item from an empty buffer

Producer/Consumer Model 1 prod_cons1() { Global int N = 100; int count = 0; } parbegin producer(); consumer(); parend producer() itemType item; while(1) if (count == N) sleep(); produce(); ++count; if (count == 1) wakeup(consumer); consumer() int item; if (count == 0) --count; if (count == (N – 1)) wakeup(producer) c

Access to Count is unconstrained buffer is empty consumer tests count context-switch before sleep producer puts an item in the buffer increments count to 1 tries to wakeup consumer, but consumer is not asleep produces goes on filling the buffer then goes to sleep consumer runs and goes to sleep Could be solved with either peterson or tsl

Spinlock Semaphore ADT Proposed by Dijkstra wait(int* S) //frequently called “down” { while( *S<= 0;) //item is in CS *S--; } signal(int* S) //frequently called “up” { *S++; } Key Ideas Apart from initialization, S is only modifiable by wait and signal All modifications to S in wait an signal are done without interruption 3. Testing S is done without interruption

N-Process Example N_Process() { Global int s = 1; } parbegin proc0(); parend //All N processes look like //this proc_0() while(1) wait(&s); cs(); signal(&s); proc0 runs and calls wait s == 1, so s is decremented to 0 Enter CS proc1, calls wait, fails test and sits in loop proc2, calls wait, fails test and sits in loop proc0 runs, finishes CS, calls signal, increments s proc2 runs, passes while test, decrements s, leaves down, enters CS

SempAhores can Synchronize processes. Proc0 before proc1 { Global int s = 0; } parbegin proc0(); proc1(); parend Proc0() cs(); signal(&s); Proc1() wait(&s); cs()

PROC_0 PRODUCES X FOR PROC_1 TO CONSUME PROC_1 PRODUCES Y FOR PROC_0 TO CONSUME synch() { Global int s1 = s2 = 0; itemType x, y; } parbegin proc0(); proc1(); parend }1 proc_0() while(1) x = produce(); signal(&s1); wait(&s2) consume(y); proc_1() { wait(s1); consume(x); y = produce(); signal(s2) Demonstrate with a table: s1, s2, x y

Problem with the Semaphore as defined? Busy Wait SOLUTION: COUNTING SEMAPHORE

Counting Semaphore Requires Linked List of processes typedef struct { int value; struct process *list; //a list of processes } semaphore

Wait and signal wait(semaphore* S) { S → value--; if (S → value < 0) { add (pid) S → list; block(pid); } } signal(semaphore* S) { S → value++; if (S → value <= 0) { pid = remove(S → list); wakeup(pid); } } “It is critical that semaphore operations be executed atomically. We must guarantee that no two process can execute wait() and signal() on the same semaphore at the same time.” (Silberschatz, p. 216). With single processors, we disable interrupts. With mulitiple processors, it becomes necessary to reintroduce busy-wait. Message passing is the answer.

N Process Semaphore Example cnt_sem() { semaphore s1; s1.value = 1 parbegin { proc0(&s1) ... proc1(&s1); } parend procj(semaphor* s1) { while(1) { wait(s1); crit_sect(); signal(s1); }

Scenario 1. proc0() runs, calls down: value == 0, enters CS 2. proc1() runs, calls down: value == -1, fails test and blocks 3. proc2() runs, calls down: value == -2, fails test and blocks] 4. proc0() runs, finished CS, calls up: value == -1, removes p1 from sleep list, wakes up p1 lst p1 lst p1 p2 lst p1

Producer-Consumer With Counting Semaphores Recall Producer/Consumer required 1 variables (count) and a buffer in which to store items produces or consumed. Both must be protected Solution with three semaphores empty: counts empty buffer slots, initially N full: counts full buffer slots, initially 0 mutex: controls access to buffer, initially 1

Producer-Consumer Model 2 prod_cons2() { Global sem mutex; sem empty; semfull: mutex.value = 1; empty.value = 100; full.value = 0; } parbegin { producer(); consumer(); parend producer() while(1) wait(&empty); wait(&mutex); produce(); signal(&mutex); signal(&full); consumer() wait(&full); consume(); signal(&empty);

Scenario 1 consumer runs value == -1, blocks on full producer runs dec empty, dec mutex, enters cs, inc mutex, I inc full full.s == 0, wakes up consumer

Suppose full.s == 98, empty.s == 2, mutex.s == 1 producer runs: dec empty (so empty.s == 1), dec mutex (so mutex.s == 0), enters cs consumer runs: dec full (so full.s == 97), dec mutex (so mutex.s == -1) consumer blocks on mutex producer runs: inc mutex (so mutex.s == 0), wakes up consumer, inc full (so full.s == 98) consumer runs: enters cs, inc mutex (so mutex.s == 1), inc empty (so empty.s == 2) Semphore values: full.s == 98, empty.s == 2, mutex.s == 1 Both Producer and consumer have run to completion. Semaphore values are as they were in the beginning

A Trap Suppose in Producer Order of wait on mutx and empty switched

(more or less) Correct solutions Peterson software two processes busy-wait TSL hardware N processes Spinlock Semaphore Hardware N processes busy-wait Counting Semaphore sleep/wakeup Limited to single processors without busy- wait.

Building a Model of Producer/Consumer Primitives pipes: direct communication link between two linux processes semaphore system calls in linux