1. Chapter 6: Process Synchronization

2. 6.2 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Objectives Understand The Critical-Section Problem And its hardware and software solutions

3. 6.3 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Consumer-Producer Problem Classic example of process coordination Two processes sharing a buffer One places items into the buffer (producer) Must wait if the buffer if full The other takes items from the buffer (consumer) Must wait if buffer is empty Solution: Keep a counter on number of items in the buffer

4. 6.4 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Producer while (true) { /* produce an item in nextProduced */ while (count == BUFFER_SIZE) ; // do nothing buffer [in] = nextProduced; in = (in + 1) % BUFFER_SIZE; count++; }

5. 6.5 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Consumer while (true) { while (count == 0) ; // do nothing nextConsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; /* consume the item in nextConsumed */ } What can go wrong with this solution?

6. 6.6 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Race Condition count++ could be implemented a register1 = count register1 = register1 + 1 count = register1 count-- could be implemented as register2 = count register2 = register2 - 1 count = register2 Consider this execution interleaving with “count = 5” initially: S0: producer execute register1 = count {register1 = 5} S1: producer execute register1 = register1 + 1 {register1 = 6} S2: consumer execute register2 = count {register2 = 5} S3: consumer execute register2 = register2 - 1 {register2 = 4} S4: producer execute count = register1 {count = 6 } S5: consumer execute count = register2 {count = 4}

7. 6.7 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Race Condition Occurs when multiple processes manipulate shared data concurrently and the result depends on the particular order of manipulation Data inconsistency may arise Solution idea Mark code segment that manipulates shared data as critical section If a process is executing its critical section, no other processes can execute their critical sections More formally, any method that solves the Critical-Section Problem must satisfy three requirements …

8. 6.8 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Critical-Section Problem 1. Mutual Exclusion - If process P i is executing in its critical section, then no other processes can be executing in their critical sections 2. Progress - If no process is executing in its critical section and there exist some processes that wish to enter their critical section, then the selection of the processes that will enter the critical section next cannot be postponed indefinitely 3. Bounded Waiting - A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its critical section and before that request is granted Assumptions Each process executes at a nonzero speed No restriction on the relative speed of the N processes

9. 6.9 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Peterson’s Solution Software solution; no hardware support Two process solution Assume that the LOAD and STORE instructions are atomic; that is, cannot be interrupted (may not always be true in modern computers) The two processes share two variables: int turn; Boolean flag[2]; turn indicates whose turn it is to enter the critical section The flag array indicates whether a process is ready to enter the critical section flag[i] = true ==> process P i is ready

10. 6.10 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Algorithm for Process P i while (true) { flag[i] = TRUE; turn = j; while (flag[j] && turn == j) ; CRITICAL SECTION flag[i] = FALSE; REMAINDER SECTION } Does this algorithm satisfy the three requirements?

11. 6.11 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Synchronization Hardware Uniprocessors – could disable interrupts Currently running code would execute without preemption Generally too inefficient on multiprocessor systems  Operating systems using this not broadly scalable Many systems provide hardware support for critical section code  more efficient and easier for programmers Modern machines provide special atomic hardware instructions  Atomic = non-interruptable Either test memory word and set value Or swap contents of two memory words

12. 6.12 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 TestAndndSet Instruction Definition: boolean TestAndSet (boolean *target) { boolean rv = *target; *target = TRUE; return rv; }

13. 6.13 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Solution using TestAndSet Shared boolean variable lock, initialized to false while (true) { while ( TestAndSet (&lock ) ) ; /* do nothing // critical section lock = FALSE; // remainder section } Does this algorithm satisfy the three requirements? NO. A process can wait indefinitely for another faster process that is accessing its CS. Check Fig 6.8 for a modified version.

14. 6.14 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Swap Instruction Definition: void Swap (boolean *a, boolean *b) { boolean temp = *a; *a = *b; *b = temp: }

15. 6.15 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Solution using Swap Shared boolean variable lock initialized to FALSE; Each process has a local boolean variable key while (true) { key = TRUE; while ( key == TRUE) Swap (&lock, &key ); // critical section lock = FALSE; // remainder section }

16. 6.16 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Semaphore Much easier to use than hardware-based solutions Semaphore S – integer variable Two standard operations modify S: wait() signal() These two operations are indivisible (atomic)

17. 6.17 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Semaphore Operations wait (S) { while (S <= 0) ; // no-op, called busy waiting, spinlock S--; } signal (S) { S++; } Later, we will see how to implement these operations with no busy waiting

18. 6.18 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Semaphore Usage Counting semaphore – can be any integer value Binary semaphore – can be 0 or 1, (also known as mutex locks) Mutual exclusion Semaphore mutex; // initialized to 1 wait (mutex); Critical Section signal (mutex); Process synchronization: S2 in P2 should be executed after S1 in P1 P1: S1; signal (sem); P2: wait (sem); S2; Control access to a resource with finite number of instances Example: producer-consumer problem with finite buffer

19. 6.19 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Semaphore Implementation with no Busy waiting With each semaphore there is an associated waiting queue. Each entry in a waiting queue has two data items: value (of type integer) 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 the processes in the waiting queue and place it in the ready queue.

20. 6.20 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Semaphore Implementation with no Busy Waiting wait (S) { value--; if (value < 0) { add this process to waiting queue block(); } } signal (S) { value++; if (value <= 0) { /*if some processes are waiting*/ remove a process P from waiting queue wakeup(P); } }

21. 6.21 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Semaphore Implementation Must guarantee that no two processes can execute wait and signal on the same semaphore at the same time Thus, implementation becomes the critical section problem where the wait and signal code are placed in the critical section, and protected by Disabling interrupts (uniprocessor systems only) Busy waiting or spinlocks (multiprocessor systems)  Can not disable interrupts on all processors (too costly and degrades performance) Well, why we do not do the above in applications anyway? Applications may spend long (and unknown) amount of time in critical sections, unlike the kernel which spends a short and known beforehand time in the critical section (~ ten instructions)

22. 6.22 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 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 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.

23. 6.23 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Classical Problems of Synchronization Bounded-Buffer Problem Readers and Writers Problem Dining-Philosophers Problem These problems are usually used to test newly proposed synchronization schemes

24. 6.24 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Bounded-Buffer Problem 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

25. 6.25 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Bounded Buffer Problem (Cont.) The structure of the producer process while (true) { // produce an item wait (empty); wait (mutex); // add the item to the buffer signal (mutex); signal (full); }

26. 6.26 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Bounded Buffer Problem (Cont.) The structure of the consumer process while (true) { wait (full); wait (mutex); // remove an item from buffer signal (mutex); signal (empty); // consume the removed item }

27. 6.27 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Dining-Philosophers Problem Shared data Bowl of rice (data set) Semaphore chopstick [5] initialized to 1

28. 6.28 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Dining-Philosophers Problem (Cont.) The structure of Philosopher i: While (true) { wait ( chopstick[i] ); wait ( chopStick[ (i + 1) % 5] ); // eat signal ( chopstick[i] ); signal (chopstick[ (i + 1) % 5] ); // think }

29. 6.29 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Be Careful When You Use Semaphores Some common problems … signal (mutex) …. wait (mutex)  Multiple processes can access CS at the same time wait (mutex) … wait (mutex)  Processes may block for ever Omitting of wait (mutex) or signal (mutex) (or both)

30. 6.30 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Synchronization Examples Windows XP Linux Pthreads

31. 6.31 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Windows XP Synchronization Uses interrupt masks to protect access to global resources on uniprocessor systems (inside kernel) Uses spinlocks on multiprocessor systems Also provides dispatcher objects for thread synchronization outside kernel, which can act as mutexes, semaphores, or events (condition variables)

32. 6.32 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Linux Synchronization Linux: disables interrupts to implement short critical sections (on single processor systems) Linux provides: semaphores Spinlocks (on SMP)

33. 6.33 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Pthreads Synchronization Pthreads API is OS-independent It provides: mutex locks condition variables extensions include: semaphores read-write locks spin locks May not be portable #include pthread_mutex_t mutex; pthread_mutex_init(&mutex, null); pthread_mutex_lock(&mutex); pthread_mutex_unlock(&mutex); #include sem_t sem; sem_init(&sem, 0, 5); sem_wait(&sem); sem_post(&sem);

34. 6.34 Silberschatz, Galvin and Gagne ©2005 Operating System Concepts – 7 th Edition, Feb 8, 2005 Summary Processor Synchronization Techniques to coordinate access to shared data Race condition Multiple processes manipulating shared data and result depends on execution order Critical section problem Three requirements: mutual exclusion, progress, bounded waiting Software solution: Peterson’s Algorithm Hardware support: TestAndSet(), Swap()  Busy waiting (or spinlocks) Semaphores:  Not busy waiting  wait(), signal() must be atomic  moves the CS problem to kernel Some classical synchronization problems Consumer-producer Dining philosopher Readers-writers Examples Win XP, Linux, Pthreads