Dining Philosophers: Dining Philosophers: A Classic Parallel A Classic Parallel Processing Problem Processing Problem by by E Dijkstra E Dijkstra Presented by: Presented by: Monzur Morshed Monzur Morshed Habibur Rahman Habibur Rahman Tiger Tiger HATS HATS www.tigerhats.org www.tigerhats.org
29
Embed
Dining Philosophers: A Classic Parallel Processing Problem by E Dijkstra
Dining Philosophers: A Classic Parallel Processing Problem by E Dijkstra
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Dining Philosophers:Dining Philosophers:A Classic Parallel A Classic Parallel
The International Research group dedicated to Theories, Simulation and
Modeling, New Approaches, Applications, Experiences, Development, Evaluations, Education, Human, Cultural and Industrial Technology
TigerTigerHATS HATS - Information is - Information is powerpower
3
Dining Philosophers (1)Dining Philosophers (1)
Philosophers eat/think Eating needs 2 forks Pick one fork at a time How to prevent
deadlock
DefinitionDefinition Extension to mutual
exclusion Arbitrary topology Each philosopher (process)
proceeds through the following cycle• Thinking may
remain indefinitely• Hungry • Eating has to finish within
finite time
Solution properties• Safety – no two neighbors
eat at the same time• Liveness – each hungry
philosopher eventually eats
Problem StatementProblem Statement
Five philosophers eat then think forever• They never sleep nor relieve themselves!
• They do not behave altruistically They eat at a communal table• It has a single bowl of tangled spaghetti
• Five plates each with a single fork to the left of their plate
• To eat a philosopher must have two forks, their own and that of their neighbour’s to the right
• If a philosopher is unable to eat they resume thinking
RamificationsRamifications Deadlock• All philosophers decide to eat at same time• They all pick up one fork• None of them can eat hence the system comes to a
halt• Circular waiting for resources
Starvation• Some philosophers think for such a short time and
contrive to put their forks down in such a way that no other philosophers have the opportunity to pick up the two forks they require to eat
• Thread waits indefinitely Livelock• A policy that makes them all do something endlessly
without ever eating! Deadlock Starvation but not vice versa• Starvation can end (but doesn’t have to)• Deadlock can’t end without external intervention
When some system processes are blocked on resource requests that can never be satisfied unless drastic actions are taken, the processes are deadlocked.
Three approaches to deadlock• Prevent deadlock by careful system analysis• Detect deadlock when it happens, and take
corrective action• Ignore the problem and hope for the best
(this is the Unix and Windows model)
What is deadlock?What is deadlock?
Strict deadlock is caused by cyclic resource requests
Effective deadlock is caused by resource depletion (for example, not enough memory to run a large process thread)
Causes of DeadlockCauses of Deadlock
Res 2Res 1
ThreadB
ThreadA Wait
For
WaitFor
OwnedBy
OwnedBy
The Danger of DeadlockThe Danger of Deadlock
It is possible for all processes to block• Deadlock !
philosopher 1cstick[1].P();cstick[2].P();
philosopher 2cstick[2].P();cstick[3].P();
philosopher 3cstick[3].P();cstick[4].P();
philosopher 4cstick[4].P();cstick[5].P();
philosopher 5cstick[5].P();cstick[1].P();
cstick[1]
cstick[2]cstick[5]
cstick[4] cstick[3]
Avoiding Deadlock(1)Avoiding Deadlock(1)
Avoid cycles (or have a total ordering of the chopsticks)
philosopher 1cstick[1].P();cstick[2].P();
philosopher 2cstick[2].P();cstick[3].P();
philosopher 3cstick[3].P();cstick[4].P();
philosopher 4cstick[4].P();cstick[5].P();
philosopher 5cstick[1].P();cstick[5].P();
cstick[1]
cstick[2]cstick[5]
cstick[4] cstick[3]
Necessary Conditions for Necessary Conditions for DeadlockDeadlock
Mutual exclusion Hold and wait condition No preemption condition Circular wait condition Original scenario & our proposed
ritual had all four of these properties.
Necessary Conditions for Necessary Conditions for DeadlockDeadlock
Mutual exclusion • Exclusive use of chopsticks
Hold and wait condition• Hold 1 chopstick, wait for next
No preemption condition• Cannot force another to release held resource
Circular wait condition• Each waits for next neighbor to put down
chopstick
Four conditions to provide mutual exclusion• No two processes simultaneously in
critical region• No assumptions made about speeds or
numbers of CPUs• No process running outside its critical
region may block another process• No process must wait forever to enter
Simple: “waiting” state• Enter waiting state when neighbors eating• When neighbors done, get forks• Neighbors can’t enter waiting state if
neighbor waiting Problem:• Doesn’t prevent starvation• Requires checking both neighbors at once• Race condition
Waiter solution• Since the philosophers don't speak with each other• One solution is to have them speak to a waiter which keeps
an overview of the table, he can then decide who gets forks and when.
Resource hierarchy solution• Resource hierarchy consists of ordering the forks by number. • It always be requested by order and released in the reverse
order.
Chandy / Misra solution• The forks as either being clean or dirty and based on this
categorization the philosophers requests the forks from one another.
• It request equals communication and so the restraint inherent to the problem has been violated - So this is really no solution at all.
Fully Distributed SolutionFully Distributed Solution(Lehman and Rabin ’81)(Lehman and Rabin ’81)
Problem with previous solutions• Not truly distributed: Requires some sort of central
coordination or global state• Non-Symmetric: Different philosophers run different
algorithms
Additional properties:• Deadlock free: Eventually someone new gets to eat• Lockout free: Eventually every hungry philosopher gets
to eat• Adversary: One philosopher may try to starve another
• Can’t just hold the fork indefinitely• Communication only between adjacent philosophers
• No global state• Can’t communicate with both at same time
A semaphore is a variable or abstract data type
Semaphores are used for synchronization and mutual exclusion by indicating the availability and number of resources.
The pthread package provides two types of semaphores – named and unnamed.
For this project, we use unnamed or Binary semaphores.
Binary semaphore –integer value can range only between 0 and 1; can be simpler to implement
Semaphore solutionSemaphore solution
The code below illustrates how a semaphore is created:#include <semaphore.h>sem_t mutex; /* create the semaphore and initialize
it to 1 */sem_init(&mutex, 0, 1);sem_wait(&mutex); /* acquire the semaphore *//*** critical section ***/sem_post(&mutex); /* release the semaphore */
The sem_init(…) creates a semaphore and initialize it. This function is passed three parameters:
1. A pointer to the semaphore2. A flag indicating the level of sharing ( flag o indicating that this
semaphore can only be shared by threads belonging to the same process that created the semaphore. A nonzero value would allow other processes to access the semaphore as well.