OS Winter’03 Concurrency

OS Winter’03 Bakery algorithm of Lamport  Critical section algorithm for any n>1  Each time a process is requesting an entry to CS, assign it a ticket which is Unique and monotonically increasing  Let the process into CS in the order of their numbers

OS Winter’03 Choosing a ticket Does not guarantee uniqueness! Use process Ids: Process need to know that somebody perhaps chose a smaller number:

OS Winter’03 Bakery algorithm for n processes

OS Winter’03 Correctness Lemma: Mutual exclusion is immediate from this lemma It is easy to show that Progress and Fairness hold as well (recitation)

OS Winter’03 Hardware primitives  Elementary building blocks capable of performing certain steps atomically Should be universal to allow for solving versatile synchronization problems  Numerous such primitives were identified: Test-and-set Fetch-and-add Compare-and-swap

OS Winter’03 Test-and-Set (TS) boolean test-and-set(boolean &lock) { temp=lock; lock=TRUE; return temp; } reset(boolean &lock) { lock=FALSE; }

OS Winter’03 Critical section using TS Shared boolean lock, initially FALSE do { while(test-and-set(&lock)); critical section; reset(&lock); reminder section; } while(1); Check yourself! Is mutual exclusion satisfied? Is progress satisfied? Is fairness satisfied?

OS Winter’03 Discussion  Satisfies Mutual Exclusion and Progress  Does not satisfies Fairness  Provides exclusion among unbounded number of processes Process IDs and number are unknown  Busy waiting Burning CPU cycles while being blocked

OS Winter’03 Fetch-and-Add (FAA) s: shared, a: local int FAA(int &s, int a) { temp=s; s=s+a; return temp; } FAA can be used as a ticket machine

OS Winter’03 Critical section using FAA Shared: int s, turn; Initially: s = 0; turn=0; Process P i code: Entry: me = FAA(s,1); while(turn < me); // busy wait for my turn Critical section Exit: FAA(turn,1); Check yourself! Is mutual exclusion satisfied? Is progress satisfied? Is fairness satisfied?

OS Winter’03 Discussion  Satisfies all three properties  Supports unbounded number of processes  Unbounded counter  Busy waiting

OS Winter’03 Problems with studied synchronization methods  Critical section framework is inconvenient for programming  Performance penalty Busy waiting Too coarse synchronization  Using hardware primitives directly results in non-portable code

OS Winter’03 Higher Level Abstractions  Higher level software abstractions are represented by Semaphores Monitors

OS Winter’03 Semaphores  Invented by Edsger Dijkstra in 1968  Interface consists of two primitives: P() and V()

OS Winter’03 Notes on the Language  Dutch: P: Proberen, V: Verhogen  Hebrew: P: פחות, V: ועוד  English: P(): wait(), V(): signal()

OS Winter’03 Semaphores: initial value  Initial value of a semaphore indicates how many identical instances of the critical resource exist  A semaphore initialized to 1 is called a mutex (mutual exclusion)

OS Winter’03 Programming with semaphores  Semaphores is a powerful programming abstraction  Define a semaphore for each critical resource E.g., one for each linked list Granularity?  Concurrent processes access appropriate semaphores when synchronization is needed

OS Winter’03 Some examples … V(synch); … P(synch); …

OS Winter’03 Some examples Do { P(mutex); critical section V(mutex); Remainder section; While(1);

OS Winter’03 Implementing semaphores  Semaphores can be implemented efficiently by the system P() is explicitly telling the system: “ Hey, I cannot proceed, you can preempt me ” V() instructs the system to wake up a waiting process

OS Winter’03 Implementing Semaphores type semaphore = record count: integer; queue: list of process end; var S: semaphore; S.count must be initialized to a nonnegative value (depending on application)

OS Winter’03 Implementing Semaphores P(S): S.count--; if (S.count<0) { add this process to S.queue block this process; } V(S): S.count++; if (S.count <= 0) { remove a process P from S.queue place this process P on ready queue }

OS Winter’03 We ’ re still cheating …  P() and V() must be executed atomically  In uniprocessor system may disable interrupts  In multi-processor system, use hardware synchronization primitives TS, FAA, etc …  Involves a some limited amount of busy waiting

OS Winter’03 Monitors monitor monitor-name { shared variable declarations procedure P1(…) { … } … procedure Pn() { … }  Only a single process at a time can be active within the monitor => other processes calling Pi() are queued  Conditional variables for finer grained synchronization x.wait() suspend the execution until another process calls x.signal()