Carnegie Mellon Concurrency and Synchronization

Transcription

1 Concurrency and Synchronization CMPSCI 3: Computer Systems Principles

2 int pthread_join (pthread_t thread, void **value_ptr) { int result; ptw3_thread_t * tp = (ptw3_thread_t *) thread.p; if (NULL == tp thread.x!= tp>pthandle.x){ result = ESRCH; else if (PTHREAD_CREATE_DETACHED == tp>detachstate){ result = EINVAL; else { result = ; if (result == ) { result = pthreadcancelablewait (tp>threadh); *value_ptr = tp>exitstatus; result = pthread_detach (thread); return (result);

3 Typical way a function return two values int pthread_join (pthread_t thread, void **value_ptr) { int result; ptw3_thread_t * tp = (ptw3_thread_t *) thread.p; if (NULL == tp thread.x!= tp>pthandle.x){ result = ESRCH; else if (PTHREAD_CREATE_DETACHED == tp>detachstate){ result = EINVAL; else { result = ; if (result == ) { result = pthreadcancelablewait (tp>threadh); *value_ptr = tp>exitstatus; result = pthread_detach (thread); return (result); 3

4 Typical way a function return two values int pthread_join (pthread_t thread, void **value_ptr) { int result; ptw3_thread_t * tp = (ptw3_thread_t *) thread.p; if (NULL == tp thread.x!= tp>pthandle.x){ result = ESRCH; else if (PTHREAD_CREATE_DETACHED == tp>detachstate){ result = EINVAL; you need to use else { double pointer. result = ; if (result == ) { result = pthreadcancelablewait (tp>threadh); *value_ptr = tp>exitstatus; result = pthread_detach (thread); return (result); To change a pointer even outside of a function, 4

5 Concurrency and Synchronization CMPSCI 3: Computer Systems Principles 5

6 Today Sharing Mutual exclusion Semaphores 6

7 Shared Variables in Threaded C Programs Which variables in a threaded C program are shared? The answer is not as simple as global variables are shared and stack variables are private Def: A variable xis shared if and only if multiple threads reference some instance of x Requires answers to the following questions: What is the memory model for threads? How are instances of variables mapped to memory? How many threads might reference each of these instances? 7

8 Threads Memory Model Conceptual model: Multiple threads run within the context of a single process Each thread has its own separate thread context Thread ID, stack, stack pointer, PC, condition 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 8

9 Threads Memory Model Conceptual model: Multiple threads run within the context of a single process Each thread has its own separate thread context Thread ID, stack, stack pointer, PC, condition 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 Operationally, this model is not strictly enforced: Register values are truly separate and protected, but Any thread can read and write the stack of any other thread The mismatch between the conceptual and operation model is a source of confusion and errors 9

10 Example Program to Illustrate Sharing char **ptr; /* global */ int main() { long i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; /* thread routine */ void *thread(void *vargp) { long myid = (long)(vargp); static int cnt = ; printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); for (i = ; i < ; i++) pthread_create(&tid, NULL, thread, (void *)(i)); pthread_exit(null);

11 Example Program to Illustrate Sharing char **ptr; /* global */ int main() { long i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; for (i = ; i < ; i++) pthread_create(&tid, NULL, thread, (void *)(i)); pthread_exit(null); /* thread routine */ void *thread(void *vargp) { long myid = (long)(vargp); static int cnt = ; printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); pthread_exit vs pthread_join: Do you need further processing in main thread?

12 Example Program to Illustrate Sharing char **ptr; /* global */ int main() { long i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; /* thread routine */ void *thread(void *vargp) { long myid = (long)(vargp); static int cnt = ; printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); for (i = ; i < ; i++) pthread_create(&tid, NULL, thread, (void *)(i)); pthread_exit(null);

13 Example Program to Illustrate Sharing char **ptr; /* global */ int main() { long i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; for (i = ; i < ; i++) pthread_create(&tid, NULL, thread, (void *)(i)); pthread_exit(null); /* thread routine */ void *thread(void *vargp) { long myid = (long)(vargp); static int cnt = ; printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); static acts to extend the lifetime of a variable to the lifetime of the process 3

14 Example Program to Illustrate Sharing char **ptr; /* global */ int main() { long i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; /* thread routine */ void *thread(void *vargp) { long myid = (long)(vargp); static int cnt = ; printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); for (i = ; i < ; i++) pthread_create(&tid, NULL, thread, (void *)(i)); pthread_exit(null); 4

15 Example Program to Illustrate Sharing char **ptr; /* global */ int main() { long i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; for (i = ; i < ; i++) pthread_create(&tid, NULL, thread, (void *)(i)); pthread_exit(null); /* thread routine */ void *thread(void *vargp) { long myid = (long)(vargp); static int cnt = ; printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); Peer threads reference main thread s stack indirectly through global ptr variable 5

16 Mapping Variable Instances to Memory Global variables Def: Variable declared outside of a function Virtual memory contains exactly one instance of any global variable Local variables Def: Variable declared inside function without static attribute Each thread stack contains one instance of each local variable Local static variables Def: Variable declared inside function with the static attribute Virtual memory contains exactly one instance of any local static variable. 6

17 Mapping Variable Instances to Memory Global var: instance (ptr [data]) char **ptr; /* global */ int main() { int i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; /* 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); sharing.c printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); 7

18 Mapping Variable Instances to Memory Local vars: instance (i.m, msgs.m) char **ptr; /* global */ int main() { int i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; /* 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); sharing.c printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); 8

19 Mapping Variable Instances to Memory char **ptr; /* global */ int main() { int i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; Local var: instances ( myid.p [peer thread s stack], myid.p [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); sharing.c printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); 9

20 Mapping Variable Instances to Memory char **ptr; /* global */ int main() { int i; pthread_t tid; What if declare myid char *msgs[] static? = { "Hello from foo", "Hello from bar" ; ptr = msgs; Local var: instances ( myid.p [peer thread s stack], myid.p [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); sharing.c printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt);

21 Mapping Variable Instances to Memory char **ptr; /* global */ int main() { int i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; /* 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); sharing.c printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); Local static var: instance (cnt [data])

22 Mapping Variable Instances to Memory Global var: instance (ptr [data]) char **ptr; /* global */ int main() { int i; pthread_t tid; char *msgs[] = { "Hello from foo", "Hello from bar" ; ptr = msgs; Local vars: instance (i.m, msgs.m) Local var: instances ( myid.p [peer thread s stack], myid.p [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); sharing.c printf("[%d]: %s (svar=%d)\n", myid, ptr[myid], ++cnt); Local static var: instance (cnt [data])

23 Shared Variable Analysis Which variables are shared? Variable Referenced by Referenced by Referenced by instance main thread? peer thread? peer thread? ptr cnt i.m msgs.m myid.p myid.p yes yes yes no yes yes yes no no yes yes yes no yes no no no yes A variable xis shared iffmultiple threads reference at least one instance of x. Thus: ptr, cnt, and msgsare shared iand myidare notshared 3

24 Synchronizing Threads Shared variables are handy... but introduce the possibility of nasty synchronization errors. 4

25 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Thread routine */ void *thread(void *vargp vargp) { long i, niters = *((long *)vargp vargp); for (i = ; i < niters; i++ ++) cnt++; return NULL; /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c 5

26 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Thread routine */ void *thread(void *vargp vargp) { long i, niters = *((long *)vargp vargp); This guarantees the read/write actually happens for (i = ; i < niters; i++ ++) cnt++; return NULL; /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c 6

27 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Thread routine */ void *thread(void *vargp vargp) { long i, niters = *((long *)vargp vargp); for (i = ; i < niters; i++ ++) cnt++; return NULL; /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c 7

28 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); int main (int argc, char *argv argv[]) { pthread_t tid; for(int i=; i<; i++) { pthread_create(& (&tid tid, NULL, thread, &i); pthread_exit(null); return ; race.c Race /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c 8

29 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c int main (int argc, char *argv argv[]) { pthread_t tid; for(int i=; i<; i++) { pthread_create(& (&tid tid, NULL, thread, &i); pthread_exit(null); return ; race.c Race No Race 9

30 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Thread routine */ void *thread(void *vargp vargp) { long i, niters = *((long *)vargp vargp); for (i = ; i < niters; i++ ++) cnt++; return NULL; /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c 3

31 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Thread routine */ void *thread(void *vargp vargp) { long i, niters = *((long *)vargp vargp); for (i = ; i < niters; i++ ++) cnt++; return NULL; /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c 3

32 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Thread routine */ void *thread(void *vargp vargp) { long i, niters = *((long *)vargp vargp); for (i = ; i < niters; i++ ++) cnt++; return NULL; /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c 3

33 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c /* Thread routine */ void *thread(void *vargp vargp) { long i, niters = *((long *)vargp vargp); for (i = ; i < niters; i++ ++) cnt++; return NULL; linux>./badcnt OK cnt= linux>./badcnt BOOM! cnt=336 cntshouldequal,,. What went wrong? 33

34 Assembly Code for Counter Loop C code for counter loop in thread i for (i = ; i < niters; i++) cnt++; Asm code for thread i movq (%rdi), %rcx testq %rcx,%rcx jle.l movl $, %eax.l3: movq cnt(%rip),%rdx addq $, %rdx movq %rdx, cnt(%rip) addq $, %rax cmpq %rcx, %rax jne.l3.l: 34

35 Assembly Code for Counter Loop C code for counter loop in thread i for (i = ; i < niters; i++) cnt++; Asm code for thread i movq (%rdi), %rcx testq %rcx,%rcx jle.l movl $, %eax.l3: movq cnt(%rip),%rdx addq $, %rdx movq %rdx, cnt(%rip) addq $, %rax cmpq %rcx, %rax jne.l3.l: 35

36 Assembly Code for Counter Loop C code for counter loop in thread i for (i = ; i < niters; i++) cnt++; Asm code for thread i movq (%rdi), %rcx testq %rcx,%rcx jle.l movl $, %eax.l3: movq cnt(%rip),%rdx addq $, %rdx movq %rdx, cnt(%rip) addq $, %rax cmpq %rcx, %rax jne.l3.l: H i : Head 36

37 Assembly Code for Counter Loop C code for counter loop in thread i for (i = ; i < niters; i++) cnt++; Asm code for thread i movq (%rdi), %rcx testq %rcx,%rcx jle.l movl $, %eax.l3: movq cnt(%rip),%rdx addq $, %rdx movq %rdx, cnt(%rip) addq $, %rax cmpq %rcx, %rax jne.l3.l: H i : Head L i : Load cnt U i : Update cnt S i : Store cnt 37

38 Assembly Code for Counter Loop C code for counter loop in thread i for (i = ; i < niters; i++) cnt++; Asm code for thread i movq (%rdi), %rcx testq %rcx,%rcx jle.l movl $, %eax.l3: movq cnt(%rip),%rdx addq $, %rdx movq %rdx, cnt(%rip) addq $, %rax cmpq %rcx, %rax jne.l3.l: H i : Head L i : Load cnt U i : Update cnt S i : Store cnt T i : Tail 38

39 iclickerquestion Suppose that cntstarts with value, and that two threads each execute the code below once. What are the possible values for cnt afterward? A) Only B) or C) or or D) None of the above movq cnt(%rip),%rdx addq $, %rdx movq %rdx, cnt(%rip) 39

40 iclickerquestion solution Suppose that cntstarts with value, and that two threads each execute the code below once. What are the possible values for cnt afterward? A) Only B) or C) or or D) None of the above movq cnt(%rip),%rdx addq $, %rdx movq %rdx, cnt(%rip) 4

41 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! 4

42 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i %rdx %rdx cnt 4

43 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i %rdx %rdx cnt H 43

44 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i H L %rdx %rdx cnt 44

45 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i H L U %rdx %rdx cnt 45

46 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i H L U S %rdx %rdx cnt 46

47 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i H L U S H %rdx %rdx cnt 47

48 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i H L U S H L %rdx %rdx cnt 48

49 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i H L U S H L U %rdx %rdx cnt 49

50 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i H L U S H L U S %rdx %rdx cnt 5

51 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i H L U S H L U S T %rdx %rdx cnt 5

52 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i H L U S H L U S T T %rdx %rdx cnt 5

53 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i %rdx %rdx cnt H L U S H L U S T T OK 53

54 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i %rdx %rdx cnt H L U S H L U S T T OK Thread critical section Thread critical section 54

55 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i %rdx %rdx cnt 55

56 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i %rdx %rdx cnt H 56

57 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i H L %rdx %rdx cnt 57

58 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i H L U %rdx %rdx cnt 58

59 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i H L U H %rdx %rdx cnt 59

60 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i H L U H L %rdx %rdx cnt 6

61 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i H L U H L S %rdx %rdx cnt 6

62 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i H L U H L S T %rdx %rdx cnt 6

63 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i H L U H L S T U %rdx %rdx cnt 63

64 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i H L U H L S T U S %rdx %rdx cnt 64

65 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i %rdx %rdx cnt H L U H L S T U S T Oops! 65

66 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i %rdx %rdx cnt H L U H L S T U S T Oops! Thread critical section Thread critical section 66

67 Concurrent Execution Key idea: In general, any sequentially consistent interleaving is possible, but some give an unexpected result! I i denotes that thread iexecutes instruction I %rdx i is the content of %rdxin thread i s context i(thread) instr i %rdx %rdx cnt H L U S H L U S T T OK Thread critical section Thread critical section 67

68 Concurrent Execution (cont) Incorrect ordering: two threads increment the counter, but the result is instead of i(thread) instr i %rdx %rdx cnt H L U H L S T U S T Oops! Thread critical section Thread critical section 68

69 Concurrent Execution (cont) How about this ordering? i(thread) instr i H L H L U S U S T T %rdx %rdx cnt Oops! 69

70 Concurrent Execution (cont) How about this ordering? i(thread) instr i H L H L U S U S T T %rdx %rdx cnt Oops! We can analyze the behavior using a progress graph 7

71 Progress Graphs Thread T A progress graph depicts the discrete execution state space of concurrent threads. S U L H H L U S T Thread 7

72 Progress Graphs Thread T S A progress graph depicts the discrete execution state space of concurrent threads. Each axis corresponds to the sequential order of instructions in a thread. U L H H L U S T Thread 7

73 Progress Graphs Thread T S A progress graph depicts the discrete execution state space of concurrent threads. Each axis corresponds to the sequential order of instructions in a thread. U L H H L U S T Thread 73

74 Progress Graphs Thread T S U L A progress graph depicts the discrete execution state space of concurrent threads. Each axis corresponds to the sequential order of instructions in a thread. Each point corresponds to a possible execution state (Inst, Inst ). H H L U S T Thread 74

75 Progress Graphs Thread T S U L (L, S ) A progress graph depicts the discrete execution state space of concurrent threads. Each axis corresponds to the sequential order of instructions in a thread. Each point corresponds to a possible execution state (Inst, Inst ). H H L U S T Thread E.g., (L, S ) denotes state where thread has completed L and thread has completed S. 75

76 Trajectories in Progress Graphs Thread T S U A trajectoryis a sequenceof legal state transitionsthat describes one possibleconcurrent execution of the threads. Example: H, L, U, H, L, S, T, U, S, T L H H L U S T Thread 76

77 Critical Sections and Unsafe Regions critical section wrt cnt Thread T S U L, U, and S form acritical section with respect to the shared variable cnt Instructions in critical sections (wrtsome shared variable) shouldnot be interleaved L H H L U S T Thread critical section wrt cnt 77

78 Critical Sections and Unsafe Regions critical section wrt cnt Thread T S U L Unsafe region L, U, and S form acritical section with respect to the shared variable cnt Instructions in critical sections (wrtsome shared variable) shouldnot be interleaved Sets of states where such interleaving occurs form unsafe regions H H L U S T Thread critical section wrt cnt 78

79 Critical Sections and Unsafe Regions Thread safe T Def:A trajectory is safe iffit does not enter any unsafe region critical section wrt cnt S U Unsafe region Claim: A trajectory is correct (wrt cnt) iffit is safe L H H L U S T Thread critical section wrt cnt 79

80 Critical Sections and Unsafe Regions Thread safe T Def:A trajectory is safe iffit does not enter any unsafe region critical section wrt cnt S U L Unsafe region unsafe Claim: A trajectory is correct (wrt cnt) iffit is safe H H L U S T Thread critical section wrt cnt 8

81 iclicker question Thread T Using the program graph, classify the following trajectories as either safe or unsafe. ) H L U S H L U S T T ) H L H L U S T U S T 3) H H L U S L U S T T critical section wrt cnt S U Unsafe region A. ) Safe ) Safe 3) Safe B. ) Unsafe ) Unsafe 3) Unsafe C. ) Safe ) Unsafe 3) Safe D. ) Safe ) Unsafe 3) Unsafe L H H L U S T Thread critical section wrt cnt 8

82 iclicker question solution Thread T Using the program graph, classify the following trajectories as either safe or unsafe. ) H L U S H L U S T T ) H L H L U S T U S T 3) H H L U S L U S T T critical section wrt cnt S U Unsafe region A. ) Safe ) Safe 3) Safe B. ) Unsafe ) Unsafe 3) Unsafe C. ) Safe ) Unsafe 3) Safe D. ) Safe ) Unsafe 3) Unsafe L H H L U S T Thread critical section wrt cnt 8

83 Enforcing Mutual Exclusion Question: How can we guarantee a safe trajectory? Answer: We must synchronizetheexecution of the threads so that they can never have an unsafe trajectory. i.e., need to guarantee mutually exclusive access for each critical section. 83

84 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n", n", cnt); else printf("ok cnt=%ld\n", n", cnt); exit(); badcnt.c /* Thread routine */ void *thread(void *vargp vargp) { long i, niters = *((long *)vargp vargp); for (i = ; i < niters; i++ ++) cnt++; return NULL; linux>./badcnt OK cnt= linux>./badcnt BOOM! cnt=336 cntshouldequal,,. What went wrong? 84

85 Enforcing Mutual Exclusion Question: How can we guarantee a safe trajectory? Answer: We must synchronizetheexecution of the threads so that they can never have an unsafe trajectory. i.e., need to guarantee mutually exclusive access for each critical section. Classic solution: Semaphores (Edsger Dijkstra) Other approaches (out of our scope) Mutex and condition variables (Pthreads) Monitors (Java) 85

86 Semaphores Semaphore: nonnegative global integer synchronization variable. 86

87 Semaphores Semaphore: nonnegative global integer synchronization variable. semaphore 87

88 Semaphores Semaphore: nonnegative global integer synchronization variable. semaphore 88

89 Semaphores Semaphore: nonnegative global integer synchronization variable. semaphore 89

90 Semaphores Semaphore: nonnegative global integer synchronization variable semaphore 9

91 Semaphores Semaphore: nonnegative global integer synchronization variable. semaphore 9

92 Semaphores Semaphore: nonnegative global integer synchronization variable. 9

93 Semaphores Semaphore: nonnegative global integer synchronization variable. 93

94 Semaphores Semaphore: nonnegative global integer synchronization variable. Manipulated by Pand Voperations. P(s) If sis nonzero, then decrement sby and return immediately. Test and decrement operations occur atomically (indivisibly) If sis zero, then suspend thread until sbecomes nonzero and the thread is restarted by a V operation. After restarting, the P operation decrements sand returns control to the caller. V(s): Increment sby. Increment operation occurs atomically If there are any threads blocked in a P operation waiting for sto become nonzero, then restart exactly one of those threads, which then completes its P operation by decrementing s. 94

95 Semaphores Semaphore: nonnegative global integer synchronization variable. Manipulated by Pand Voperations. P(s) If sis nonzero, then decrement sby and return immediately. Test and decrement operations occur atomically (indivisibly) If sis zero, then suspend thread until sbecomes nonzero and the thread is restarted by a V operation. After restarting, the P operation decrements sand returns control to the caller. V(s): Increment sby. Increment operation occurs atomically If there are any threads blocked in a P operation waiting for sto become nonzero, then restart exactly one of those threads, which then completes its P operation by decrementing s. Semaphore invariant: (s >= ) 95

96 C Semaphore Operations Pthreads functions: #include <semaphore.h> int sem_init(sem_t *s,, unsigned int val); /* s = val */ int sem_wait(sem_t *s); /* P(s) */ int sem_post(sem_t *s); /* V(s) */ 96

97 badcnt.c: Improper Synchronization /* Global shared variable */ volatile long cnt = ; /* Counter */ int main(int int argc, char **argv argv) { long niters; pthread_t tid, tid; niters = atoi(argv[]); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_create(&tid, NULL, thread, &niters niters); Pthread_join(tid, NULL); Pthread_join(tid, NULL); /* Thread routine */ void *thread thread(void *vargp vargp) { long i, niters = *(( ((long *)vargp vargp); for (i = ; i < niters; i++ ++) cnt++; return NULL; /* Check result */ if (cnt!= ( * niters)) printf("boom! cnt=%ld\n" n", cnt); else printf("ok cnt=%ld\n" n", cnt); exit(); badcnt.c How can we fix this using semaphores? 97

98 Using Semaphores for Mutual Exclusion Basic idea: Associate a unique semaphore mutex, initially, with each shared variable (or related set of shared variables). Surround corresponding critical sections with P(mutex)and V(mutex) operations. 98

99 Using Semaphores for Mutual Exclusion Basic idea: Associate a unique semaphore mutex, initially, with each shared variable (or related set of shared variables). Surround corresponding critical sections with P(mutex)and V(mutex) operations. Terminology: Binary semaphore: semaphore whose value is always or Mutex: binary semaphore used for mutual exclusion P operation: locking the mutex V operation: unlocking or releasing the mutex Holding a mutex: locked and not yet unlocked. Counting semaphore: used as a counter for set of available resources. 99

100 goodcnt.c:proper Synchronization Define and initialize a mutex for the shared variable cnt: volatile long cnt = ; /* Counter */ sem_t mutex; /* Semaphore that protects cnt */ sem_init em_init(&mutex,, ); /* mutex = */ Surround critical section with Pand V: for (i = ; i < niters; i++) { sem_wait(&mutex); mutex); cnt++; sem_post(&mutex); mutex); goodcnt.c linux>./goodcnt OK cnt= linux>./goodcnt OK cnt=

101 goodcnt.c:proper Synchronization Define and initialize a mutex for the shared variable cnt: volatile long cnt = ; /* Counter */ sem_t mutex; /* Semaphore that protects cnt */ sem_init em_init(&mutex,, ); /* mutex = */ Surround critical section with Pand V: for (i = ; i < niters; i++) { sem_wait(&mutex); mutex); cnt++; sem_post(&mutex); mutex); goodcnt.c linux>./goodcnt OK cnt= linux>./goodcnt OK cnt= Warning: It s orders of magnitude slower than badcnt.c.

102 Why MutexesWork Thread T V(s) S U Unsafe region Provide mutually exclusive access to shared variable by surrounding critical section with Pand Voperations on semaphore s(initially set to ) L P(s) H Thread H P(s) L U S V(s) T

103 Why MutexesWork Thread T V(s) S U Unsafe region Provide mutually exclusive access to shared variable by surrounding critical section with Pand Voperations on semaphore s(initially set to ) L P(s) H Initially s = Thread H P(s) L U S V(s) T 3

104 Why MutexesWork Thread T V(s) S U Unsafe region Provide mutually exclusive access to shared variable by surrounding critical section with Pand Voperations on semaphore s(initially set to ) L P(s) H Initially s = Thread H P(s) L U S V(s) T 4

105 Why MutexesWork Thread T V(s) S U Unsafe region Provide mutually exclusive access to shared variable by surrounding critical section with Pand Voperations on semaphore s(initially set to ) L P(s) Impossible H Initially s = Thread H P(s) L U S V(s) T 5

106 Why MutexesWork Thread T V(s) S U L P(s) Forbidden region Unsafe region Impossible Provide mutually exclusive access to shared variable by surrounding critical section with Pand Voperations on semaphore s(initially set to ) Semaphore invariant creates a forbidden region that encloses unsafe region and that cannot be entered by any trajectory. H Initially s = Thread H P(s) L U S V(s) T 6

107 Summary Programmers need a clear model of how variables are shared by threads. Variables shared by multiple threads must be protected to ensure mutually exclusive access. Semaphores are a fundamental mechanism for enforcing mutual exclusion. 7