Process Synchroniza/on

Transcription

1 Process Synchroniza/on Andrew Case Slides adapted from Mohamed Zahran, Clark Barre9, Jinyang Li, Randy Bryant and Dave O Hallaron

2 Topics Sharing data Race condi/ons Mutual exclusion and semaphores Sample problems Deadlocks

3 Mul/Threaded process A process can have mul/ple threads Each thread has its own logical control flow (PC, registers, etc.) Each thread shares the same code, data, and kernel context Shared code and data Thread (main thread) stack shared libraries Thread (peer thread) stack Thread context: Data registers Condition codes SP PC run-time heap read/write data read-only code/data Kernel context: VM structures Descriptor table brk pointer Thread context: Data registers Condition codes SP PC 3

4 Threads Memory Model Conceptual model: MulMple threads run within the context of a single process Each thread has its own separate thread context Thread ID, stack, stack pointer, PC, condimon codes, and GP registers All threads share the remaining process context Code, data, heap, and shared library segments of the process virtual address space Open files and installed handlers Opera/onally, this model is not strictly enforced: Register values are protected, but Any thread can read and write to enmre virtual address space (any threads stack) 4

5 Mapping Variable Instances to Memory Global variables Def: Variable declared outside of a funcmon Virtual memory contains exactly one instance of any global variable Local variables Def: Variable declared inside funcmon without static a9ribute Each thread stack contains one instance of each local variable Local sta/c variables Def: Variable declared inside funcmon with the static a9ribute Virtual memory contains exactly one instance of any local sta/c variable. 5

