Chapter 6 Process Synchronization Operating System Concepts 8

Chapter 6: Process Synchronization Operating System Concepts – 8 th Edition, Silberschatz, Galvin and Gagne © 2009

Module 6: Process Synchronization n n n Background The Critical-Section Problem Peterson’s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization Examples Operating System Concepts – 8 th Edition 6. 2 Silberschatz, Galvin and Gagne © 2009

Objectives n To introduce the critical-section problem, whose solutions can be used to ensure the consistency of shared data n To present both software and hardware solutions of the critical-section problem Operating System Concepts – 8 th Edition 6. 3 Silberschatz, Galvin and Gagne © 2009

Background n Concurrent access to shared data may result in data inconsistency Multiple threads in a single process n Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes Operating System Concepts – 8 th Edition 6. 4 Silberschatz, Galvin and Gagne © 2009

Background -2 n Disjoint threads use disjoint sets of variables, and do not use shared resources. l The progress of one thread is independent of all other threads, to which it is disjoint. n Non-disjoint threads influence each other by using shared data and/or resources. n Two possibilities: Competing threads: compete for access to the data resources l Cooperating threads: e. g. producer / consumer model l n Without synchronization, the effect of non-disjoint parallel threads influencing each other is not predictable and not reproducible. Operating System Concepts – 8 th Edition 6. 5 Silberschatz, Galvin and Gagne © 2009

Example -1 Suppose that we wanted to provide a solution to the consumerproducer problem that fills all the buffers. We can do so by having an integer count that keeps track of the number of full buffers. Initially, count is set to 0. It is incremented by the producer after it produces a new buffer and is decremented by the consumer after it consumes a buffer. Operating System Concepts – 8 th Edition 6. 6 Silberschatz, Galvin and Gagne © 2009

PROCESS SYNCHRONIZATION n The Producer Consumer Problem : n A producer process "produces" information "consumed" by a consumer process. n Here are the variables needed to define the problem: #define BUFFER_SIZE 10 typedef struct { DATA data; } item; item buffer[BUFFER_SIZE]; int in = 0; // Location of next input to buffer int out = 0; // Location of next removal from buffer int counter = 0; // Number of buffers currently full Operating System Concepts – 8 th Edition 6. 7 Silberschatz, Galvin and Gagne © 2009

