Dining Philosophers Problem: Solutions and Reviews

1. Lecture 15: Dining Philosophers Problem

2. Review: Mutual Exclusion Solutions • Software solution • Disabling interrupts • Strict alternation • Peterson’s solution • Hardware solution • TSL/XCHG • Semaphore • Conditional variables • POSIX standards

3. Review: Pthreads APIs for condition variables

4. Thread 1: printf(“hello “); pthread_mutex_lock(&mutex); thread1_done = 1; pthread_cond_signal(&cv); pthread_mutex_unlock(&mutex); Review: Using condition variables int thread1_done = 0; pthread_cond_t cv; pthread_mutex_t mutex; Thread 2: pthread_mutex_lock(&mutex); while (thread1_done == 0) { pthread_cond_wait(&cv, &mutex); } printf(“ world\n“); pthread_mutex_unlock(&mutex);

5. proc1( ) { pthread_mutex_lock(&m1); /* use object 1 */ pthread_mutex_lock(&m2); /* use objects 1 and 2 */ pthread_mutex_unlock(&m2); pthread_mutex_unlock(&m1); } proc2( ) { pthread_mutex_lock(&m2); /* use object 2 */ pthread_mutex_lock(&m1); /* use objects 1 and 2 */ pthread_mutex_unlock(&m1); pthread_mutex_unlock(&m2); } Review: Deadlock thread a thread b

6. In this lecture • Dining Philosophers Problem • Readers-Writers Problem

7. Dining Philosophers • Classic Synchronization Problem • Philosopher • eat, think • eat, think • …….. • Philosopher = Process • Eating needs two resources (chopsticks)

8. Problem: need two chopsticks to eat

9. First Pass at a Solution One Mutex for each chopstick Philosopher i: while (1) { Think(); lock(Left_Chopstick); lock(Right_Chopstick); Eat(); unlock(Left_Chopstick); unlock(Right_Chopstick); }

12. DEADLOCK

13. One Possible Solution • Use a mutex for the whole dinner-table • Philosopher i: lock(table); Eat(); Unlock(table); Performance problem!

14. Another Solution Philosopher i: Think(); unsuccessful = 1; while (unsuccessful) { lock(left_chopstick); if (try_lock(right_chopstick)) /* try_lock returns immediately if unable to grab the lock */ unsuccessful = 0; else unlock(left_chopstick); } Eat(); unlock(left_chopstick); unlock(right_chopstick); Problem: starvation if unfavorable scheduling!

15. In Practice • Starvation will probably not occur • We can ensure this by adding randomization to the system: • Add a random delay before retrying • Unlikely that our random delays will be in sync too many times

16. Solution with Random Delays Philosopher i: Think(); while (unsuccessful) { wait(random()); lock(left_chopstick); if (trylock(right_chopstick)) unsuccessful = 0; else unlock(left_chopstick); } Eat(); unlock(left_chopstick); unlock(right_chopstick);

17. Solution without random delay • Do not try to take forks one after another • Don’t have each fork protected by a different mutex • Try to grab both forks at the same time