Download
1 / 29
290 likes | 669 Views
6.5 Semaphore. Can only be accessed via two indivisible (atomic) operations wait (S) { while S <= 0 ; // no-op S--; } signal (S) { S++; }. 6.5 Semaphore. Binary semaphore –integer value can range only between 0 and 1; can be simpler to implement
E N D
6.5 Semaphore Can only be accessed via two indivisible (atomic) operations wait (S) { while S <= 0 ; // no-op S--; } signal (S) { S++; }
6.5 Semaphore • Binary semaphore –integer value can range only between 0 and 1; can be simpler to implement • Counting semaphore –integer value can range over an unrestricted domain
6.5 Semaphore • The main disadvantage of the semaphore is that it requires busy waiting, which wastes CPU cycle that some other process might be able to use productively • This type of semaphore is also called a spinlock because the process “spins” while waiting for the lock
6.5 Semaphore To overcome the busy waiting problem, we create two more operations: • block–place the process invoking the operation on the appropriate waiting queue. • wakeup –remove one of processes in the waiting queue and place it in the ready queue.
6.6Classical Problems of Synchronization • Bounded-Buffer Problem • Readers and Writers Problem • Dining-Philosophers Problem
6.6Classical Problems of Synchronization • N buffers, each can hold one item • Semaphore mutex initialized to the value 1 • Semaphore full initialized to the value 0 • Semaphore empty initialized to the value N.
Readers-Writers Problem • A data set is shared among a number of concurrent processes • Readers –only read the data set; they do not perform any updates • Writers –can both read and write. • First readers-writers problem: requires that no reader will be kept waiting unless a writer has already obtained permission to use the shared object
Readers-Writers Problem Shared Data • Data set • Semaphore mutex initialized to 1. • Semaphore wrt initialized to 1. • Integer read count initialized to 0.
Dining-Philosophers Problem • The philosophers share a circular table surrounded by five chairs, each belonging to one philosopher • In the center of table is a bowl of rice, and the table is laid with 5 single chopsticks • From time to time, a philosopher gets hungry and tries to pick up the two chopsticks that are closest to her • 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 her chopsticks and starts thinking
Dining-Philosophers Problem Methods to avoid deadlock: • Allow at most four philosophers to be sitting simultaneously • Allow a philosopher to pick up her chopsticks only if both chopsticks are available (pick them up is a critical section)
Problems with Semaphores signal (mutex) //violate mutual exclusive critical section wait (mutex) wait (mutex) //deadlock occurs critical section wait (mutex) Omitting of wait (mutex) or signal (mutex) (or both)
Monitors • A high-level abstraction that provides a convenient and effective mechanism for process synchronization • Only one process may be active within the monitor at a time
Syntax of Monitor monitor monitor-name { // shared variable declarations procedure P1 (…) { …. } … procedure Pn(…) {……} Initialization code ( ….) { …} … }
Condition Variables • However, the monitor construct, as defined so far, is not powerful enough • We need to define one or more variables of type condition: condition x, y; Two operations on a condition variable: • x.wait() –a process that invokes the operation is suspended. • x.signal() –resumes one of processes (if any) that invoked x.wait()
Syntax of Monitor monitor monitor-name { // shared variable declarations procedure P1 (…) { …. } … procedure Pn(…) {……} Initialization code ( ….) { …} … }
Solution to Dining Philosophers Each philosopher I invokes the operations pickup() and putdown() in the following sequence: dp.pickup(i) EAT dp.putdown(i)
