Upcoming SlideShare
×

# Classical problem of synchronization

2,583 views

Published on

Published in: Education, Technology
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

### Classical problem of synchronization

1. 1. Classical Problem Of Synchronization Submitted To: Namita mam Submitted By:- Shakshi Kanwar Ranawat
2. 2. Contents Of Discussion  The Dining-Philosophers Problem  The Reader Writers Problem  The Bounded Buffer Problem
3. 3. Dining-Philosophers Problem: Rice
4. 4. Dining-Philosophers Problem • Table, a bowl of rice in center, five chairs, and five chopsticks, also in each chair there is a philosopher. • A philosopher may pick up only one chopstick at a time. • When a hungry philosopher has both her chopsticks at the same time, she eats without releasing her chopsticks. • When she is finished eating, she puts down both of her chopsticks and starts thinking. • From time to time, a philosopher gets hungry and tries to pick up the two chopsticks that are closest to her (chopsticks between her left and right neighbors).
5. 5. The Structure of philosopher i do{ wait(chopstick[i]); wait(chopstick[(i+1)%5]); …. //eat ….. signal(chopstick[i]); signal(chopstick[(i+1)%5]); ….. //think ….. }while(TRUE);
6. 6. Dining-Philosophers Problem (Cont.) Solution:  Present each chopstick by a semaphore.  A philosopher tries to grab the chopstick by executing a wait operation on that semaphore.  She releases her chopsticks by executing the signal operation on the appropriate semaphores. This solution guarantees that no two neighbors are eating simultaneously, but it could cause a deadlock. Suppose all five philosophers become hungry simultaneously, and each grabs her left chopstick. When each philosopher tries to grab her right chopstick, she will cause the possibility that the philosophers will starve to death.
7. 7. Dining-Philosophers Problem (Cont.)  We present a solution to the dining-philosophers problem that ensure freedom from deadlock. – Allow at most 4 philosophers to be sitting simultaneously at the table. – Allow a philosopher to pick up her chopstick only if both chopsticks are available. – An odd philosopher picks up first her left chopstick and then her right chopstick, whereas, an even philosopher picks up her right chopstick first and then her left chopstick. • Note: A deadlock-free solution does not necessarily eliminate the possibility of starvation.
8. 8. A semaphore solution: // represent each chopstick with a semaphore Semaphore chopstick[] = new Semaphore[5]; // all = 1 initially process philosopher_i { while (true) { // pick up left chopstick chopstick[i].acquire();
9. 9. Cont… // pick up right chopstick chopstick[(i+1) % 5].acquire(); // eat // put down left chopstick chopstick[i].release(); // put down right chopstick chopstick[(i+1) % 5].release(); // think } }
10. 10. Cont… This solution guarantees no two neighboring philosophers eat simultaneously, but has the possibility of creating a deadlock
11. 11. Uses of semaphores  protecting acccess to a critical section (e.g., db in the R/W problem)  as a mutex lock (e.g., to protect the shared variables used in solving a probem such as readerCount above)  to protect a relationship (e.g., empty and full as used in the P/C problem)  to support atomicity (e.g., you pickup either both chopsticks as the same time or neither, you cannot pickup just one)
12. 12. Application  The dining philosophers problem represents a situation that can occur in large communities of processes that share a sizeable pool of resources.
13. 13. Bounded Buffer Problem  also called the Producers and Consumers problem.  A finite supply of containers is available. Producers take an empty container and fill it with a product. Consumers take a full container, consume the product and leave an empty container.  The main complexity of this problem is that we must maintain the count for both the number of empty and full containers that are available.  Producers produce a product and consumers consume the product, but both use of one of the containers each time.
14. 14. The Bounded Buffer Problem Consider: a buffer which can store n items a producer process which creates the items (1 at a time) a consumer process which processes them (1 at a time) A producer cannot produce unless there is an empty buffer slot to fill. A consumer cannot consume unless there is at least one produced item.
15. 15. Cont..
16. 16. Bounded-Buffer Problem Process Shared data semaphore full, empty, mutex; Initialisation: full = 0, empty = n, mutex = 1
17. 17. Producer Process do { … produce an item in nextp … wait(empty); wait(mutex);… add nextp to buffer… signal(mutex); signal(full); } while (1);
18. 18. Consumer Process do { wait(full) wait(mutex); … remove an item from buffer to nextc … signal(mutex); signal(empty); … consume the item in nextc … } while (1);
19. 19. Application A pipe or other finite queue (buffer), is an example of the bounded buffer problem.
20. 20. Reader Writer Problem  If one notebook exists where writers may write information to, only one writer may write at a time. Confusion may arise if a reader is trying read at the same as a writer is writing. Since readers only look at the data, but do not modify the data, we can allow more than one reader to read at the same time.  The main complexity with this problems stems from allowing more than one reader to access the data at the same time.