Process Synchronisation (contd.) Operating Systems. Autumn CS4023

Transcription

1 Operating Systems Autumn

2 Outline Process Synchronisation (contd.) 1 Process Synchronisation (contd.)

3 Synchronization Hardware 6.4 (SGG) Many systems provide hardware support for critical section code Could disable interrupts ( uniprocessor ) Currently running code would execute without preemption Generally too inefficient on multiprocessor systems OSs using this are not broadly scalable Modern machines provide special atomic hardware instructions test-and-set test memory locn and (possibly) set value (see SGG); see, also compare-and-swap Or swap contents of two memory words

4 Semaphores Process Synchronisation (contd.) Synchronization tool that minimizes busy waiting Semaphore S, can be implemented with no more than an integer variable Only two operations allowed on S wait() and signal() Originally called P() and V() (Dutch Probeer & Verhoog) Less complicated Can only be accessed via two indivisible (atomic) operations whose implementation are wait(s) { while (S <= 0) ; // no-op busy waiting S- -; // must be atomic } Signal(S) { S++; // must be atomic }

5 Semaphores as a General Synchronization Tool Counting semaphore integer value which can range over an unrestricted domain (permits more than one simultaneous access) Binary semaphore integer value can be only 0 or 1 can be simpler to implement Also known as a mutex lock (mutual exclusion) Can implement a counting semaphore S as a binary semaphore Provides mutual exclusion Semaphore S; // initialized to 1 CRITICAL SECTION

6 Semaphore Implementation with almost no Busy Waiting We would like a better solution since the wait() and signal() operations still have the issue of busy waiting, so... With each semaphore there is an associated waiting queue. Each entry in a waiting queue has two data items int count pointer to next record in the list Two 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

7 Semaphore Implementation with almost no Busy Waiting (contd.) Implementation of wait() void wait(s) { S.count- -; if (S.count < 0) block();// add this process to waiting queue } Implementation of signal() void signal(s) { S.count++; if (S.count <= 0) wakeup(p);// remove process P from waiting q }

8 Semaphore Implementation Must guarantee that no two processes can execute wait() and signal() on the same semaphore at the same time Thus, implementation of both functions becomes a critical section problem where the wait() and signal() code are placed in a critical section using an old-style busy waiting semaphore, S1 while(s1 < 0) /* no-op */ ; Now have busy waiting in critical section implementation But implementation code is short three lines long in both cases! Little busy waiting if critical section rarely occupied

9 Deadlock and Starvation Deadlock two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes Let S and Q be two semaphores initialized to 1 P 0 P 1 Starvation indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.

10 Deadlock and Starvation Deadlock two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes Let S and Q be two semaphores initialized to 1 P 0 P 1 Starvation indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.

11 Deadlock and Starvation Deadlock two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes Let S and Q be two semaphores initialized to 1 P 0 P 1 Starvation indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.

12 Deadlock and Starvation Deadlock two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes Let S and Q be two semaphores initialized to 1 P 0 P 1 Starvation indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.

13 Deadlock and Starvation Deadlock two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes Let S and Q be two semaphores initialized to 1 P 0 P 1 Starvation indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.

14 Deadlock and Starvation Deadlock two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes Let S and Q be two semaphores initialized to 1 P 0 P 1 Starvation indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.