10/17/2011. Cooperating Processes. Synchronization 1. Example: Producer Consumer (3) Example

Transcription

1 Cooperating Processes Synchronization 1 Chapter processes share something (devices such as terminal, keyboard, mouse, etc., or data structures) and can affect each other non deterministic Not exactly cooperating in the English sense of the word multiple processes share processor(s) and can be pre empted by cpu scheduler at random times ex) p1: System.out.print( ABC ); p2: System.out.print( XYZ ); Q. What is shared between these two processes? Q. What are the possible outputs? Example p1: i= 0; while (i < 5) ++i; System.out.pln( p1 wins! ); p2: i = 0; while (i > 5) i; System.out.pln( p2 wins! ); assume iis shared Q1. who wins? Q2. is it guaranteed that there is a winner? Q3. if p1 runs on processor 1 and p2 runs on processor 2 and if they are in perfect sync, what happens? Q3. if p1 is just a bit ahead of p2, who wins? Q4. what can happen on a single processor? Example: Producer Consumer (1) producer: while (count == BUF_SIZE) ; buf[in] = nextproduced; in = (in + 1) % BUF_SIZE; count++; buf and count are shared consumer: while (count == 0) ; nextconsumed = buf[out]; out = (out + 1) % BUF_SIZE; count ; what happens if producer and consumer both execute the last line of code concurrently? what are the possible values of count after both are done? translate count++ and count to machine language Example: Producer Consumer (2) Example: Producer Consumer (3) count++; register1 = count register1 = register1 + 1 count = register1 count--; register2 = count register2 = register2-1 count = register2 p1 p2 p3 c1 c2 c3 suppose count is 5 possible interleaving of machine instructions [1] p1 p2 p3 c1 c2 c3 ==> [2] p1 c1 p2 c2 p3 c3 ==> [3] p1 c1 c2 p2 c3 p3 ==> [4] p1 p2 c1 c2 p3 c3 ==> [5] p1 p2 c1 c2 c3 p3 ==> which value is correct? why does this happen? 1

2 Terms race condition: multiple processes run and access shared data concurrently and the outcome depends on the order in which accesses take place atomic operations: operations that cannot be interrupted uninterruptible unit of operations they run to completion or not at all individual load and stores (of 4 byte word) are typically atomic uni processor system: any section of code executed with interrupt disabled harder to do on a multi processor system Critical Section definition: a block of code that only one process may be executing at a time solution requirements mutual exclusion: no more than one process progress: no deadlock bounded waiting: ensure fairness solution: use a software lock acquire lock: wait until lock is free and grab it release lock: free the lock More terms synchronization (or concurrency control): using atomic operations to eliminate race conditions lock: synchronization mechanism to enforce atomicity lock(l): if L is not currently locked, atomically acquire control; if L is currently locked, block until it becomes free unlock(l): release control of L deadlock: 2+ actions are waiting for each other to finish (e.g., catch-22 or chicken-n-egg ) livelock: resource starvation, states of the processes constantly change with regard to one another, none progressing (e.g., polite people meet in the corridor ) Proving Correctness mutual exclusion if one process is in critical section and another process tries to enter 2 nd process must be blocked if multiple processes are in entry code at most one process is allowed to enter critical section progress (no deadlock) if no process is in critical section and a process arrives this process is if multiple processes are in entry code at least one process should be bounded waiting (no livelock): no process should block forever if process p i is in critical section and process p j is waiting to enter when p i leaves and tries to re enter, p j is allowed entry first General Structure [ entry ] acquire lock: wait till lock is free and grab it [ exit ] release lock: free lock for others Lock attempt 0 boolean if (!lock) 2

3 Lock attempt 1 boolean while (lock) ; Lock attempt 1 boolean while (lock) ; A. No. Multiple processes may be allowed in critical section. Lock attempt 2 boolean[] flags = {false, false; Lock attempt 2 boolean[] flags = {false, false; A. No. Multiple processes may be allowed in critical section. Lock attempt 3 boolean[] flags = {false, false; Lock attempt 3 boolean[] flags = {false, false; while (flags[other]) ; // check for the other process A. No. Deadlock can happen. 3

4 Lock attempt 4 Lock attempt 4 int turn = 0; while (turn!= me) ; // process 0 gets the turn initially // wait for my turn // give turn to the other int turn = 0; while (turn!= me) ; // process 0 gets the turn initially // wait for my turn // give turn to the other Q. anything wrong with this approach? A. It is slowed by the slow processes making it unfair 6.3 Lock attempt Lock attempt 5 (Peterson s) boolean[] flags = {false, false; boolean[] flags = {false, false; // signal that I m ready // yield to the other process while (flags[other] && turn==other) ; // wait for my turn // signal that I m ready // shared variable, yields first while (flags[other] && turn==other) ; // wait for my turn C/Java code machine language: register = other turn = register Proving Correctness mutual exclusion if one process is in critical section and another process tries to enter 2 nd process must be blocked if multiple processes are in entry code at most one process is allowed to enter critical section progress if no process is in critical section and a process arrives this process is if multiple processes are in entry code at least one process should be bounded waiting if process p i is in critical section and process p j is waiting to enter when p i leaves and tries to re enter, p j is allowed entry first Proving Correctness for Peterson s Solution mutual exclusion each process enters critical section only if either 1. flag[other] is false OR 2. turn = me if both processes were to be in critical section at the same time, both flag[me] and flag[other] must have been true therefore, only one process enters critical section since turn cannot both be me and other at the same time progress and bounded waiting process[me] cannot enter critical section because it s stuck in the while loop if process[other] is not ready to enter critical section, then flag[other] would be false > allowing process[me] to proceed if process[other] is ready, then flag[other] is true, 1. if turn is me, process[me] can enter 2. if turn is other, process[other] can enter as soon as process[other] is done, flag[other] is set to false > process[me] can enter, process[me] gets to go in before process[other] goes in again (if both want to) if process p i is in critical section and process p j is waiting to enter when p i leaves and tries to re enter, p j is allowed entry first 4

5 6.4 Synchronization Hardware Assistance uni processor system: as mentioned before, disable interrupts right before entering critical section > not easy for multiprocessor system (disable interrupts for all processors?) special hardware synchronization operators (some systems) basic atomic operators: load (read) and store (write) additional operators: test and set, swap, fetch and add 6.4 test and set read original value and replace with new value for the lock variable, imagine following C/C++ code boolean test_n_set(boolean* lock) { boolean return_value = *lock; * return return_value; code could be written as: boolean while (lock); > while (test_n_set(&lock)); lock = true 6.4 test and set strange looking code: where is test? if lock was true (locked by another process), it returns true if lock was false (free), it locks and returns false 6.4 swap swap the values in the two parameters imagine following C/C++ code void swap(boolean* lock1, boolean* lock2) { boolean tmp = *lock1; *lock1 = *lock2; *lock2 = tmp; code could be written as: boolean key = true; do { compare and swap(lock, key); while (!key); 6.4 fetch and add increment parameter by 1 imagine following C/C++ code var++; int fetch_n_add(int* var) { int return_value = *var; *var = return_value + 1; return return_value; can be useful for synchronization of more than 2 processes (semaphores in section 6.5) 6.4 fetch and add code could be written as: counter = 0; turn = 1; me = fetch and add(counter, dd( 1); while (me!= turn) ; fetch and add(turn, 1); 5