Producer / Consumer Producer : item next. Produced; while (true) { /* produce an item and put in next. Produced */ while (count == BUFFER_SIZE) ; // do nothing buffer [in] = next. Produced; in = (in + 1) % BUFFER_SIZE; count++; } Consumer: item next. Consumed; while (true) { while (count == 0) ; // do nothing next. Consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; /* consume the item in next. Consumed } Concepts – 8 th Edition Operating System 6. 8 Silberschatz, Galvin and Gagne © 2009

Race Condition n count++ could be implemented as register 1 = count register 1 = register 1 + 1 count = register 1 n count-- could be implemented as register 2 = count register 2 = register 2 - 1 count = register 2 n Consider this execution interleaving with “count = 5” initially: S 0: producer execute register 1 = count {register 1 = 5} S 1: producer execute register 1 = register 1 + 1 {register 1 = 6} S 2: consumer execute register 2 = count {register 2 = 5} S 3: consumer execute register 2 = register 2 - 1 {register 2 = 4} S 4: producer execute count = register 1 {count = 6 } S 5: consumer execute count = register 2 {count = 4} count = 4 after count++ and count--, even though we started with count = 5 l Easy question: what other values can count be from doing this incorrectly? l n Obviously, we would like to have count++ execute, followed by count-- (or vice versa) Operating System Concepts – 8 th Edition 6. 9 Silberschatz, Galvin and Gagne © 2009

Example -2 - Operating System Concepts – 8 th Edition 6. 10 Silberschatz, Galvin and Gagne © 2009

Race Conditions n A race condition is where multiple processes/threads concurrently read and write to a shared memory location and the result depends on the order of the execution. n The part of the program, in which race conditions can occur, is called critical section Operating System Concepts – 8 th Edition 6. 11 Silberschatz, Galvin and Gagne © 2009

Critical Sections n A critical section is a piece of code that accesses a shared resource (data structure or device) that must not be concurrently accessed by more than one thread of execution. n The goal is to provide a mechanism by which only one instance of a critical section is executing for a particular shared resource. n Unfortunately, it is often very difficult to detect critical section bugs Operating System Concepts – 8 th Edition 6. 12 Silberschatz, Galvin and Gagne © 2009

Critical Sections -2 n A Critical Section Environment contains: l Entry Section Code requesting entry into the critical section. l Critical Section Code in which only one process can execute at any one time. l Exit Section The end of the critical section, releasing or allowing others in. l Remainder Section Rest of the code AFTER the critical section. do { Entry Section; critical section; Exit Section; reminder sections; } while (true); Operating System Concepts – 8 th Edition 6. 13 Silberschatz, Galvin and Gagne © 2009

Solution to Critical-Section Problem A solution to the critical-section problem must satisfy the following requirements: 1. Mutual Exclusion - If process Pi 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, or limit 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 Assume that each process executes at a nonzero speed No assumption concerning relative speed of the N processes Operating System Concepts – 8 th Edition 6. 14 Silberschatz, Galvin and Gagne © 2009

Critical section problem q an example , a kernel data structure that maintains a List of all open files in the system, If it will be accessed simultaneously by two processes this will result in a race condition. q Two general approaches to handle CS in OS: q Preemptive kernels e. g. Linux( carefully designed). q Nonpreemptive kernels e. g. Win. XP (free from race conditions ? ) Operating System Concepts – 8 th Edition 6. 15 Silberschatz, Galvin and Gagne © 2009

Peterson’s Solution q Two processes solution q It provides a good algorithmic description of solving the critical- section problem q Algorithm is only for 2 processes at a time q Processes are q P 0 q P 1 q Or can also be represented as Pi and Pj , q i. e. j=1 -i Operating System Concepts – 8 th Edition 6. 16 Silberschatz, Galvin and Gagne © 2009

2 process-Algorithm 1 n Let the processes share common integer variable turn n If process turn == i , Pi is allowed to execute in critical section n Let int turn =0 (or 1) n Do{ while (turn != i); But, l Guarantees mutual exclusion. l Does not guarantee progress --- enforces strict alternation of processes entering CS's l (if Pj decides not to reenter or crashes outside CS, then Pi cannot ever get in). Critical section Turn = j; }while(1) remainder section For Process Pi Sonali C. Operating System Concepts – 8 th Edition 17 6. 17 Silberschatz, Galvin and Gagne © 2009

2 process -Algorithm 2 n Shared variables boolean flag[2]; // “interest” bits initially flag [0] = flag [1] = false. l flag [i] = true Pi declares interest in entering its critical section n Process Pi // where the “other” process is Pj l do { flag[i] = true; // declare your own interest while (flag[ j]) ; //wait if the other guy is interested critical section flag [i] = false; // declare that you lost interest remainder section // allows other guy to enter } while (1); Sonali C. Operating System Concepts – 8 th Edition Process Synchronization 6. 18 18 Silberschatz, Galvin and Gagne © 2009

2 -PROCESS -Algorithm 2 n Satisfies mutual exclusion, but not progress requirement. If flag[ i] == flag[ j] == true, then deadlock - no progress l but barring this event, a non-CS guy cannot block you from entering l Can make consecutive re-entries to CS if other not interested l Sonali C. Operating System Concepts – 8 th Edition Process Synchronization 6. 19 19 Silberschatz, Galvin and Gagne © 2009

TWO-PROCESS -Algorithm 3 n Combined shared variables & approaches of algorithms 1 and 2. do { For Process Pi flag [i] = true; // declare your interest to enter turn = j; // assume it is the other’s turn-give PJ a chance while (flag [ j ] and turn == j) ; critical section flag [i] = false; remainder section } while (1); Sonali C. Operating System Concepts – 8 th Edition Process Synchronization 6. 20 20 Silberschatz, Galvin and Gagne © 2009

TWO-PROCESS-Algorithm 3 n Meets all three requirements; solves the critical- section problem for two processes. l Turn variable breaks any deadlock possibility of previous example, AND prevents “hogging” – Pi setting turn to j gives PJ a chance after each pass of Pi’s CS l Flag[ ] variable prevents getting locked out if other guy never re-enters or crashes outside and allows CS consecutive access other not interested in entering. Sonali C. Operating System Concepts – 8 th Edition Process Synchronization 6. 21 21 Silberschatz, Galvin and Gagne © 2009

Synchronization Hardware n Many systems provide hardware support for critical section code n Uniprocessors – could disable interrupts Currently running code would execute without preemption l Generally too inefficient on multiprocessor systems 4 Operating systems using this not broadly scalable n Modern machines provide special atomic hardware instructions 4 Atomic = non-interruptable l Either test memory word and set value(Test. And. Set()) l Or swap contents of two memory words(Swap()) l n Test. And. Set is hard to program for end users Operating System Concepts – 8 th Edition 6. 22 Silberschatz, Galvin and Gagne © 2009

Semaphore n Semaphore: a synchronization tool, A flag used to indicate that a routine cannot proceed if a shared resource is already in use by another routine. Semaphore S – integer variable n Two standard operations modify S: wait() and signal() n l Originally called P() and V() Less complicated n Can only be accessed via two indivisible (atomic) operations l wait (S) { while S <= 0 ; // no-op S--; } l signal (S) { S++; } n Operating System Concepts – 8 th Edition 6. 23 Silberschatz, Galvin and Gagne © 2009

Semaphore as General Synchronization Tool n Two types: l Counting semaphore – integer value can range over an unrestricted domain l Binary semaphore – integer value can range only between 0 and 1; can be simpler to implement 4 Also known as mutex locks (they are locks that provide mutual exclusion) n There are 3 uses for Semaphores: Operating System Concepts – 8 th Edition 6. 24 Silberschatz, Galvin and Gagne © 2009

Semaphores Usage 1: n Binary semaphores can solve the critical-section problem for n processes. The n processes share a semaphore, mutex, initialized to 1. Each process Pi is organized as: Semaphore mutex; // initialized to 1 do { wait (mutex); // Critical Section signal (mutex); // remainder section } while (TRUE); n Only one process is allowed into Critical Section (mutual exclusion). Operating System Concepts – 8 th Edition 6. 25 Silberschatz, Galvin and Gagne © 2009

Semaphores Usage 2: n Counting semaphores control access to a given resource of many instances. n Simply initialize the semaphore to K (# of available resources). n This allows K processes to enter their critical-sections and use that resource at a time. l Each process wants to use a resource performs wait( ) operation decrementing the count of the semaphore. l Each process releases a resource, it performs signal( ) operation incrementing the count of the semaphore. l When the count =0, all resources are being used. Any process wants to use a resource will block until count >0. Operating System Concepts – 8 th Edition 6. 26 Silberschatz, Galvin and Gagne © 2009

Semaphores Usage 3: n To solve synchronization problems. n Example: l Two concurrent processes: P 1 and P 2 l Statement S 1 in P 1 needs to be performed before statement S 3 in P 2 n Need to make P 2 wait until P 1 tells “it is OK to proceed” l Define a semaphore “synch” Initialize synch to 0. l In P 2: wait(synch); S 3; l And in P 1: S 1 ; signal(synch); Operating System Concepts – 8 th Edition 6. 27 Silberschatz, Galvin and Gagne © 2009

Semaphore Implementation n 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 n This type of semaphore is also called a spinlock because the process “spins” while waiting for the lock Operating System Concepts – 8 th Edition 6. 28 Silberschatz, Galvin and Gagne © 2009

Semaphore Implementation with no Busy waiting n With each semaphore there is an associated waiting queue. Each entry in a waiting queue has two data items: l value (of type integer) l pointer to next record in the list n Two operations: l block – place the process invoking the operation on the appropriate waiting queue. and the state of the process is switched to the waiting state. l Then control is transferred to the CPU scheduler, which selects another process to execute. l wakeup – remove one of processes in the waiting queue and place it in the ready queue. Operating System Concepts – 8 th Edition 6. 29 Silberschatz, Galvin and Gagne © 2009

Semaphore Implementation with no Busy waiting (Cont. ) v Implementation of wait: wait(semaphore *S) { S->value--; if (S->value < 0) { add this process to S->list; block(); } } v Implementation of signal: signal(semaphore *S) { S->value++; if (S->value <= 0) { remove a process P from S->list; wakeup(P); } } Operating System Concepts – 8 th Edition 6. 30 Silberschatz, Galvin and Gagne © 2009

struct semaphore { int count; queue. Type queue; } n A queue is used to void wait(semaphore s) hold processes { s. count--; waiting on a if (s. count < 0) semaphore. { place this process in s. queue; block this process } } void signal(semaphore s) { s. count++; if (s. count <= 0) { remove a process P from s. queue; place process P on ready list; } Sonali C. Process Synchronization 31 Silberschatz, Galvin and Gagne © 2009 6. 31 Operating System Concepts – 8 Edition } th

Semaphore n It's critical that these be atomic, We must guarantee that no two processes can execute wait()and signal()operations on the same semaphore at the same time. n in uniprocessors we can disable interrupts, n but in multiprocessors other mechanisms for atomicity are needed. Operating System Concepts – 8 th Edition 6. 32 Silberschatz, Galvin and Gagne © 2009

Deadlock n Deadlock – two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes n Let S and Q be two semaphores initialized to 1 P 0 P 1 wait (S); wait (Q); . . . signal (S); signal (Q); wait (S); . . . signal (Q); signal (S); l Suppose that P 0 executes wait(S) and P 1 then executes wait(Q). l When P 0 executes wait(Q), it must wait until P 1 executes signal(Q). l Similarly, when P 1 executes wait(S), it must wait until P 0 executes signal (S). l Since these signal () operations cannot be executed, P 0 and P 1 are deadlocked. Operating System Concepts – 8 th Edition 6. 33 Silberschatz, Galvin and Gagne © 2009

Starvation v Starvation – indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended. Operating System Concepts – 8 th Edition 6. 34 Silberschatz, Galvin and Gagne © 2009

Classical Problems of Synchronization v Bounded-Buffer Problem v Bounded buffers P/C can be seen in e. g. streaming filters or packet switching in networks. v Readers and Writers Problem v Database readers and writers: online reservation systems; file systems. v Dining-Philosophers Problem v Dining philosophers could be a sequence of active database transactions that have a circular wait-for-lock dependence. v The Sleeping Barber problem v Sleeping Barber is often generally thought of as a client-server relationship. Operating System Concepts – 8 th Edition 6. 35 Silberschatz, Galvin and Gagne © 2009

Bounded-Buffer Problem v N buffers, each can hold one item v Semaphore mutex controls access to region and initialized to the value 1. v Semaphore full counts full buffer slots and initialized to the value 0. v Semaphore empty counts empty buffer slots and initialized to the value N. Operating System Concepts – 8 th Edition 6. 36 Silberschatz, Galvin and Gagne © 2009

Bounded Buffer Problem (Cont. ) The structure of the producer process do { // produce an item in nextp wait (empty); /* decrement empty count */ wait (mutex); /* enter critical region */ // add the item to the buffer signal (mutex); /* leave critical region */ signal (full); /* increment count of full slots */ } while (TRUE); Operating System Concepts – 8 th Edition 6. 37 Silberschatz, Galvin and Gagne © 2009

Bounded Buffer Problem (Cont. ) The structure of the consumer process do { wait (full); /* decrement full count */ wait (mutex); /* enter critical region */ // remove an item from buffer to nextc signal (mutex); /* leave critical region */ signal (empty); /* increment count of empty slots */ // consume the item in nextc } while (TRUE); Operating System Concepts – 8 th Edition 6. 38 Silberschatz, Galvin and Gagne © 2009

Classical Problem 2: The Readers-Writers Problem Multiple readers or a single writer can use DB. writer X reader writer X X writer reader writer reader Operating System Concepts – 8 th Edition reader CSS 430 Processes Synchronization 6. 39 39 Silberschatz, Galvin and Gagne © 2009

Readers-Writers Problem v A data set is shared among a number of concurrent processes v Readers – only read the data set; they do not perform any updates v Writers – can both read and write v Problem – allow multiple readers to read at the same time. Only one single writer can access the shared data at the same time v Shared Data v Data set v Semaphore mutex initialized to 1 v Semaphore wrt initialized to 1 v Integer readcount initialized to 0 Operating System Concepts – 8 th Edition 6. 40 Silberschatz, Galvin and Gagne © 2009

Readers-Writers Problem (Cont. ) BINARY_SEMAPHORE wrt = 1; The structure of a reader process BINARY_SEMAPHORE mutex = 1; do { int readcount = 0; The structure of a writer process entry*/ readcount ++ ; if (readcount == 1) wait (wrt) ; /* 1 st reader locks writer */ signal (mutex) do { wait (wrt) ; // wait (mutex) ; /* Allow 1 reader in writing is // reading is performed signal (wrt) ; } while (TRUE); writer */ wait (mutex) ; readcount - - ; if (readcount == 0) signal (wrt) ; /*last reader frees signal (mutex) ; } while (TRUE); Operating System Concepts – 8 th Edition 6. 41 Silberschatz, Galvin and Gagne © 2009

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

The Structure of Philosopher i n Philosopher i while ( true ) { // get left chopstick wait(chop. Stick[i]); // get right chopstick wait(chop. Stick[(i + 1) % 5]); // eat for a while //return left chopstick signal(chop. Stick[i]); // return right chopstick signal(chop. Stick[(i + 1) % 5]); // think for awhile } Waiting Picked up A deadlock occurs! Operating System Concepts – 8 th Edition CSS 430 Processes Synchronization 6. 43 43 Silberschatz, Galvin and Gagne © 2009

Dining-Philosophers Problem v 5 philosophers with 5 chopsticks sit around a circular table. They each want to eat at random times and must pick up the chopsticks on their right and on their left. v Clearly deadlock is rampant ( and starvation possible. ) v Several solutions are possible: v • Allow only 4 philosophers to be hungry at a time. v • Allow pickup only if both chopsticks are available. ( Done in critical section ) v • Odd # philosopher always picks up left chopstick 1 st, even # philosopher always picks up right chopstick 1 st. Operating System Concepts – 8 th Edition 6. 44 Silberschatz, Galvin and Gagne © 2009

The Sleeping Barber Problem A barbershop consists of a waiting room with N chairs, and the barber room containing the barber chair. If there are no customers to be served the barber goes to sleep. If a customer enters the barbershop and all chairs are busy, then the customer leaves the shop. If the barber is busy, then the customer sits in one of the available free chairs. If the barber is asleep, the customer wakes the barber up. Operating System Concepts – 8 th Edition 6. 45 Silberschatz, Galvin and Gagne © 2009

The Sleeping Barber Problem The following pseudo-code guarantees synchronization between barber and customer and is deadlock free, but may lead to starvation of a customer The Customer (Thread/Process): while(true) { //runs in an infinite loop wait(access. Seats) //tries to get access to the chairs Semaphore Customers = 0 Semaphore Barber = 0 if ( Number. Of. Free. Seats > 0 ) { //if there any free seats Semaphore access. Seats (mutex) = 1 int Number. Of. Free. Seats = N //total number of seats The Barber (Thread/Process): while(true) { //runs in an infinite loop wait(Customers) //tries to acquire a customer - if none is available he goes to sleep wait(access. Seats) //at this time he has been awakened - want to modify the number of available seats Number. Of. Free. Seats++ //one chair gets free signal(Barber) //the barber is ready to cut Number. Of. Free. Seats-- //sitting down on a chair signal(Customers) //notify the barber, who's waiting that there is a customer signal(access. Seats) //don't need to lock the chairs anymore wait(Barber) //now it's this customer's turn, but wait if the barber is busy //here the customer is having his hair cut } else { //there are no free seats //tough luck signal(access. Seats) //but don't forget to release the lock on the seats //customer leaves without a haircut } } signal(access. Seats) //we don't need the lock on the chairs anymore //here the barber is cutting hair } Operating System Concepts – 8 th Edition 6. 46 Silberschatz, Galvin and Gagne © 2009

Synchronization Examples v Windows XP v Linux Operating System Concepts – 8 th Edition 6. 47 Silberschatz, Galvin and Gagne © 2009

Windows XP Synchronization v Uses interrupt masks to protect access to global resources on uniprocessor systems. v Uses spinlocks on multiprocessor systems v Also provides dispatcher objects which may act as either mutexes and semaphores v Dispatcher objects may also provide events v An event acts much like a condition variable(they may notify a waiting thread when a desired condition occurs). Nonsignaled owner thread releases mutex lock signaled thread acquires mutex lock Operating System Concepts – 8 th Edition 6. 48 Silberschatz, Galvin and Gagne © 2009

Linux Synchronization v Linux: v Prior to kernel Version 2. 6, a nonpreemptive kernel. v Version 2. 6 and later, fully preemptive v Linux provides: v semaphores v spin locks Single processor Multiple processors Disable kernel preemption Acquire spin lock enable kernel preemption Release spin lock Operating System Concepts – 8 th Edition 6. 49 Silberschatz, Galvin and Gagne © 2009

End of Chapter 6 Operating System Concepts – 8 th Edition, Silberschatz, Galvin and Gagne © 2009