6 Mapping Variable Instances to Memory Global var: instance in data memory Local vars: instance in main thread stack linux>./a.out []: Hello from foo (cnt=) []: Hello from foo (cnt=) char **ptr; /* global */ int main() { int i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; Local var: instances ( myid in peer thread s stack, myid in peer thread s stack ) /* thread routine */ void *thread(void *vargp) { int myid = (int)vargp; static int cnt = ; for (i = ; i < ; i++) pthread_create(&tid, NULL, thread, (void *)i); Pthread_exit(NULL); printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); Local sta-c var: instance in data memory 6

7 Problem: Race condi/ons A race condi-on occurs when correctness of the program depends on one thread or process reaching point x before another thread or process reaches point y Any ordering of instruc/ons from mul/ple threads may occur race.c 7

8 Race Condi/on: Example How can we fix it? int main() { int cnt; for (cnt = ; cnt < ; cnt++) { /* send an cnt to each thread */ pthread_create(&tid, NULL, thread, &cnt); void *thread(void *p) { int i = *((int *)p); /* cast to an int ptr and de-ref */ pthread_detach(pthread_self()); save_value(i); /* do something with the count */ return NULL; Race Test If no race, then each thread would get different value of cnt Set of saved values would consist of one copy each of through 99. 8

9 Race Condi/on: Example :int cnt; :for (cnt = ; cnt < ; cnt++) { 3: pthread_create(&tid, NULL, thread, &cnt); 4: 5:void *thread(void *p) { 6: int i = *((int *)p); 7: pthread_detach(pthread_self()); 8: save_value(i); 9: return NULL; : Line of code run Main thread Worker thread i (in thread) cnt Problem: i in worker thread should have been set to 9

10 Experimental Results No Race Single core laptop Mul/core server (Number of /mes each value is saved) The race can really happen!

11 Race Condi/on: Fixed! int main() { int cnt; for (cnt = ; cnt < ; cnt++) { int *j = malloc(sizeof(int)); /* create separate var */ *j = cnt; /* for each thread */ pthread_create(&tid, NULL, thread, j); void *thread(void *p) { int i = *((int *)p); free(p); /* free it when done */ pthread_detach(pthread_self()); save_value(i); return NULL;

12 Race Condi/on: Problem : int cnt; : for (cnt = ; cnt < ; cnt++) { 3: int *j = malloc(sizeof(int)); 4: *j = cnt; 5: pthread_create(&tid, NULL, thread, j); 6: Line of code 3 Main thread Worker thread i Cnt (worker)(global) *j? *p 7: void *thread(void *p) { 8: int i = *((int *)p); 9: free(p); : pthread_detach(pthread_self()); : save_value(i); : return NULL; 3:

13 Topics Sharing data Race condi/ons Mutual exclusion and Semaphores Sample problems Deadlocks 3

14 Improper Synchroniza/on: badcnt.c volatile int cnt = ; /* global */ int main(int argc, char **argv) { int niters = atoi(argv[]); pthread_t tid, tid; pthread_create(&tid, NULL, thread, &niters); pthread_create(&tid, NULL, thread, &niters); pthread_join(tid, NULL); pthread_join(tid, NULL); /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%d\n, cnt); else printf("ok cnt=%d\n", cnt); exit(); /* Thread routine */ void *thread(void *vargp) { /* local data */ int i; int niters = *((int *)vargp); for (i = ; i < niters; i++) cnt++; /* shared data */ return NULL; linux>./badcnt OK cnt= linux>./badcnt BOOM! cnt=35 linux> cnt should equal,. What went wrong? 4

15 Assembly Code for Counter Loop C code for counter loop in thread i for (i=; i < niters; i++) cnt++; /* changing shared data */ Corresponding assembly code.l: movl (%rdi),%ecx movl $,%edx cmpl %ecx,%edx jge.l3 Head (loop itera/on) Cri/cal Regions: changing shared data movl cnt(%rip),%eax incl %eax movl %eax,cnt(%rip) Load cnt Update cnt Store cnt.l3: incl %edx cmpl %ecx,%edx jl.l Tail (loop itera/on) 5

16 Concurrent Execu/on Any sequen/ally consistent interleaving is possible X i denotes that thread i executes instrucmon X %eax i is the content of %eax in thread i s context Thread cri/cal sec/on i (thread) instr i %eax %eax cnt H L U S H L U S T T OK Thread cri/cal sec/on H head L Load U Update S Store T tail 6

17 Concurrent Execu/on (cont) Race condi/on: two threads increment the counter, but the result is instead of i (thread) instr i %eax %eax cnt H L U H L S T U S T Oops! Thread cri/cal sec/on Thread cri/cal sec/on H head L Load U Update S Store T tail 7

18 Concurrent Execu/on (cont) How about this ordering? i (thread) instr i %eax %eax cnt H L H L U S U S T T How do we fix it?! Oops! Thread cri/cal sec/on Thread cri/cal sec/on H head L Load U Update S Store T tail 8

19 Enforcing Mutual Exclusion Answer: We must synchronize the execu/on of the threads so that cri/cal regions are run sequen/ally. i.e., need to guarantee mutually exclusive access to crimcal regions Classic solu/on: Semaphores (Dijkstra) Other approaches (out of our scope) Pthread Mutexes and condimon variables Monitors (Java) 9

20 Semaphores Semaphore: nonnega/ve global integer synchroniza/on variable Manipulated by P and V opera/ons: P(s): [ while (s == ) wait(); s--; ] Dutch for "Proberen" (test) Used to gain access to a shared resource AKA: down, wait V(s): [ s++; ] Dutch for "Verhogen" (increment) Used to release access of a shared resource AKA: up, post [ ] indicates an atomic opera/on performed by the OS Guarantees these are run as if it was one instrucmons Only one P or V operamon at a Mme can modify s.

21 Using Semaphores for Mutual Exclusion Basic idea: Associate a unique semaphore mutex with each shared resource (e.g. a variable) Surround corresponding crimcal secmons with P(mutex)/wait() and V(mutex)/post() operamons. Terminology: Binary semaphore: semaphore whose value is always or Mutex: binary semaphore used for mutual exclusion P()/wait() operamon: locking the mutex V()/post() operamon: unlocking or releasing the mutex Holding a mutex/resource: locked and not yet unlocked.

22 C Semaphore Opera/ons Pthreads func/ons: #include <semaphore.h> shared between threads (as opposed to processes) /* creating a semaphore */ int sem_init(sem_t *sem,, unsigned int val); /* s = val */ /* using a semaphore */ int sem_wait(sem_t *sem); /* P(s): try to claim a resource */ int sem_post(sem_t *sem); /* V(s): release a resource */ Number of resources available (how many threads can access the data at any given /me)

23 Improper Synchroniza/on: badcnt.c volatile int cnt = ; /* global */ int main(int argc, char **argv) { int niters = atoi(argv[]); pthread_t tid, tid; pthread_create(&tid, NULL, thread, &niters); pthread_create(&tid, NULL, thread, &niters); pthread_join(tid, NULL); pthread_join(tid, NULL); /* Thread routine */ void *thread(void *vargp) { /* local data */ int i, niters = *((int *)vargp); for (i = ; i < niters; i++) cnt++; /* shared data */ return NULL; /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%d\n, cnt); else printf("ok cnt=%d\n", cnt); exit(); How can we fix this using semaphores? 3

24 Proper Synchroniza/on: goodcnt.c Define and ini/alize a mutex for the shared variable cnt: volatile int cnt = ; /* Counter */ sem_t mutex; /* Semaphore that protects cnt */ sem_init(&mutex,, ); /* mutex= (only access at a time) */ Surround cri/cal sec/on with P and V: for (i = ; i < niters; i++) { sem_wait(&mutex); /* P() */ cnt++; sem_post(&mutex); /* V() */ linux>./goodcnt OK cnt= linux>./goodcnt OK cnt= linux> Note: much slower than badcnt.c 4

25 Sample Problems Readerswriters problem Producerconsumer problem 5

26 ReadersWriters Problem Problem statement: Reader threads only read the object Writer threads modify the object Writers must have exclusive access to the object Unlimited number of readers can access the object Examples: Online airline reservamon system MulMthreaded caching Web proxy Banking somware 6

27 Variants of ReadersWriters First readerswriters problem (favors readers) No reader should be kept waimng unless a writer has already been granted permission to use the object. A reader that arrives amer a waimng writer gets priority over the writer. Second readerswriters problem (favors writers) Once a writer is ready to write, it performs its write as soon as possible A reader that arrives amer a writer must wait, even if the writer is also waimng. Starva-on (where a thread waits indefinitely) is possible in both cases. 7

28 Solu/on to First ReadersWriters Problem Readers: int readcnt; /* Initially */ sem_t mutex, w; /* Both set to */ void reader(void) { while () { /* am I the first reader in? */ /* if so, try to lock mutex */ /* to exclude writer */ /* do some reading */ void writer(void) { while () { /* try to lock mutex */ /* to exclude readers */ Writers: /* do some writing */ /* unlock mutex */ /* am I the last reader out? */ /* if so, unlock mutex */ 8

29 Solu/on to First ReadersWriters Problem Readers: int readcnt; /* Initially */ sem_t mutex, w; /* Both initially */ void reader(void) { while () { sem_wait(&mutex); readcnt++; if (readcnt == ) /* First in */ sem_wait(&w); sem_post(&mutex); /* Reading happens here */ Writers: void writer(void) { while () { sem_wait(&w); /* Writing here */ sem_post(&w); rw.c sem_wait(&mutex); readcnt--; if (readcnt == ) /* Last out */ sem_post(&w); sem_post(&mutex); 9

30 Sample Problems Readerswriters problem Producerconsumer problem 3

31 ProducerConsumer Problem producer thread shared buffer consumer thread Common synchroniza/on pamern: Producer waits for empty slot, inserts item in buffer, and nomfies consumer Consumer waits for item, removes it from buffer, and nomfies producer Examples MulMmedia processing: Producer creates MPEG video frames, consumer renders them Eventdriven graphical user interfaces Producer detects mouse clicks, mouse movements, and keyboard hits and inserts corresponding events in buffer Consumer retrieves events from buffer and paints the display 3

32 ProducerConsumer on element Buffer #include csapp.h #define NITERS 5 void *producer(void *arg); void *consumer(void *arg); struct { int buf; /* shared var */ sem_t full; /* sems */ sem_t empty; shared; int main() { pthread_t tid_producer; pthread_t tid_consumer; /* Initialize the semaphores */ sem_init(&shared.empty,, ); sem_init(&shared.full,, ); /* Create threads and wait */ pthread_create(&tid_producer, NULL, producer, NULL); pthread_create(&tid_consumer, NULL, consumer, NULL); pthread_join(tid_producer, NULL); pthread_join(tid_consumer, NULL); exit(); 3

33 ProducerConsumer on element Buffer Ini/ally: empty==, full== Producer Thread void *producer(void *arg) { int i, item; Consumer Thread void *consumer(void *arg) { int i, item; for (i = ; i < NITERS; i++) { /* Produce item */ item = i; printf("produced %d\n, item); /* Write item to buf */ sem_wait(&shared.empty); shared.buf = item; sem_post(&shared.full); return NULL; for (i = ; i < NITERS; i++) { /* Read item from buf */ sem_wait(&shared.full); item = shared.buf; sem_post(&shared.empty); /* Consume item */ printf("consumed %d\n, item); return NULL; 33

34 ProducerConsumer on an nelement Buffer Requires a mutex and two coun/ng semaphores: mutex: enforces mutually exclusive access to the the buffer slots: counts the available slots in the buffer items: counts the available items in the buffer Implemented using a shared buffer 34

35 ProducerConsumer w/ Shared Buffer Producerconsumer pamern: Producer inserts item in buffer (waits if buffer is full) Consumer removes item from buffer (waits if buffer is empty) Producer Producer threads Producer threads threads Shared Buffer Producer Producer threads Producer threads threads Examples: Network server Producer threads read from sockets and put client request on buffer Consumer threads process clients requests from buffer 35

36 Topics Sharing data Race condi/ons Mutual exclusion and semaphores Sample problems Deadlocks 36

37 Problem: Deadlocks Def: A process is deadlocked if it is wai/ng for a condi/on that will never be occur. Typical Scenario Processes and Process both need the same two resources (A and B) Process acquires A, waits for B Process acquires B, waits for A Both will wait forever! 37

38 Deadlocking With Semaphores int main() { pthread_t tid[]; sem_init(&mutex[],, ); /* mutex[] = */ sem_init(&mutex[],, ); /* mutex[] = */ pthread_create(&tid[], NULL, worker, (void*) ); /* Lock - */ pthread_create(&tid[], NULL, worker, (void*) ); /* Lock - */ pthread_join(tid[], NULL); pthread_join(tid[], NULL); exit(); void *worker(void *x) { int id = (int) x; sem_wait(&mutex[id]); sem_wait(&mutex[-id]); // Do something sem_post(&mutex[id]); sem_post(&mutex[-id]); return NULL; Tid[]: P(s ); P(s ); V(s ); V(s ); Tid[]: P(s ); P(s ); V(s ); V(s ); 38

39 Avoiding Deadlock with Semaphores Acquire shared resources in same order Release resources in same reverse order int main() { pthread_t tid[]; sem_init(&mutex[],, ); /* mutex[] = */ sem_init(&mutex[],, ); /* mutex[] = */ pthread_create(&tid[], NULL, worker, (void*) ); /* Lock - */ pthread_create(&tid[], NULL, worker, (void*) ); /* Lock - */ pthread_join(tid[], NULL); pthread_join(tid[], NULL); exit(); void *worker(void *x) { int id = (int) x; sem_wait(&mutex[id]); sem_wait(&mutex[-id]); // Do something sem_post(&mutex[id]); sem_post(&mutex[-id]); return NULL; Tid[]: P(s ); P(s ); V(s ); V(s ); Tid[]: P(s ); P(s ); V(s ); V(s ); 39

40 Threads Summary Threads are were growing in popularity Pros: Somewhat cheaper than processes Easy to share data between threads Cons: Easy to share data between threads Easy to introduce subtle synchronizamon errors Shares variables must be protected to ensure mutually exclusive access Semaphores provide one solumon 4