CONDITION VARIABLE

Announcements  Quiz  Getting the big picture  Programming assignments  Cooperation  Lecture is cut 20 mins short for Quiz and in-class activity.

Today  Races  Deadlocks  Dining Philosopher's Problem  Condition Variable

One Worry: Races  A race occurs when correctness of the program depends on one thread reaching point x before another thread reaches point y /* a threaded program with a race */ int main() { pthread_t tid[N]; int i; for (i = 0; i < N; i++) Pthread_create(&tid[i], NULL, thread, &i); for (i = 0; i < N; i++) Pthread_join(tid[i], NULL); exit(0); } /* thread routine */ void *thread(void *vargp) { int myid = *((int *)vargp); printf("Hello from thread %d\n", myid); return NULL; } race.c

Race Elimination  Make sure don’t have unintended sharing of state /* a threaded program without the race */ int main() { pthread_t tid[N]; int i; for (i = 0; i < N; i++) { int *valp = malloc(sizeof(int)); *valp = i; Pthread_create(&tid[i], NULL, thread, valp); } for (i = 0; i < N; i++) Pthread_join(tid[i], NULL); exit(0); } /* thread routine */ void *thread(void *vargp) { int myid = *((int *)vargp); free(vargp); printf("Hello from thread %d\n", myid); return NULL; } norace.c

Today  Races  Deadlocks  Dining Philosopher's Problem  Condition Variable

Another Worry: Deadlock  Def: A process is deadlocked iff it is waiting for a condition that will never be true.  Typical Scenario  Processes 1 and 2 needs two resources (A and B) to proceed  Process 1 acquires A, waits for B  Process 2 acquires B, waits for A  Both will wait forever!  Analogous to a traffic gridlock

Deadlocking With Semaphores int main() { pthread_t tid[2]; Sem_init(&mutex[0], 0, 1); /* mutex[0] = 1 */ Sem_init(&mutex[1], 0, 1); /* mutex[1] = 1 */ Pthread_create(&tid[0], NULL, count, (void*) 0); Pthread_create(&tid[1], NULL, count, (void*) 1); Pthread_join(tid[0], NULL); Pthread_join(tid[1], NULL); printf("cnt=%d\n", cnt); exit(0); } void *count(void *vargp) { int i; int id = (int) vargp; for (i = 0; i < NITERS; i++) { P(&mutex[id]); P(&mutex[1-id]); cnt++; V(&mutex[id]); V(&mutex[1-id]); } return NULL; } Tid[0]: P(s 0 ); P(s 1 ); cnt++; V(s 0 ); V(s 1 ); Tid[1]: P(s 1 ); P(s 0 ); cnt++; V(s 1 ); V(s 0 );

Deadlock Visualized in Progress Graph Locking introduces the potential for deadlock: waiting for a condition that will never be true Any trajectory that enters the deadlock region will eventually reach the deadlock state, waiting for eithe r s 0 or s 1 to become nonzero Other trajectories luck out and s kirt the deadlock region Unfortunate fact: deadlock is of ten nondeterministic Thread 1 Thread 2 P(s 0 )V(s 0 )P(s 1 )V(s 1 ) P(s 1 ) P(s 0 ) V(s 0 ) Forbidden region for s 0 Forbidden region for s 1 Deadlock state Deadlock region s 0 =s 1 =1

Avoiding Deadlock int main() { pthread_t tid[2]; Sem_init(&mutex[0], 0, 1); /* mutex[0] = 1 */ Sem_init(&mutex[1], 0, 1); /* mutex[1] = 1 */ Pthread_create(&tid[0], NULL, count, (void*) 0); Pthread_create(&tid[1], NULL, count, (void*) 1); Pthread_join(tid[0], NULL); Pthread_join(tid[1], NULL); printf("cnt=%d\n", cnt); exit(0); } void *count(void *vargp) { int i; int id = (int) vargp; for (i = 0; i < NITERS; i++) { P(&mutex[0]); P(&mutex[1]); cnt++; V(&mutex[id]); V(&mutex[1-id]); } return NULL; } Tid[0]: P(s0); P(s1); cnt++; V(s0); V(s1); Tid[1]: P(s0); P(s1); cnt++; V(s1); V(s0); Acquire shared resources in same order

Avoided Deadlock in Progress Graph No way for trajectory to get stuck Processes acquire locks in same order Order in which locks released immaterial Thread 1 Thread 2 P(s 0 )V(s 0 )P(s 1 )V(s 1 ) P(s 1 ) P(s 0 ) V(s 0 ) Forbidden region for s 0 Forbidden region for s 1 s 0 =s 1 =1

Threads Summary  Threads provide another mechanism for writing concurrent programs  Threads are growing in popularity  Somewhat cheaper than processes  Easy to share data between threads  However, the ease of sharing has a cost:  Easy to introduce subtle synchronization errors  Tread carefully with threads!  For more info:  D. Butenhof, “Programming with Posix Threads”, Addison-Wesley, 1997

