Locks and semaphores. Johan Montelius KTH

Transcription

1 Locks and semaphores Johan Montelius KTH / 40

2 recap, what s the problem : # include < pthread.h> volatile int count = 0; void * hello ( void * arg ) { for ( int i = 0; i < 10; i ++) { count ++; } } int main () { pthread_t p1, p2; } pthread_ create (& p1, NULL, hello, NULL ); pthread_ create (& p2, NULL, hello, NULL ); : 2 / 40

3 Peterson s algorithm int request [2] = {0,0}; int turn = 0; int lock ( int id) { request [id] = 1; int other = 1-id; turn = other ; while ( request [ other ] == 1 && turn == other ) {}; // spin } return 1; void release ( int id) { request [id] = 0; } 3 / 40

4 Total Store Order P1 P2 4 / 40

5 Total Store Order P1 P2 a b / 40

6 Total Store Order P1 P2 a = 1 a b / 40

7 Total Store Order P1 P2 a b 0 0 a = 1 b = / 40

8 Total Store Order P1 P2 a b 0 0 a = 1 b = 1 read b read a / 40

9 Total Store Order P1 P2 a b 0 0 a = 1 b = 1 read b read a / 40

10 atomic memory operations 5 / 40

11 atomic memory operations All CPU:s provide several versions of atomic operations that both read and write to a memory element in one atomic operation. test-and-set: swap i.e. read and write to a memory location, the simplest primitive 5 / 40

12 atomic memory operations All CPU:s provide several versions of atomic operations that both read and write to a memory element in one atomic operation. test-and-set: swap i.e. read and write to a memory location, the simplest primitive fetch-and-add/and/xor/... : update the value with a given operation, more flexible 5 / 40

13 atomic memory operations All CPU:s provide several versions of atomic operations that both read and write to a memory element in one atomic operation. test-and-set: swap i.e. read and write to a memory location, the simplest primitive fetch-and-add/and/xor/... : update the value with a given operation, more flexible compare-and-swap : if the memory location contains a specific value then swap 5 / 40

14 try to lock by swap int try ( int * lock ) { return sync_val_compare_and_swap (lock, 0, 1); } 6 / 40

15 try to lock by swap int try ( int * lock ) { return sync_val_compare_and_swap (lock, 0, 1); } pushq % rbp movq %rsp, % rbp movq %rdi, -8(% rbp ) movq -8(% rbp ), % rdx movl $0, % eax movl $1, % ecx lock cmpxchgl % ecx, (% rdx ) nop popq % rbp ret 6 / 40

16 try to lock by swap int try ( int * lock ) { return sync_val_compare_and_swap (lock, 0, 1); } pushq % rbp movq %rsp, % rbp movq %rdi, -8(% rbp ) movq -8(% rbp ), % rdx movl $0, % eax movl $1, % ecx lock cmpxchgl % ecx, (% rdx ) nop popq % rbp ret This is using GCC extensions to C, similar extensions available in all compilers. 6 / 40

17 a spin-lock int lock ( int * lock ) { while ( try ( lock )!= 0) {} } return 1; 7 / 40

18 a spin-lock int lock ( int * lock ) { while ( try ( lock )!= 0) {} } return 1; void release ( int * lock ) { * lock = 0; } 7 / 40

19 finally - we re in control int global = 0; int count = 0; void * hello ( void * name ) { for ( int i = 0; i < 10; i ++) { lock (& global ); count ++; release (& global ); } } 8 / 40

20 spin locks 9 / 40

21 spin locks 9 / 40

22 avoid spinning We need to talk to the operating system. 10 / 40

23 avoid spinning We need to talk to the operating system. void lock ( int * lock ) { } while ( try ( lock )!= 0) { sched_yield (); // in Linux } 10 / 40

24 Wham -... For how long should we sleep? 11 / 40

25 Wham -... For how long should we sleep? 11 / 40

26 Wham -... For how long should we sleep? We would like to be woken up as the lock is released - before you go-go. 11 / 40

27 a detour in Sun Solaris void lock ( lock_t *m) { while ( try (m-> guard )!= 0) {}; if(m-> flag == 0) { m-> flag = 1; m-> guard = 0; } else { queue_add (m-> queue, gettid ()); m-> guard = 0; park (); } 12 / 40

28 a detour in Sun Solaris void lock ( lock_t *m) { while ( try (m-> guard )!= 0) {}; void unlock ( lock_t *m) { while ( try (m-> guard )!= 0) {}; if(m-> flag == 0) { m-> flag = 1; m-> guard = 0; } else { queue_add (m-> queue, gettid ()); m-> guard = 0; park (); } } if( empty (m-> queue )) { m-> flag = 0; } else { unpark ( dequeue (m-> queue )); } m-> guard = 0; 12 / 40

29 it s not easy It s not easy to to get it right. /* m-> flag == 1 */ : queue_add (m-> queue, gettid ()); m-> guard = 0; park (); // when I wake up the flag is set if( empty (m-> queue )) { m-> flag = 0; } else { // don t reset the flag unpark ( dequeue (m-> queue )); } 13 / 40

30 it s not easy It s not easy to to get it right. /* m-> flag == 1 */ : queue_add (m-> queue, gettid ()); setpark (); // if somone unparks now my park () is a noop m-> guard = 0; park (); if( empty (m-> queue )) { m-> flag = 0; } else { // don t reset the flag unpark ( dequeue (m-> queue )); } 13 / 40

31 back to Linux 14 / 40

32 back to Linux Introducing futex: fast user space mutex. 14 / 40

33 back to Linux Introducing futex: fast user space mutex. futex_wait(mutex, val) : suspend on the mutex if its equal to val. futex_wake(mutex) : wake one of the treads suspended on the mutex 14 / 40

34 back to Linux Introducing futex: fast user space mutex. futex_wait(mutex, val) : suspend on the mutex if its equal to val. futex_wake(mutex) : wake one of the treads suspended on the mutex In GCC you have to call them using a syscall() 14 / 40

35 a futex lock void lock ( volatile int * lock ) { while ( try ( lock )!= 0) { // time to sleep... futex_wait (lock, 1); } } 15 / 40

36 a futex lock void lock ( volatile int * lock ) { while ( try ( lock )!= 0) { // time to sleep... futex_wait (lock, 1); } } void unlock ( volatile int * lock ) { * lock = 0; futex_wake ( lock ); } 15 / 40

37 a futex lock void lock ( volatile int * lock ) { while ( try ( lock )!= 0) { // time to sleep... futex_wait (lock, 1); } } void unlock ( volatile int * lock ) { * lock = 0; futex_wake ( lock ); } Not very efficient - we want to avoid calling futex_wait() if no one is waiting. 15 / 40

38 pthread mutex Using Linux futex or Sun park/unpark directly is error prone and not very portable. 16 / 40

39 pthread mutex Using Linux futex or Sun park/unpark directly is error prone and not very portable. It s better to use the pthread library API, probably more efficient and definitely less problems. 16 / 40

40 pthread mutex Using Linux futex or Sun park/unpark directly is error prone and not very portable. It s better to use the pthread library API, probably more efficient and definitely less problems. Introducing pthread mutex locks: pthread_mutex_t : structure that is the mutex 16 / 40

41 pthread mutex Using Linux futex or Sun park/unpark directly is error prone and not very portable. It s better to use the pthread library API, probably more efficient and definitely less problems. Introducing pthread mutex locks: pthread_mutex_t : structure that is the mutex pthread_mutex_init(pthread_mutex_t *mutex,... *attr) 16 / 40

42 pthread mutex Using Linux futex or Sun park/unpark directly is error prone and not very portable. It s better to use the pthread library API, probably more efficient and definitely less problems. Introducing pthread mutex locks: pthread_mutex_t : structure that is the mutex pthread_mutex_init(pthread_mutex_t *mutex,... pthread_mutex_destroy(pthread_mutex_t *mutex) *attr) 16 / 40

43 pthread mutex Using Linux futex or Sun park/unpark directly is error prone and not very portable. It s better to use the pthread library API, probably more efficient and definitely less problems. Introducing pthread mutex locks: pthread_mutex_t : structure that is the mutex pthread_mutex_init(pthread_mutex_t *mutex,... pthread_mutex_destroy(pthread_mutex_t *mutex) pthread_mutex_lock(pthread_mutex_t *mutex) *attr) 16 / 40

44 pthread mutex Using Linux futex or Sun park/unpark directly is error prone and not very portable. It s better to use the pthread library API, probably more efficient and definitely less problems. Introducing pthread mutex locks: pthread_mutex_t : structure that is the mutex pthread_mutex_init(pthread_mutex_t *mutex,... pthread_mutex_destroy(pthread_mutex_t *mutex) pthread_mutex_lock(pthread_mutex_t *mutex) pthread_mutex_unlock(pthread_mutex_t *mutex) *attr) 16 / 40

45 pthread mutex Using Linux futex or Sun park/unpark directly is error prone and not very portable. It s better to use the pthread library API, probably more efficient and definitely less problems. Introducing pthread mutex locks: pthread_mutex_t : structure that is the mutex pthread_mutex_init(pthread_mutex_t *mutex,... pthread_mutex_destroy(pthread_mutex_t *mutex) pthread_mutex_lock(pthread_mutex_t *mutex) pthread_mutex_unlock(pthread_mutex_t *mutex) *attr) 16 / 40

46 pthread mutex Using Linux futex or Sun park/unpark directly is error prone and not very portable. It s better to use the pthread library API, probably more efficient and definitely less problems. Introducing pthread mutex locks: pthread_mutex_t : structure that is the mutex pthread_mutex_init(pthread_mutex_t *mutex,... pthread_mutex_destroy(pthread_mutex_t *mutex) pthread_mutex_lock(pthread_mutex_t *mutex) pthread_mutex_unlock(pthread_mutex_t *mutex) *attr) The lock procedure is platform specific, normally implemented as a combination of spinning and yield. 16 / 40

47 What could go wrong? 17 / 40

48 What could go wrong? Nothing works, will not even compile. 17 / 40

49 What could go wrong? Nothing works, will not even compile. Deadlock: the execution is stuck, no thread is making progress. 17 / 40

50 What could go wrong? Nothing works, will not even compile. Deadlock: the execution is stuck, no thread is making progress. Livelock: we re moving around in circles, all threads think that they are doing progress but we re stuck in a loop. 17 / 40

51 What could go wrong? Nothing works, will not even compile. Deadlock: the execution is stuck, no thread is making progress. Livelock: we re moving around in circles, all threads think that they are doing progress but we re stuck in a loop. Starvation: we re making progress but some threads are stuck waiting. 17 / 40

52 What could go wrong? Nothing works, will not even compile. Deadlock: the execution is stuck, no thread is making progress. Livelock: we re moving around in circles, all threads think that they are doing progress but we re stuck in a loop. Starvation: we re making progress but some threads are stuck waiting. Unfairness: we re making progress but some threads are given more of the resources. 17 / 40

53 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: M: L: / 40

54 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: M: L: / 40

55 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: M: L: / 40

56 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: M: L: / 40

57 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: M: L: / 40

58 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: M: L: / 40

59 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: M: L: takes lock / 40

60 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: M: L: takes lock / 40

61 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: M: L: takes lock / 40

62 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: suspends on lock M: L: takes lock / 40

63 Resources, priorities and scheduling Assume we have a fixed priority scheduler, three processes with high (H), medium (M) and low (L) priority and one critical resource. H: suspends on lock M: L: takes lock / 40

64 Mars Pathfinder and Priority Inversion 19 / 40

65 Some examples concurrent counter a list a queue 20 / 40

66 the concurrent counter s t r u c t c o u n t e r _ t { i n t v a l ; } void i n c r ( s t r u c t c o u n t e r _ t c ) { c >v a l ++; } 21 / 40

67 the concurrent counter s t r u c t c o u n t e r _ t { i n t v a l ; } void i n c r ( s t r u c t c o u n t e r _ t c ) { c >v a l ++; } s t r u c t c o u n t e r _ t { i n t v a l ; pthread_mutex_t l o c k ; } void i n c r ( s t r u c t c o u n t e r _ t c ) { p t h r e a d _ l o c k ( c >l o c k ) ; c >v a l ++; p t h r e a d _ u n l o c k ( c >l o c k ) ; } 21 / 40

68 Do the right thing Doing the right thing often has a price. 22 / 40

69 Do the right thing Doing the right thing often has a price. 22 / 40

70 sloppy counter counter thread 1 23 / 40

71 sloppy counter counter thread 1 thread 2 23 / 40

72 sloppy counter counter thread 1 thread 2 thread 3 23 / 40

73 sloppy counter counter local local local thread 1 thread 2 thread 3 23 / 40

74 sloppy counter 0 counter local local local thread 1 thread 2 thread 3 23 / 40

75 sloppy counter 0 counter 1 local local local thread 1 thread 2 thread 3 23 / 40

76 sloppy counter 0 counter local local local 1 1 thread 1 thread 2 thread 3 23 / 40

77 sloppy counter 0 counter 2 local local local 1 thread 1 thread 2 thread 3 23 / 40

78 sloppy counter 0 counter local local local thread 1 thread 2 thread 3 23 / 40

79 sloppy counter 0 counter 3 local local local 1 1 thread 1 thread 2 thread 3 23 / 40

80 sloppy counter counter local local local thread 1 thread 2 thread 3 23 / 40

81 sloppy counter counter 4 local local local 2 1 thread 1 thread 2 thread 3 23 / 40

82 sloppy counter counter local local local thread 1 thread 2 thread 3 23 / 40

83 sloppy counter counter 5 local local local 2 2 thread 1 thread 2 thread 3 23 / 40

84 sloppy counter 5 counter 5 local local local 2 2 thread 1 thread 2 thread 3 23 / 40

85 sloppy counter 5 counter 0 local local local 2 2 thread 1 thread 2 thread 3 23 / 40

86 sloppy counter 5 counter 0 local local local 2 2 thread 1 thread 2 thread 3 Sloppy vs Speed - do the right thing. 23 / 40

87 how about a list Simple solution: protect the list with one lock. 24 / 40

88 how about a list Simple solution: protect the list with one lock. Concurrent solution: allow several thread to operate on the list concurrently. 24 / 40

89 how about a list Simple solution: protect the list with one lock. Concurrent solution: allow several thread to operate on the list concurrently. concurrent reading: not a problem 24 / 40

90 how about a list Simple solution: protect the list with one lock. Concurrent solution: allow several thread to operate on the list concurrently. concurrent reading: not a problem concurrent updating: / 40

91 how about a list Simple solution: protect the list with one lock. Concurrent solution: allow several thread to operate on the list concurrently. concurrent reading: not a problem concurrent updating:... hmm, how would you solve it? 24 / 40

92 What about a queue Simple solution: protect the queue with one lock. Concurrent solution: allow threads to add elements to the queue at the same time as other remove elements. 25 / 40

93 What about a queue Simple solution: protect the queue with one lock. Concurrent solution: allow threads to add elements to the queue at the same time as other remove elements. front end dummy 25 / 40

94 What about a queue Simple solution: protect the queue with one lock. Concurrent solution: allow threads to add elements to the queue at the same time as other remove elements. front end dummy 25 / 40

95 What about a queue Simple solution: protect the queue with one lock. Concurrent solution: allow threads to add elements to the queue at the same time as other remove elements. front end dummy dummy 25 / 40

96 What about a queue Simple solution: protect the queue with one lock. Concurrent solution: allow threads to add elements to the queue at the same time as other remove elements. front end dummy dummy 25 / 40

97 What about a queue Simple solution: protect the queue with one lock. Concurrent solution: allow threads to add elements to the queue at the same time as other remove elements. front end dummy dummy 25 / 40

98 What about a queue Simple solution: protect the queue with one lock. Concurrent solution: allow threads to add elements to the queue at the same time as other remove elements. front end dummy 25 / 40

99 an operating system Traditionally operating systems were single threaded - the obvious solution. 26 / 40

100 an operating system Traditionally operating systems were single threaded - the obvious solution. The first systems that operated on multi-cpu architectures used one big kernel lock to avoid any problems with concurrency. 26 / 40

101 an operating system Traditionally operating systems were single threaded - the obvious solution. The first systems that operated on multi-cpu architectures used one big kernel lock to avoid any problems with concurrency. An operating system that is targeting multi-core architectures will today be multi threaded and use fine grain locking to increase performance. 26 / 40

102 an operating system Traditionally operating systems were single threaded - the obvious solution. The first systems that operated on multi-cpu architectures used one big kernel lock to avoid any problems with concurrency. An operating system that is targeting multi-core architectures will today be multi threaded and use fine grain locking to increase performance. How are things done in for example the JVM or Erlang? 26 / 40

103 beyond locks The locks that we have seen are all right: We can take a lock and prevent others from obtaining the lock. 27 / 40

104 beyond locks The locks that we have seen are all right: We can take a lock and prevent others from obtaining the lock. If someone holds the lock we will suspend execution. 27 / 40

105 beyond locks The locks that we have seen are all right: We can take a lock and prevent others from obtaining the lock. If someone holds the lock we will suspend execution. When the lock is released we will wake up and try to grab the lock again. 27 / 40

106 beyond locks The locks that we have seen are all right: We can take a lock and prevent others from obtaining the lock. If someone holds the lock we will suspend execution. When the lock is released we will wake up and try to grab the lock again. We would like to suspend and only be woken up if a specified condition holds true. 27 / 40

107 the queue revisited 28 / 40

108 the queue revisited front end dummy 28 / 40

109 the queue revisited front end dummy 28 / 40

110 the queue revisited front end dummy 28 / 40

111 the queue revisited front end dummy What do we do now? 28 / 40

112 conditional variables 29 / 40

113 conditional variables Introducing pthread conditional variables: pthread_cond_t : the data structure of a conditional variable 29 / 40

114 conditional variables Introducing pthread conditional variables: pthread_cond_t : the data structure of a conditional variable pthread_cond_init(pthread_cond_t *restrict cond,...) 29 / 40

115 conditional variables Introducing pthread conditional variables: pthread_cond_t : the data structure of a conditional variable pthread_cond_init(pthread_cond_t *restrict cond,...) pthread_cond_destroy(pthread_cond_t *cond) 29 / 40

116 conditional variables Introducing pthread conditional variables: pthread_cond_t : the data structure of a conditional variable pthread_cond_init(pthread_cond_t *restrict cond,...) pthread_cond_destroy(pthread_cond_t *cond) pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) 29 / 40

117 conditional variables Introducing pthread conditional variables: pthread_cond_t : the data structure of a conditional variable pthread_cond_init(pthread_cond_t *restrict cond,...) pthread_cond_destroy(pthread_cond_t *cond) pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) pthread_cond_signal(pthread_cond_t *cond) 29 / 40

118 conditional variables Introducing pthread conditional variables: pthread_cond_t : the data structure of a conditional variable pthread_cond_init(pthread_cond_t *restrict cond,...) pthread_cond_destroy(pthread_cond_t *cond) pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) pthread_cond_signal(pthread_cond_t *cond) pthread_cond_broadcast(pthread_cond_t *cond) 29 / 40

119 conditional variables Introducing pthread conditional variables: pthread_cond_t : the data structure of a conditional variable pthread_cond_init(pthread_cond_t *restrict cond,...) pthread_cond_destroy(pthread_cond_t *cond) pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) pthread_cond_signal(pthread_cond_t *cond) pthread_cond_broadcast(pthread_cond_t *cond) 29 / 40

120 conditional variables Introducing pthread conditional variables: pthread_cond_t : the data structure of a conditional variable pthread_cond_init(pthread_cond_t *restrict cond,...) pthread_cond_destroy(pthread_cond_t *cond) pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) pthread_cond_signal(pthread_cond_t *cond) pthread_cond_broadcast(pthread_cond_t *cond) The exact declarations are slightly more complicated, check the man pages. 29 / 40

121 the producer/consumer A single element buffer, multiple consumers, multiple producers. int buffer ; int count = 0; 30 / 40

122 the producer/consumer A single element buffer, multiple consumers, multiple producers. int buffer ; int count = 0; void put ( int value ) { assert ( count == 0); count = 1; buffer = value ; } int get () { assert ( count == 1); count = 0; return buffer ; } 30 / 40

123 the producer/consumer A single element buffer, multiple consumers, multiple producers. int buffer ; int count = 0; void put ( int value ) { assert ( count == 0); count = 1; buffer = value ; } int get () { assert ( count == 1); count = 0; return buffer ; } Let s try to make this work. 30 / 40

124 this will not work void produce ( int val ) { put ( val ); } int consume () { int val = get (); return val ; } 31 / 40

125 add a mutex and cond variable pthread_ cond_ t cond ; pthread_ mutex_ t mutex ; 32 / 40

126 add a mutex and cond variable pthread_ cond_ t cond ; pthread_ mutex_ t mutex ; produce ( i n t v a l ) { pthread_ mutex_ lock (&mutex ) ; i f ( count == 1) pthread_cond_wait (&cond, &mutex ) ; put ( v a l ) ; p t h r e a d _ c o n d _ s i g n a l (&cond ) ; pthread_ mutex_ unlock (&mutex ) ; } 32 / 40

127 add a mutex and cond variable pthread_ cond_ t cond ; pthread_ mutex_ t mutex ; produce ( i n t v a l ) { pthread_ mutex_ lock (&mutex ) ; i f ( count == 1) pthread_cond_wait (&cond, &mutex ) ; put ( v a l ) ; p t h r e a d _ c o n d _ s i g n a l (&cond ) ; pthread_ mutex_ unlock (&mutex ) ; } i n t consume ( ) { pthread_ mutex_ lock (&mutex ) ; i f ( count == 0) pthread_cond_wait (&cond, &mutex ) ; i n t v a l = g e t ( ) ; p t h r e a d _ c o n d _ s i g n a l (&cond ) ; pthread_ mutex_ unlock (&mutex ) ; r e t u r n v a l ; } 32 / 40

128 add a mutex and cond variable pthread_ cond_ t cond ; pthread_ mutex_ t mutex ; produce ( i n t v a l ) { pthread_ mutex_ lock (&mutex ) ; i f ( count == 1) pthread_cond_wait (&cond, &mutex ) ; put ( v a l ) ; p t h r e a d _ c o n d _ s i g n a l (&cond ) ; pthread_ mutex_ unlock (&mutex ) ; } i n t consume ( ) { pthread_ mutex_ lock (&mutex ) ; i f ( count == 0) pthread_cond_wait (&cond, &mutex ) ; i n t v a l = g e t ( ) ; p t h r e a d _ c o n d _ s i g n a l (&cond ) ; pthread_ mutex_ unlock (&mutex ) ; r e t u r n v a l ; } When does this work, when does it not work? 32 / 40

129 a race condition If you re signaled to wake up - it might take some time before you do wake up. 33 / 40

130 better pthread_ cond_ t filled, empty ; pthread_ mutex_ t mutex ; 34 / 40

131 better pthread_ cond_ t filled, empty ; pthread_ mutex_ t mutex ; produce ( i n t v a l ) { pthread_ mutex_ lock (&mutex ) ; w h i l e ( count == 1) pthread_cond_wait (&empty, &mutex ) ; : p t h r e a d _ c o n d _ s i g n a l (& f i l l e d ) ; : } 34 / 40

132 better pthread_ cond_ t filled, empty ; pthread_ mutex_ t mutex ; produce ( i n t v a l ) { pthread_ mutex_ lock (&mutex ) ; w h i l e ( count == 1) pthread_cond_wait (&empty, &mutex ) ; : p t h r e a d _ c o n d _ s i g n a l (& f i l l e d ) ; : } i n t consume ( ) { pthread_ mutex_ lock (&mutex ) ; w h i l e ( count == 0) pthread_cond_wait (& f i l l e d, &mutex ) ; : p t h r e a d _ c o n d _ s i g n a l (&empty ) ; : } 34 / 40

133 a larger buffer int buffer [ MAX ]; int * getp = 0; in * putp = 0; int count = 0; void put ( int value ) { assert ( count < MAX ); buffer [ putp ] = value ; putp = putp + 1 % MAX ; count ++; } int get () { assert ( count > 0); int val = buffer [ getp ]; getp = getp + 1 % MAX count -- return val ; } 35 / 40

134 final touch produce ( int val ) { : while ( count == MAX ) pthread_cond_wait (& empty, & mutex ); : } 36 / 40

135 final touch produce ( int val ) { : while ( count == MAX ) pthread_cond_wait (& empty, & mutex ); : } int consume () { : while ( count == 0) pthread_cond_wait (& filled, & mutex ); : } 36 / 40

136 final touch produce ( int val ) { : while ( count == MAX ) pthread_cond_wait (& empty, & mutex ); : } int consume () { : while ( count == 0) pthread_cond_wait (& filled, & mutex ); : } Can we allow a producer to add an entry while another removes an entry? 36 / 40

137 Where are we now? atomic test and set: we need it 37 / 40

138 Where are we now? atomic test and set: we need it spin locks: simple to use but have some problems 37 / 40

139 Where are we now? atomic test and set: we need it spin locks: simple to use but have some problems wait and wake : avoid spinning 37 / 40

140 Where are we now? atomic test and set: we need it spin locks: simple to use but have some problems wait and wake : avoid spinning condition variables : don t wake up if it s not time to continue 37 / 40

141 Where are we now? atomic test and set: we need it spin locks: simple to use but have some problems wait and wake : avoid spinning condition variables : don t wake up if it s not time to continue Is there more? 37 / 40

142 Semaphores 38 / 40

143 Semaphores Properties of a semaphore: 38 / 40

144 Semaphores Properties of a semaphore: holds a number 38 / 40

145 Semaphores Properties of a semaphore: holds a number only allow threads to pass is number is above 0 38 / 40

146 Semaphores Properties of a semaphore: holds a number only allow threads to pass is number is above 0 passing threads decremented the number 38 / 40

147 Semaphores Properties of a semaphore: holds a number only allow threads to pass is number is above 0 passing threads decremented the number a thread can increment the number 38 / 40

148 Semaphores Properties of a semaphore: holds a number only allow threads to pass is number is above 0 passing threads decremented the number a thread can increment the number A semaphore is a counter of resources. 38 / 40

149 POSIX semaphores #include <semaphore.h> 39 / 40

150 POSIX semaphores #include <semaphore.h> sem_t : the semaphore data structure 39 / 40

151 POSIX semaphores #include <semaphore.h> sem_t : the semaphore data structure sem_init(sem_t *sem, int pshared, unsigned int value): could be shared between processes 39 / 40

152 POSIX semaphores #include <semaphore.h> sem_t : the semaphore data structure sem_init(sem_t *sem, int pshared, unsigned int value): could be shared between processes int sem_destroy(sem_t *sem) 39 / 40

153 POSIX semaphores #include <semaphore.h> sem_t : the semaphore data structure sem_init(sem_t *sem, int pshared, unsigned int value): could be shared between processes int sem_destroy(sem_t *sem) sem_wait(sem_t *sem) 39 / 40

154 POSIX semaphores #include <semaphore.h> sem_t : the semaphore data structure sem_init(sem_t *sem, int pshared, unsigned int value): could be shared between processes int sem_destroy(sem_t *sem) sem_wait(sem_t *sem) sem_post(sem_t *sem) 39 / 40

155 POSIX semaphores #include <semaphore.h> sem_t : the semaphore data structure sem_init(sem_t *sem, int pshared, unsigned int value): could be shared between processes int sem_destroy(sem_t *sem) sem_wait(sem_t *sem) sem_post(sem_t *sem) 39 / 40

156 Summary

157 Summary

158 Summary

159 Summary

160 Summary

161 Summary 40 / 40