Process Synchronization. studykorner.org

Transcription

1 Process Synchronization

2 Semaphore Implementation Must guarantee that no two processes can execute wait () and signal () on the same semaphore at the same time The main disadvantage of the semaphore definition given here is that it requires Busy Waiting (SPIN LOCK).

3 Semaphore Implementation with no Busy waiting (Cont.) Implementation of wait: wait(semaphore *S) { S->value--; if (S->value < 0) { add this process to S->list; block(); } } Implementation of signal: signal(semaphore *S) { S->value++; if (S->value <= 0) { remove a process P from S->list; wakeup(p); } }

4 Deadlock and Starvation Let S and Q be two semaphores initialized to 1 P 0 P 1 wait (S); wait (Q); wait (Q); wait (S); signal (S); signal (Q); signal (Q); signal (S); Starvation indefinite blocking A process may never be removed from the semaphore queue in which it is suspended (LIFO queue implementation) Priority Inversion Scheduling problem when lower-priority process holds a lock needed by higher-priority process

5 Classical Problems of Synchronization Classical problems used to test newlyproposed synchronization schemes Bounded-Buffer Problem (Producer-Consumer) Readers and Writers Problem Dining-Philosophers Problem

6 Semaphore library and its system call sem_init(), sem_post(), sem_wait(),

7 sem_init int sem_init(sem_t *sem, int pshared, unsigned int initial_value); If pshared = 0, semaphore is shared between the threads of a process, If pshared = nonzero, semaphore is shared between processes, located in a region of shared memory. Forked child can also access the semaphore. sem_init() returns 0 on success; on error, -1 is returned, and errno is set to indicate the error.

8 sem_post int sem_post(sem_t *sem); sem_post() increments (unlocks) the semaphore pointed to by sem. If the semaphore's value > 0, then another process or thread blocked in a sem_wait() call will be woken up and proceed to lock the semaphore. sem_post() returns 0 on success; on error, the value of the semaphore is left unchanged, -1 is returned, and errno is set to indicate the error.

9 sem_wait int sem_wait(sem_t *sem); sem_wait() decrements (locks) the semaphore pointed to by sem. If the semaphore's value >0, then the decrement proceeds, and the function returns, immediately. If the semaphore value =0, then the call blocks until it becomes possible to perform the decrement (i.e., the semaphore value rises above zero). return 0 on success; on error, the value of the semaphore is left unchanged, -1 is returned, and errno is set to indicate the error.

10 Bounded Buffer Problem(Producer and consumer) Semaphore mutex=1 (to provide mutual exclusion, similar to turn variable Semaphore empty=n (how much free space available to put item) Semaphore full=0 ( how many items are produced) Producer Consumer process do { // produce an item do { wait (full); wait (mutex); wait (empty); wait (mutex); // add the item to the buffer count ++; signal (mutex); signal (full); // remove an item count --; signal (mutex); signal (empty); } while (TRUE); } while (TRUE);

11 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 Problem allow multiple readers to read at the same time Only one single writer can access the shared data at the same time Several variations of how readers and writers are treated all involve priorities

12 Readers-Writers Problem (Cont.) semaphore mutex, wrt; int readcount; Data set Semaphore mutex initialized to 1 Semaphore wrt initialized to 1 Integer readcount initialized to 0

13 Readers-Writers Problem (Cont.) The structure for a writer process do { wait (wrt) ; // writing is performed signal (wrt) ; } while (TRUE); To see no process writing The structure of a reader process do { wait (mutex) ; readcount ++ ; if (readcount == 1) wait (wrt) ; signal (mutex) // reading is performed Only one process executes at a time to make consistency for readcount variable Allow another to read simultaneously To allow process for writing wait (mutex) ; readcount - - ; if (readcount == 0) signal (wrt) ; signal (mutex) ; } while (TRUE); Only one process executes at a time to make consistency for readcount variable

14 Readers-Writers Problem Variations First variation no reader kept waiting unless writer has permission to use shared object Second variation once writer is ready, it performs write asap Both may have starvation leading to even more variations Problem is solved on some systems by kernel providing reader-writer locks ms/6_synchronization.html

15 Dining-Philosophers Problem Philosophers spend their lives thinking and eating Don t interact with their neighbors, occasionally try to pick up 2 chopsticks (one at a time) to eat from bowl Need both to eat, then release both when done In the case of 5 philosophers Shared data Bowl of rice (data set) Semaphore chopstick [5] initialized to 1

16 Dining-Philosophers Problem Algorithm The structure of Philosopher i: do { P( chopstick[i] ); P(chopStick[ (i + 1) % 5] ); // eat V( chopstick[i] ); V(chopstick[ (i + 1) % 5] ); // think } while (TRUE); What is the problem with this algorithm?

17 Problems with Semaphores Incorrect use of semaphore operations: V(mutex)..CS.. P(mutex) P(mutex)..CS.. P(mutex) Omitting of P(mutex) or V(mutex) (or both) Deadlock and starvation