Dining Philosopher’s Problem (Dijkstra ’71) Philosophers eat/think Eating needs two forks Pick one fork at a time Captures the concept of multiple threads competing for shared resources

Dining Philosopher’s Problem  Thinking about philosophers makes it easier to think abstractly.  The philosophers are very logical  They want to settle on a shared policy that all can apply concurrently  They are hungry: we should let everyone eat (eventually)  The policy should be totally fair.  Design an algorithm that the philosophers can follow that insures that none starves as long as each philosopher eventually stops eating, and such that the maximum number of philosophers can eat at once.

Wrong design void philosopher() { while(1) { sleep(); get_left_fork(); get_right_fork(); eat(); put_left_fork(); put_right_fork(); } Other (inefficient) ideas: use a binary semaphore before getting the forks Recommended reading:

What can go wrong?  Starvation: Leaving some philosopher hungry (for a long time) in some situation  Deadlock: All the philosophers waits or gets “stuck”; nobody can make progress  Livelock: Everyone does something endlessly (e.g., infinite loop) without ever eating! Deadlock  Starvation but not vice versa

Solution 1: test (get_fork blocks until you can eat) #define N 5 /* Number of philosphers */ #define RIGHT(i) (((i)+1) %N) #define LEFT(i) (((i)==N) ? 0 : (i)+1) typedef enum { THINKING, HUNGRY, EATING } phil_state; phil_state state[N]; semaphore mutex =1; semaphore s[N]; /* one per philosopher, all 0 */ void test(int i) { if ( state[i] == HUNGRY && state[LEFT(i)] != EATING && state[RIGHT(i)] != EATING ) { state[i] = EATING; V(s[i]); } void get_forks(int i) { P(mutex); state[i] = HUNGRY; test(i); // try to acquire two forks V(mutex); P(s[i]); // wait if you can’t eat } void put_forks(int i) { P(mutex); state[i]= THINKING; test(LEFT(i)); // see if LEFT can eat test(RIGHT(i)); // see if RIGHT can eat V(mutex); } void philosopher(int process) { while(1) { think(); get_forks(process); eat(); put_forks(process); }

Solution 2 void get_forks(int i) { state[i] = HUNGRY; while ( state[i] == HUNGRY ) { P(mutex); if ( state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT(i)] != EATING ) { state[i] = EATING; V(s[i]); } V(mutex); P(s[i]); } void philosopher(int process) { while(1) { think(); get_forks(process); eat(); put_forks(); } void put_forks(int i) { P(mutex); state[i]= THINKING; if ( state[LEFT(i)] == HUNGRY ) V(s[LEFT(i)]); if ( state[RIGHT(i)] == HUNGRY) V(s[RIGHT(i)]); V(mutex); }

Today  Races  Deadlocks  Dining Philosopher's Problem  Condition Variable

Difficulties in using Semaphores  Semaphores provide a very general mechanism for synchronization.  The power of semaphores derives from calls to P() and V() that are unmatched.  E.g., reader/writer and dining phil.  Unlike mutex (locks) where we lock() and unlock()  This means that it’s very tricky to get it right (e.g., no single fixed pattern of use and/or more than one semaphores).

Condition Variables  Condition variables is a synchronization primitive that helps us model events (rather than resources in the case of semaphores).  A condition variable represents some condition that a thread can:  Wait on, until the condition occurs; or  Notify other waiting threads that the condition has occur  It provides a place to wait (queue).

Condition Variables  Operations on condition variables:  wait() -- Block until another thread calls signal() or broadcast() on the CV  signal() -- Wake up one thread waiting on the CV  broadcast() -- Wake up all threads waiting on the CV  Pthread  pthread_cond_wait(pthread_cond_t *c, pthread_mutex_t *m);  pthread_cond_signal(pthread_cond_t *c);  pthread_cond_broadcast (pthread_cond_t *c);  Used with mutex

Broadcast  The pthread_cond_broadcast() function is used whenever the shared- variable state has been changed in a way that more than one thread can proceed with its task.  Single producer/multiple consumer problem  The producer would notify all consumers that might be waiting; more throughput on a multi-processor.  Read-write lock.  Wakes up all waiting readers when a writer releases its lock. Recommended reading

Producer and consumer  Important to use while statement to check the condition after waking up. It handles spurious wakeup. cond_t empty, fill; void produce(int item) { mutex_lock(&mutex); while (count == MAX) cond_wait(&empty, &mutex); put(item); // put an item in the circular buffer cond_signal(&fill); // signal an item is filled mutex_unlock(&mutex); } int consumer() { mutex_lock(&mutex); while (count == 0) cond_wait(&fill, &mutex); int item = get(); cond_signal(&empty); mutex_unlock(&mutex); return item; }

Next Lecture  So far we have learned basic concepts in Operating System.  This is not an OS class  But, most of you didn’t take OS.  We will begin to talk more about distributed systems.