Chapter 5: Process Synchronization

Size: px
Start display at page:

Download "Chapter 5: Process Synchronization"

Transcription

1 Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Alternative Approaches 5.2 Silberschatz, Galvin and Gagne

2 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Alternative Approaches 5.3 Silberschatz, Galvin and Gagne Silberschatz, Galvin and Gagne

3 Background Processes can execute concurrently May be interrupted at any time, partially completing execution Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes 5.6 Silberschatz, Galvin and Gagne 2013 An example: the early P-C solution item buffer[buffer_size]; int in = 0; int out = 0; Producer item next_produced; while (true) { /* produce an item in next_produced */ while (((in + 1) % BUFFER_SIZE) == out) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; item next_consumed; while (true) { Consumer while (in == out) ; /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; /* consume the item in next_consumed */ 5.7 Silberschatz, Galvin and Gagne

4 An example: the early P-C solution (con t) Suppose that we wanted to provide a solution to the consumer-producer problem that fills all the buffers. Having an integer counter that keeps track of the number of full buffers. Initially, counter 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. 5.8 Silberschatz, Galvin and Gagne 2013 Producer while (true) { /* produce an item in next produced */ while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; counter++; 5.9 Silberschatz, Galvin and Gagne

5 Consumer while (true) { while (counter == 0) ; /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; /* consume the item in next consumed */ 5.10 Silberschatz, Galvin and Gagne 2013 Race Condition counter++ could be implemented as register1 = counter register1 = register1 + 1 counter = register1 counter-- could be implemented as register2 = counter register2 = register2-1 counter = register Silberschatz, Galvin and Gagne

6 Race Condition Consider this execution interleaving with count = 5 initially: producer execute counter++ S0: register1 = counter {register1 = 5 S1: register1 = register1 + 1 {register1 = 6 S2: consumer execute S3: consumer execute S4: counter = register1 {counter = 6 S5: consumer execute consumer execute counter-- S0: producer execute S1: producer execute S2: register2 = counter {register2 = 5 S3: register2 = register2 1 {register2 = 4 S4: producer execute S5: counter = register2 {counter = Silberschatz, Galvin and Gagne 2013 Critical Section General structure of process P i 5.13 Silberschatz, Galvin and Gagne

7 Producer: where is the Critical-Section? while (true) { /* produce an item in next produced */ while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next_produced; entry code in = (in + 1) % BUFFER_SIZE; counter++; exit code Will reading a variable cause race condition? 5.14 Silberschatz, Galvin and Gagne 2013 Critical Section Problem Consider system of n processes {p 0, p 1, p n-1 Each process has critical section segment of code Process may be changing common variables, updating table, writing file, etc When one process in critical section, no other may be in its critical section Critical section problem is to design protocol to solve this Each process must ask permission to enter critical section in entry section, may follow critical section with exit section, then remainder section 5.15 Silberschatz, Galvin and Gagne

8 Solution to Critical-Section Problem Requirements: 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 Assume that each process executes at a nonzero speed No assumption concerning relative speed of the n processes 5.16 Silberschatz, Galvin and Gagne 2013 Critical-Section Handling in OS Two approaches depending on if kernel is preemptive or non-preemptive Preemptive allows preemption of process when running in kernel mode Non-preemptive runs until exits kernel mode, blocks, or voluntarily yields CPU Essentially free of race conditions in kernel mode 5.17 Silberschatz, Galvin and Gagne

9 Exercise In the counter-based implementation of producer-consumer problem, could buffer produce race condition? How so? Show analysis. item next_produced; while (true) { /* produce an item in next produced */ while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; counter++; item buffer[buffer_size]; int in = 0; int out = 0; int counter = 0; Producer item next_consumed; while (true) { while (counter == 0) ; /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; /* consume the item in next consumed */ Consumer What about variables in and out? 5.18 Silberschatz, Galvin and Gagne 2013 Could the code produce race condition? item buffer[buffer_size]; int in = 0; int out = 0; Producer item next_produced; while (true) { /* produce an item in next produced */ while (((in + 1) % BUFFER_SIZE) == out) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; item next_consumed; while (true) { Consumer while (in == out) ; /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; /* consume the item in next consumed */ 5.19 Silberschatz, Galvin and Gagne

10 5.20 Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Alternative Approaches a Because good algorithmic of the way description modern computer of solving architectures the criticalsection perform problem basic machine-language and illustrates some instructions, of the complexities such as involved load and in store, designing there software no guarantees that addresses that the requirements Peterson s solution of mutual will exclusion, work correctly progress, on such and bounded waiting. architectures Silberschatz, Galvin and Gagne

11 First Try: Algorithm for P 1 and P 2 P1: do { while (turn == 2); critical section turn = 2; remainder section while (true); 5.22 Silberschatz, Galvin and Gagne 2013 Second Try: Algorithm for P 1 and P 2 Boolean f1,f2; // true: process is ready to enter CS! P1: do { f1 = true; while (f2); // do nothing critical section f1 = false; remainder section while (true); P2: do { f2 = true; while (f1); // do nothing critical section f2 = false; remainder section while (true); 5.23 Silberschatz, Galvin and Gagne

12 Third Try: Algorithm for P 1 and P 2 Boolean f1,f2; // true: process is ready to enter CS! int turn; //turn: whose turn it is to enter the CS; P1: do { f1 = true; turn = 2; while (f2 && turn = = 2); // do nothing critical section f1 = false; remainder section while (true); P2: do { f2 = true; turn = 1; while (f1 && turn = = 1); // do nothing critical section f2 = false; remainder section while (true); 5.24 Silberschatz, Galvin and Gagne 2013 Peterson s Solution Good algorithmic description of solving the problem Two process solution Assume that the load and store machine-language instructions are atomic; that is, cannot be interrupted The two processes share two variables: int turn; Boolean flag[2] The variable turn indicates whose turn it is to enter the critical section The flag array is used to indicate if a process is ready to enter the critical section. flag[i] = true implies that process P i is ready! 5.25 Silberschatz, Galvin and Gagne

13 Algorithm for Process P i int turn; Boolean flag[2] do { flag[i] = true; turn = j; while (flag[j] && turn = = j); critical section flag[i] = false; while (true); // Suppose i = 0, j = 1; // Code similar for Pj. remainder section turn: whose turn it is to enter the CS; flag[i] = true: process Pi is ready! 5.26 Silberschatz, Galvin and Gagne 2013 Peterson s Solution (Cont.) Provable that the three CS requirements are met: 1. Mutual exclusion is preserved P i enters CS only if: either flag[j] = false or turn = i 2. Progress requirement is satisfied 3. Bounded-waiting requirement is met 5.27 Silberschatz, Galvin and Gagne

14 Example 1 Initial : turn = 0 ; flag[0] = FALSE ; flag[1] = FALSE Process 0 Process 1 flag[0] = TRUE turn = 1 check (flag[1] == TRUE and turn == 1) - Condition is false because flag[1] = FALSE - Since condition is false, no waiting in while loop - Enter the critical section - Process 0 happens to lose the processor - Process 0 resumes and continues until it finishes in the critical section - Leave critical section flag[0] = FALSE Start executing the remainder - Process 0 happens to lose the processor flag[1] = TRUE turn = 0 check (flag[0] == TRUE and turn == 0) - Since condition is true, it keeps busy waiting until it loses the processor check (flag[0] == TRUE and turn == 0) - This condition fails because flag[0] == FALSE - No more busy waiting - Enter the critical section 5.28 Silberschatz, Galvin and Gagne 2013 Example 2 Initial : turn = 0 ; flag[0] = FALSE ; flag[1] = FALSE Process 0 Process 1 flag[0] = TRUE turn = 1 - Process 0 happens to lose the processor check (flag[1] == TRUE and turn == 1) -This condition is false because turn ==0 - Process 0 no waiting in loop - Enters critical section (try to work out the remaining, similar to example 1) flag[1] = TRUE turn = 0 check (flag[0] == TRUE and turn == 0) - Since condition is true, it keeps busy waiting until it loses the processor 5.29 Silberschatz, Galvin and Gagne

15 Example 3 Initial : turn = 0 ; flag[0] = FALSE ; flag[1] = FALSE Process 0 Process 1 flag[0] = TRUE Process 0 happens to lose the processor turn = 1 check (flag[1] == TRUE and turn == 1) - Condition is true so it busy waits until it loses the processor flag[1] = TRUE turn = 0 check (flag[0] == TRUE and turn == 0) - Since condition is true, it keeps busy waiting until it loses the processor check (flag[0] == TRUE and turn == 0) - This condition fails because turn== 1 - So no busy waiting, it enters the critical section 5.30 Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Alternative Approaches 5.31 Silberschatz, Galvin and Gagne

16 Synchronization Hardware (I) Many systems provide hardware support for implementing the critical section code. All solutions below based on idea of locking Protecting critical regions via locks do { acquire lock critical section release lock remainder section while (TRUE); Check LOCK, If locked, wait till unlock; (!) Lock the LOCK; (enter CS) Unlock the LOCK; (exit CS) 5.32 Silberschatz, Galvin and Gagne 2013 Synchronization Hardware (II) Uniprocessors could disable interrupts Currently running code would execute without preemption Generally too inefficient on multiprocessor systems Operating systems using this not broadly scalable Modern machines provide special atomic hardware instructions Atomic = non-interruptible Either test memory word and set value Or swap contents of two memory words 5.34 Silberschatz, Galvin and Gagne

17 test_and_set Instruction Definition: boolean test_and_set (boolean *target) { boolean rv = *target; *target = TRUE; return rv: 1. Executed atomically 2. Returns the original value of passed parameter 3. Set the new value of passed parameter to TRUE Silberschatz, Galvin and Gagne 2013 Solution using test_and_set() Shared Boolean variable lock, initialized to FALSE Solution: do { while (test_and_set(&lock)) ; /* do nothing */ /* critical section */ Why this is good? lock = false; /* remainder section */ while (true); 5.36 Silberschatz, Galvin and Gagne

18 Analysis the two cases 1. Mutual Exclusion - 2. Progress - 3. Bounded Waiting Silberschatz, Galvin and Gagne 2013 Solution using test_and_set() Shared Boolean variable lock, initialized to FALSE Solution: do { while (test_and_set(&lock)) ; /* do nothing */ /* critical section */ lock = false; /* remainder section */ while (true); 5.38 Silberschatz, Galvin and Gagne

19 Example, Analyze test_and_set() target = FALSE Process 1 Process 2 Want to set target to TRUE Target is changed to TRUE Result comes back as FALSE, so no busy-waiting In critical section Want to set target to TRUE It receives the result TRUE busy-waits as long as Process 1 is in the critical section Leaves critical section Sets target to FALSE Mutual Exclusion, Progress, Bounded Waiting 5.39 Silberschatz, Galvin and Gagne 2013 Bounded-waiting Mutual Exclusion with test_and_set Order the processes, remember which are waiting. Boolean waiting[n]; Boolean lock; do { Is itself waiting & locked? If so, busy-waiting; (unlocked); set itself not waiting; /* critical section */ Find next waiting process; if found, Make it not waiting; Or, unlock /* remainder section */ while (true); 5.40 Silberschatz, Galvin and Gagne

20 Bounded-waiting Mutual Exclusion with test_and_set do { waiting[i] = true; key = true; while (waiting[i] && key) key = test_and_set(&lock); waiting[i] = false; /* critical section */ j = (i + 1) % n; while ((j!= i) &&!waiting[j]) j = (j + 1) % n; if (j == i) else lock = false; waiting[j] = false; /* remainder section */ while (true); Boolean waiting[n]; Boolean lock; Note: key is local; 2 conds for entering CS Find next waiting process, Still in CS No waiting process, exit by lock = F Find a waiting, Exit by set it to not waiting, But lock is T 5.41 Silberschatz, Galvin and Gagne 2013 Analysis the solution 1. Mutual Exclusion - 2. Progress - 3. Bounded Waiting Silberschatz, Galvin and Gagne

21 5.43 Silberschatz, Galvin and Gagne 2013 Recap: Check LOCK, If locked, wait till unlock; (!) Lock the LOCK; (enter CS) CS Unlock the LOCK; (exit CS) Synchronization Hardware do { while (test_and_set(&lock)) ; /* do nothing */ /* critical section */ lock = false; /* remainder section */ while (true); Solutions meet three requirements: Mutual Exclusion, Progress, Bounded Waiting 5.44 Silberschatz, Galvin and Gagne

22 Definition: compare_and_swap Instruction int compare_and_swap(int *value, int expected, int new_value) { int temp = *value; if (*value == expected) *value = new_value; return temp; 1. Executed atomically 2. Returns the original value of passed parameter value 3. Set the variable value the value of the passed parameter new_value but only if value == expected. That is, the swap takes place only under this condition Silberschatz, Galvin and Gagne 2013 Solution using compare_and_swap Shared integer lock initialized to 0 (meaning, not locked); Solution: do { while (compare_and_swap(&lock, 0, 1)!= 0) ; /* do nothing */ /* critical section */ lock = 0; /* remainder section */ while (true); 5.46 Silberschatz, Galvin and Gagne

23 5.14 : use compare_and_swap to mutual exclusion that satisfies the bounded-waiting requirement. Study the solutions in 5.8 and 5.9; Prove that the three requirements are satisfied! Software solution 5.47 Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Alternative Approaches 5.49 Silberschatz, Galvin and Gagne

24 Mutex Locks Previous solutions are complicated and generally inaccessible to application programmers OS designers build software tools to solve critical section problem Simplest is mutex lock Boolean variable indicating if lock is available or not Protect a critical section by first acquire() a lock then release() the lock Calls to acquire() and release() must be atomic Usually implemented via hardware atomic instructions Note: this solution requires busy waiting This lock therefore called a spinlock 5.52 Silberschatz, Galvin and Gagne 2013 acquire() and release() let available be the mutex. acquire() { while (!available) ; /* busy wait */ available = false;; release() { available = true; 5.53 Silberschatz, Galvin and Gagne

25 Producer: Let A be a mutex, initialized to T; while (true) { /* produce an item in next produced */ while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; acquire(a); counter++; release(a); exit code entry code 5.54 Silberschatz, Galvin and Gagne 2013 Example 5.15 Consider how to implement a mutex lock using an atomic hardware instruction. Assume that the following structure defining the mutex lock is available: typedef struct { lock; int available; where (available == 0) indicates the lock is available; a value of 1 indicates the lock is unavailable. Using this struct, illustrate how the following functions may be implemented using the test_and_set() and compare_and_swap() instructions. void acquire(lock *mutex) void release(lock *mutex) Be sure to include any initialization that may be necessary Silberschatz, Galvin and Gagne

26 Example(cont d 1) // initialization mutex->available = 0; // acquire using test_and_set() void acquire(lock *mutex) { while (test_and_set(&mutex->available)!= 0) ; return; void release(lock *mutex) { mutex->available = 0; return; 5.57 Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Alternative Approaches 5.60 Silberschatz, Galvin and Gagne

27 Semaphore More sophisticated ways (than Mutex locks) for synchronizing process activities. Examples Can solve various synchronization problems Semaphore S integer variable Can only be accessed via two indivisible (atomic) operations wait() and signal() Originally called P() and V() 5.61 Silberschatz, Galvin and Gagne 2013 Semaphore Definition of the wait() operation wait(s) { while (S <= 0) ; // busy wait S--; Definition of the signal() operation signal(s) { S++; 5.62 Silberschatz, Galvin and Gagne

28 Semaphore Usage I Binary semaphore integer value can range only between 0 and 1 Same as a mutex lock The producer with counter: Create a semaphore W initialized to 1; while (true) { /* produce an item in next produced */ while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; wait(w); counter++; signal(w); 5.63 Silberschatz, Galvin and Gagne 2013 Semaphore Usage II Counting semaphore integer value can range over an unrestricted domain Semaphore empty initialized to the value n Counting the number of empty buffers do { /* produce an item in next_produced */ wait(empty); // More to add later /* add next produced to the buffer */ // More to add later; signal(full); while (true); Can implement a counting semaphore S as a binary semaphore 5.64 Silberschatz, Galvin and Gagne

29 Semaphore Usage III Other types of synchronization problems Generate an order: Consider P 1 and P 2 that require S 1 to happen before S 2: Create a semaphore synch initialized to 0 P1: S 1 ; signal(synch); P2: wait(synch); S 2 ; 5.65 Silberschatz, Galvin and Gagne 2013 Semaphore Usage III (example) Semaphore empty initialized to the value n Counting the number of empty buffers Consumer has waited on full, counting on filled buffers, initialzed to 0 do { /* produce an item in next_produced */ wait(empty); // More to add later /* add next produced to the buffer */ // More to add later; signal(full); while (true); Can implement a counting semaphore S as a binary semaphore 5.66 Silberschatz, Galvin and Gagne

30 Semaphore Implementation (1) Three issues to consider: Critical section problem for wait() & signal() on the same semaphore; Busy-waiting; Bounded waiting; 5.67 Silberschatz, Galvin and Gagne 2013 Semaphore Implementation (2) Critical section problem No two processes can execute the wait() and signal() on the same semaphore at the same time Definition of the wait() operation wait(s) { while (S <= 0) ; // busy wait S--; Definition of the signal() operation signal(s) { S++; 5.68 Silberschatz, Galvin and Gagne

31 Semaphore Implementation (2.5) Critical section problem Thus, the implementation of semaphore, becomes the critical section problem where the wait and signal code are placed in the critical section Could now have busy waiting in critical section implementation But implementation code is short Little busy waiting if critical section rarely occupied Note: This is different from using semaphore for critical section of an application -- the applications may spend lots of time in critical sections and therefore busy waiting not a good solution 5.69 Silberschatz, Galvin and Gagne 2013 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 processes in the waiting queue and place it in the ready queue typedef struct{ int value; struct process *list; semaphore; 5.70 Silberschatz, Galvin and Gagne

32 Implementation with no Busy waiting (Cont.) wait(semaphore *S) { S->value--; if (S->value < 0) { add this process to S->list; block(); signal(semaphore *S) { S->value++; if (S->value <= 0) { remove a process P from S->list; wakeup(p); 5.71 Silberschatz, Galvin and Gagne 2013 Example Binary semaphore, initiated to value = 1 Process 1 Process 2 Start the wait routine S.value = 0 finish the wait routine Start the wait routine S.value = -1 If S.value < 0 then add P2 to queue Suspend P Silberschatz, Galvin and Gagne

33 The Requirements 1. Mutual Exclusion - 2. Progress - 3. Bounded Waiting Silberschatz, Galvin and Gagne 2013 An example 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); 5.75 Silberschatz, Galvin and Gagne

34 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 Starvation indefinite blocking A process may never be removed from the semaphore queue in which it is suspended Two cases: Last-in first-out queue of semaphore implementation Locks on kernel data structure and priority based scheduling Priority Inversion Scheduling problem when lower-priority process holds a lock needed by higher-priority process Solved via priority-inheritance protocol 5.76 Silberschatz, Galvin and Gagne 2013 Summary: Mutex and Semaphore Usage Mutex Boolean variable indicating if lock is available or not acquire()and release() Semaphore S integer variable wait() and signal() Binary semaphore integer value can range only between 0 and 1 Same as a mutex lock Counting semaphore integer value can range over an unrestricted domain Preserve an order of execution sequences Can solve various synchronization problems Solution requirements: Mutual Exclusion, Progress, Bounded Waiting Deadlock and Starvation 5.77 Silberschatz, Galvin and Gagne

35 Home Reading: know Mutex and Semaphore well, get ready to use them to solve problems on Friday Silberschatz, Galvin and Gagne Silberschatz, Galvin and Gagne

36 Recap: Mutex and Semaphore Usage Mutex Boolean variable indicating if lock is available or not acquire()and release() Semaphore S integer variable wait() and signal() Binary semaphore integer value can range only between 0 and 1 Same as a mutex lock Counting semaphore integer value can range over an unrestricted domain Preserve an order of execution sequences Can solve various synchronization problems Solution requirements: Mutual Exclusion, Progress, Bounded Waiting Deadlock and Starvation 5.80 Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Alternative Approaches 5.81 Silberschatz, Galvin and Gagne

37 Classical Problems of Synchronization Classical problems used to test newly-proposed synchronization schemes Bounded-Buffer Problem Readers and Writers Problem Dining-Philosophers Problem 5.82 Silberschatz, Galvin and Gagne 2013 item next_produced; while (true) { /* produce an item in next produced */ How do Producer and Consumer synch? item buffer[buffer_size]; int in = 0; int out = 0; int counter = 0; Producer while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; counter++; item next_consumed; while (true) { while (counter == 0) ; /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; Consumer Synch when buffer is full or empty. counting the numbers Synch when sheared data is accessed /* consume the item in next consumed */ 5.83 Silberschatz, Galvin and Gagne

38 Bounded-Buffer Problem n buffers, each can hold one item Semaphore mutex initialized to the value 1 Semaphore full initialized to the value 0 Counting the number of buffers holding an item Semaphore empty initialized to the value n Counting the number of empty buffers 5.86 Silberschatz, Galvin and Gagne 2013 Bounded Buffer Problem (Cont.) The structure of the Producer process do {... /* produce an item in next_produced */... wait(empty); wait(mutex);... /* add next produced to the buffer */... signal(mutex); signal(full);... while (true); 5.87 Silberschatz, Galvin and Gagne

39 Bounded Buffer Problem (Cont.) The structure of the Consumer process Do { wait(full); wait(mutex);... /* remove an item from buffer to next_consumed */... signal(mutex); signal(empty);... /* consume the item in next consumed */... while (true); 5.88 Silberschatz, Galvin and Gagne 2013 Producer - produce an item in nextp wait(empty); - Lose CPU wait(mutex); - add nextp to the buffer signal(mutex); signal(full); Evaluate Example mutex = 1; empty = n; full = 0; Consumer wait(full); - cannot proceed because no items in buffer - produce an item in nextp wait(empty); wait(mutex); - add nextp to the buffer signal(mutex); - Lose CPU - wait(full) is now successful because one item added to buffer 5.89 Silberschatz, Galvin and Gagne

40 Silberschatz, Galvin and Gagne 2013 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 considered all involve some form of priorities First variation no reader kept waiting unless writer has permission to use shared object Second variation once writer is ready, it performs the write ASAP Both may have starvation leading to even more variations 5.91 Silberschatz, Galvin and Gagne

41 Readers-Writers Problem First variation no reader kept waiting unless writer has permission to use shared object. When finding a writer is waiting (has readers already), new reader should not wait How to implement the logic of the problem? Shared Data set: Order readers and writers: If first reader, block W or be blocked by accessing W; // for latter case, till W done //counting readers; Semaphore rw_mutex initialized to 1 // W be blocked when Readers accessing //multiple W synched by rw_mutex; Integer read_count initialized to 0 Semaphore mutex initialized to 1 // synch multiple Readers If last reader, unblock W Silberschatz, Galvin and Gagne 2013 Readers-Writers Problem (Cont.) The structure of a Writer process do { wait(rw_mutex);... /* writing is performed */... signal(rw_mutex); while (true); 5.94 Silberschatz, Galvin and Gagne

42 Readers-Writers Problem (Cont.) The structure of a Reader process do { wait(mutex); read_count++; if (read_count == 1) wait(rw_mutex); signal(mutex);... /* reading is performed */... wait(mutex); read count--; if (read_count == 0) signal(rw_mutex); signal(mutex); while (true); 5.95 Silberschatz, Galvin and Gagne 2013 Evaluation, etc First variation of Readers-Writers problem Mutual Exclusion, Progress, Bounded Waiting Second variation once writer is ready, it performs the write ASAP When one or more writers is waiting to access the file, newly arriving readers are blocked When an active writer departs, waiting readers are unblocked in preference to unblocking another writer Encourage you to work out a solution. Semaphore Implementation Silberschatz, Galvin and Gagne

43 Assignment 2 Use a loop and sleep with a random number Use ONE makefile for all the three problems. Use comment spot in BBL submission to let TA know how to compile your code Silberschatz, Galvin and Gagne Silberschatz, Galvin and Gagne

44 Recap: Mutex and Semaphore Usage Mutex Boolean variable indicating if lock is available or not acquire()and release() Semaphore S integer variable wait() and signal() Binary semaphore integer value can range only between 0 and 1 Same as a mutex lock Counting semaphore integer value can range over an unrestricted domain Preserve an order of execution sequences Can solve various synchronization problems Solution requirements: Mutual Exclusion, Progress, Bounded Waiting Deadlock and Starvation Silberschatz, Galvin and Gagne 2013 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 the write ASAP Both may have starvation leading to even more variations Problem is solved on some systems by kernel providing reader-writer locks Silberschatz, Galvin and Gagne

45 Dining-Philosophers Problem Philosophers spend their lives alternating 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 Silberschatz, Galvin and Gagne 2013 Dining-Philosophers Problem Algorithm The structure of Philosopher i: do { wait (chopstick[i] ); wait (chopstick[ (i + 1) % 5] ); // eat signal (chopstick[i] ); signal (chopstick[ (i + 1) % 5] ); // think while (TRUE); What is the problem with this algorithm? Silberschatz, Galvin and Gagne

46 Dining-Philosophers Problem Algorithm (Cont.) Deadlock handling Allow at most 4 philosophers to be sitting simultaneously at the table. Allow a philosopher to pick up the forks only if both are available (picking must be done in a critical section. Use an asymmetric solution -- an oddnumbered philosopher picks up first the left chopstick and then the right chopstick. Evennumbered philosopher picks up first the right chopstick and then the left chopstick Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Alternative Approaches Silberschatz, Galvin and Gagne

47 producer while (true) { /* produce in nextproduced */ wait (mutex); while (count == BUFFER_SIZE) ; buffer [in] = nextproduced; in = (in + 1) % BUFFER_SIZE; count++; signal (mutex); mutex = 1; consumer while (true) { wait(mutex); while (count == 0) ; nextconsumed = buffer[out]; out = (out + 1) %BUFFER_SIZE; count--; signal (mutex); /* consume nextconsumed Silberschatz, Galvin and Gagne 2013 Problems with Semaphores Incorrect use of semaphore operations for synchronization. e.g., Mutual exclusion case: signal (sem1). wait (sem1) wait (sem1) wait (sem1) Omitting of wait (sem1) or signal (sem1) (or both) Deadlock and starvation are possible Silberschatz, Galvin and Gagne

48 Monitors A high-level abstraction that provides a convenient and effective mechanism for process synchronization Abstract data type, internal variables only accessible by code within the monitor Only one process may be active within the monitor at a time monitor monitor-name { // shared variable declarations procedure P1 ( ) {. procedure Pn ( ) { Initialization code ( ) { Silberschatz, Galvin and Gagne 2013 Schematic view of a Monitor But not powerful enough to model some synchronization schemes Silberschatz, Galvin and Gagne

49 Condition Variables condition x, y; Two operations are allowed on a condition variable: x.wait() a process that invokes the operation is suspended until x.signal() x.signal() resumes one of processes (if any) that invoked x.wait() If no x.wait() on the variable, then it has no effect on the variable Silberschatz, Galvin and Gagne 2013 Monitor with Condition Variables Silberschatz, Galvin and Gagne

50 Monitor Solution to Dining Philosophers monitor DiningPhilosophers { enum { THINKING; HUNGRY, EATING) state [5] ; condition self [5]; void pickup (int i) { state[i] = HUNGRY; test(i); if (state[i]!= EATING) self[i].wait; void putdown (int i) { state[i] = THINKING; // test left and right neighbors test((i + 4) % 5); test((i + 1) % 5); Silberschatz, Galvin and Gagne 2013 Solution to Dining Philosophers (Cont.) void test (int i) { if ((state[(i + 4) % 5]!= EATING) && (state[i] == HUNGRY) && (state[(i + 1) % 5]!= EATING) ) { state[i] = EATING ; self[i].signal () ; initialization_code() { for (int i = 0; i < 5; i++) state[i] = THINKING; Silberschatz, Galvin and Gagne

51 Solution to Dining Philosophers (Cont.) Each philosopher i invokes the operations pickup() and putdown() in the following sequence: DiningPhilosophers.pickup(i); EAT DiningPhilosophers.putdown(i); No deadlock, but starvation is possible Silberschatz, Galvin and Gagne A file is to be shared among different processes, each of which has a unique number. The file can be accessed simultaneously by several processes, subject to the following constraint: the sum of all unique numbers associated with all the processes currently accessing the file must be less than n. Write a monitor to coordinate access to the file. In process Pi, access_file(n);... finish_access(n); monitor file_access { int curr_sum = 0; int n; condition c; void access_file(int my_num) { while (curr_sum + my_num >= n) c.wait(); curr_sum += my_num; void finish_access(int my_num) { curr_sum -= my_num; c.signal(); Silberschatz, Galvin and Gagne

52 Implementation issues Silberschatz, Galvin and Gagne 2013 Condition Variables Choices If process P invokes x.signal(), and process Q is suspended in x.wait(), what should happen next? Both Q and P cannot execute in parallel. If Q is resumed, then P must wait Options include Signal and wait P waits until Q either leaves the monitor or it waits for another condition Signal and continue Q waits until P either leaves the monitor or it waits for another condition Both have pros and cons language implementer can decide Monitors implemented in Concurrent Pascal compromise P executing signal immediately leaves the monitor, Q is resumed Implemented in other languages including Mesa, C#, Java Silberschatz, Galvin and Gagne

53 Resuming Processes within a Monitor If several processes queued on condition x, and x.signal() executed, which should be resumed? FCFS works, also can be frequently not adequate conditional-wait construct of the form x.wait(c) Where c is priority number Process with lowest number (highest priority) is scheduled next Silberschatz, Galvin and Gagne 2013 Monitor Implementation Using Semaphores Use semaphore variables, wait and signal primitives Mutual exclusion 1. a mutex Queue and signaling 1. semaphore 2. counting x.wait() a process that invokes the operation is suspended until x.signal() x.signal() resumes one of processes (if any) that invoked x.wait() 2. counting and signal those on condition: counter next_count, and a signal semaphore next Silberschatz, Galvin and Gagne

54 Monitor Implementation Using Semaphores Variables semaphore mutex; // (initially = 1) semaphore next; // (initially = 0) int next_count = 0; Each procedure F will be replaced by wait(mutex); body of F; if (next_count > 0) signal(next) else signal(mutex); Mutual exclusion within a monitor is ensured Silberschatz, Galvin and Gagne 2013 Monitor Implementation Condition Variables For each condition variable x, we have: semaphore x_sem; // (initially = 0) int x_count = 0; The operation x.wait can be implemented as: x_count++; if (next_count > 0) signal(next); else signal(mutex); wait(x_sem); x_count--; Silberschatz, Galvin and Gagne

55 Monitor Implementation (Cont.) The operation x.signal can be implemented as: if (x_count > 0) { next_count++; signal(x_sem); wait(next); next_count--; Silberschatz, Galvin and Gagne 2013 Implementing Monitors using locks and condition variables Silberschatz, Galvin and Gagne

56 Synchronization Interface Examples Solaris Windows Linux Pthreads Silberschatz, Galvin and Gagne 2013 Solaris Synchronization Implements a variety of locks to support multitasking, multithreading (including real-time threads), and multiprocessing Uses adaptive mutexes for efficiency when protecting data from short code segments Starts as a standard semaphore spin-lock If lock held, and by a thread running on another CPU, spins If lock held by non-run-state thread, block and sleep waiting for signal of lock being released Uses condition variables Uses readers-writers locks when longer sections of code need access to data Uses turnstiles to order the list of threads waiting to acquire either an adaptive mutex or reader-writer lock Turnstiles are per-lock-holding-thread, not per-object Priority-inheritance per-turnstile gives the running thread the highest of the priorities of the threads in its turnstile Silberschatz, Galvin and Gagne

57 Windows Synchronization Uses interrupt masks to protect access to global resources on uniprocessor systems Uses spinlocks on multiprocessor systems Spinlocking-thread will never be preempted Also provides dispatcher objects user-land which may act mutexes, semaphores, events, and timers Events An event acts much like a condition variable Timers notify one or more thread when time expired Dispatcher objects either signaled-state (object available) or non-signaled state (thread will block) Silberschatz, Galvin and Gagne 2013 Linux Synchronization Linux: Prior to kernel Version 2.6, disables interrupts to implement short critical sections Version 2.6 and later, fully preemptive Linux provides: Semaphores atomic integers spinlocks reader-writer versions of both On single-cpu system, spinlocks replaced by enabling and disabling kernel preemption Silberschatz, Galvin and Gagne

58 Pthreads Synchronization Pthreads API is OS-independent It provides: mutex locks condition variable POSIX SEM extension (semaphore.h) Named semaphore By multiple unrelated processes Unnamed semaphore By threads of same process Non-portable extensions include: read-write locks spinlocks Silberschatz, Galvin and Gagne 2013 Monitor and condition variable in pthread We can implement monitors using pthread mutex and condition variable For producer-consumer problem, need 1 pthread mutex and 2 pthread condition variables ( pthread_cond_t) Silberschatz, Galvin and Gagne

59 Check Objectives To present the concept of process synchronization. To introduce the critical-section problem, whose solutions can be used to ensure the consistency of shared data To present both software and hardware solutions of the critical-section problem To examine several classical process-synchronization problems To explore several tools that are used to solve process synchronization problems Knowing how to use the tools Knowing how to implement the tools Silberschatz, Galvin and Gagne 2013 End of Chapter 5 Silberschatz, Galvin and Gagne

Lesson 6: Process Synchronization

Lesson 6: Process Synchronization Lesson 6: Process Synchronization Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization

More information

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks

More information

Chapter 5: Process Synchronization

Chapter 5: Process Synchronization Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Operating System Concepts 9th Edition Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution

More information

Chapter 5: Process Synchronization. Operating System Concepts Essentials 2 nd Edition

Chapter 5: Process Synchronization. Operating System Concepts Essentials 2 nd Edition Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks

More information

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks

More information

Process Synchronization

Process Synchronization Process Synchronization Daniel Mosse (Slides are from Silberschatz, Galvin and Gagne 2013 and Sherif Khattab) Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution

More information

Chapter 5: Process Synchronization

Chapter 5: Process Synchronization Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013! Chapter 5: Process Synchronization Background" The Critical-Section Problem" Petersons Solution" Synchronization Hardware" Mutex

More information

Chapter 6: Process Synchronization

Chapter 6: Process Synchronization Chapter 6: Process Synchronization Chapter 6: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks Semaphores Classic Problems of Synchronization

More information

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks

More information

Chapter 6: Process Synchronization

Chapter 6: Process Synchronization Chapter 6: Process Synchronization Chapter 6: Synchronization 6.1 Background 6.2 The Critical-Section Problem 6.3 Peterson s Solution 6.4 Synchronization Hardware 6.5 Mutex Locks 6.6 Semaphores 6.7 Classic

More information

Chapter 6: Synchronization. Chapter 6: Synchronization. 6.1 Background. Part Three - Process Coordination. Consumer. Producer. 6.

Chapter 6: Synchronization. Chapter 6: Synchronization. 6.1 Background. Part Three - Process Coordination. Consumer. Producer. 6. Part Three - Process Coordination Chapter 6: Synchronization 6.1 Background Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms to ensure

More information

CHAPTER 6: PROCESS SYNCHRONIZATION

CHAPTER 6: PROCESS SYNCHRONIZATION CHAPTER 6: PROCESS SYNCHRONIZATION The slides do not contain all the information and cannot be treated as a study material for Operating System. Please refer the text book for exams. TOPICS Background

More information

CS370 Operating Systems

CS370 Operating Systems CS370 Operating Systems Colorado State University Yashwant K Malaiya Spring 1018 L11 Synchronization Slides based on Text by Silberschatz, Galvin, Gagne Various sources 1 1 FAQ Multilevel feedback queue:

More information

Chapter 6: Process Synchronization. Operating System Concepts 8 th Edition,

Chapter 6: Process Synchronization. Operating System Concepts 8 th Edition, Chapter 6: Process Synchronization, Silberschatz, Galvin and Gagne 2009 Module 6: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores

More information

Chapter 6: Process Synchronization

Chapter 6: Process Synchronization Module 6: Process Synchronization Chapter 6: Process Synchronization Background! The Critical-Section Problem! Peterson s Solution! Synchronization Hardware! Semaphores! Classic Problems of Synchronization!

More information

Module 6: Process Synchronization

Module 6: Process Synchronization Module 6: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Atomic

More information

Chapter 6: Process Synchronization. Operating System Concepts 9 th Edit9on

Chapter 6: Process Synchronization. Operating System Concepts 9 th Edit9on Chapter 6: Process Synchronization Operating System Concepts 9 th Edit9on Silberschatz, Galvin and Gagne 2013 Objectives To present the concept of process synchronization. To introduce the critical-section

More information

Process Synchronization

Process Synchronization CS307 Process Synchronization Fan Wu Department of Computer Science and Engineering Shanghai Jiao Tong University Spring 2018 Background Concurrent access to shared data may result in data inconsistency

More information

Synchronization Principles

Synchronization Principles Synchronization Principles Gordon College Stephen Brinton The Problem with Concurrency Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms

More information

CS370 Operating Systems

CS370 Operating Systems CS370 Operating Systems Colorado State University Yashwant K Malaiya Fall 2017 Lecture 12 Slides based on Text by Silberschatz, Galvin, Gagne Various sources 1 1 FAQ 2 Mutex vs Semaphore Mutex is binary,

More information

Chapter 6: Process Synchronization. Module 6: Process Synchronization

Chapter 6: Process Synchronization. Module 6: Process Synchronization Chapter 6: Process Synchronization Module 6: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization

More information

CSE 4/521 Introduction to Operating Systems

CSE 4/521 Introduction to Operating Systems CSE 4/521 Introduction to Operating Systems Lecture 7 Process Synchronization II (Classic Problems of Synchronization, Synchronization Examples) Summer 2018 Overview Objective: 1. To examine several classical

More information

CS370 Operating Systems

CS370 Operating Systems CS370 Operating Systems Colorado State University Yashwant K Malaiya Fall 2017 Lecture 11 Slides based on Text by Silberschatz, Galvin, Gagne Various sources 1 1 FAQ Multilevel Feedback Queue: Q0, Q1,

More information

Process Synchronization

Process Synchronization Process Synchronization Chapter 6 2015 Prof. Amr El-Kadi Background Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms to ensure the orderly

More information

Chapter 7: Process Synchronization. Background. Illustration

Chapter 7: Process Synchronization. Background. Illustration Chapter 7: Process Synchronization Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors Synchronization in Solaris

More information

Process Synchronization

Process Synchronization Chapter 7 Process Synchronization 1 Chapter s Content Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors 2 Background

More information

Chapter 6: Synchronization. Operating System Concepts 8 th Edition,

Chapter 6: Synchronization. Operating System Concepts 8 th Edition, Chapter 6: Synchronization, Silberschatz, Galvin and Gagne 2009 Outline Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization

More information

Real-Time Operating Systems M. 5. Process Synchronization

Real-Time Operating Systems M. 5. Process Synchronization Real-Time Operating Systems M 5. Process Synchronization Notice The course material includes slides downloaded from: http://codex.cs.yale.edu/avi/os-book/ and (slides by Silberschatz, Galvin, and Gagne,

More information

Chapter 7: Process Synchronization. Background

Chapter 7: Process Synchronization. Background Chapter 7: Process Synchronization Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors Synchronization in Solaris

More information

Chapter 7: Process Synchronization!

Chapter 7: Process Synchronization! Chapter 7: Process Synchronization Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Monitors 7.1 Background Concurrent access to shared

More information

EI 338: Computer Systems Engineering (Operating Systems & Computer Architecture)

EI 338: Computer Systems Engineering (Operating Systems & Computer Architecture) EI 338: Computer Systems Engineering (Operating Systems & Computer Architecture) Dept. of Computer Science & Engineering Chentao Wu wuct@cs.sjtu.edu.cn Download lectures ftp://public.sjtu.edu.cn User:

More information

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Chapter 5: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Mutex Locks

More information

Chapter 6 Synchronization

Chapter 6 Synchronization Chapter 6 Synchronization Da-Wei Chang CSIE.NCKU Source: Abraham Silberschatz, Peter B. Galvin, and Greg Gagne, "Operating System Concepts", 9th Edition, Wiley. 1 Outline Background The Critical-Section

More information

Process Synchronization

Process Synchronization TDDI04 Concurrent Programming, Operating Systems, and Real-time Operating Systems Process Synchronization [SGG7] Chapter 6 Copyright Notice: The lecture notes are mainly based on Silberschatz s, Galvin

More information

CSE Opera,ng System Principles

CSE Opera,ng System Principles CSE 30341 Opera,ng System Principles Synchroniza2on Overview Background The Cri,cal-Sec,on Problem Peterson s Solu,on Synchroniza,on Hardware Mutex Locks Semaphores Classic Problems of Synchroniza,on Monitors

More information

Process Synchronization. CISC3595, Spring 2015 Dr. Zhang

Process Synchronization. CISC3595, Spring 2015 Dr. Zhang Process Synchronization CISC3595, Spring 2015 Dr. Zhang 1 Concurrency OS supports multi-programming In single-processor system, processes are interleaved in time In multiple-process system, processes execution

More information

Process Synchronization

Process Synchronization CSC 4103 - Operating Systems Spring 2007 Lecture - VI Process Synchronization Tevfik Koşar Louisiana State University February 6 th, 2007 1 Roadmap Process Synchronization The Critical-Section Problem

More information

CS420: Operating Systems. Process Synchronization

CS420: Operating Systems. Process Synchronization Process Synchronization James Moscola Department of Engineering & Computer Science York College of Pennsylvania Based on Operating System Concepts, 9th Edition by Silberschatz, Galvin, Gagne Background

More information

CS370 Operating Systems

CS370 Operating Systems CS370 Operating Systems Colorado State University Yashwant K Malaiya Spring 1019 L12 Synchronization Slides based on Text by Silberschatz, Galvin, Gagne Various sources 1 1 FAQ Critical section: shared

More information

Chapter 6: Process Synchronization. Operating System Concepts 8 th Edition,

Chapter 6: Process Synchronization. Operating System Concepts 8 th Edition, Chapter 6: Process Synchronization, Silberschatz, Galvin and Gagne 2009 Module 6: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores

More information

Module 6: Process Synchronization. Operating System Concepts with Java 8 th Edition

Module 6: Process Synchronization. Operating System Concepts with Java 8 th Edition Module 6: Process Synchronization 6.1 Silberschatz, Galvin and Gagne 2009 Module 6: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores

More information

Synchronization. Race Condition. The Critical-Section Problem Solution. The Synchronization Problem. Typical Process P i. Peterson s Solution

Synchronization. Race Condition. The Critical-Section Problem Solution. The Synchronization Problem. Typical Process P i. Peterson s Solution Race Condition Synchronization CSCI 315 Operating Systems Design Department of Computer Science A race occurs when the correctness of a program depends on one thread reaching point x in its control flow

More information

Chapter 6: Process Synchronization

Chapter 6: Process Synchronization Chapter 6: Process Synchronization Objectives Introduce Concept of Critical-Section Problem Hardware and Software Solutions of Critical-Section Problem Concept of Atomic Transaction Operating Systems CS

More information

Chapter 6: Synchronization

Chapter 6: Synchronization Chapter 6: Synchronization Module 6: Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization Monitors Synchronization

More information

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition

Chapter 5: Process Synchronization. Operating System Concepts 9 th Edition Chapter 5: Process Synchronization Silberschatz, Galvin and Gagne 2013 Objectives To present the concept of process synchronization. To introduce the critical-section problem, whose solutions can be used

More information

Chapter 6 Process Synchronization

Chapter 6 Process Synchronization Chapter 6 Process Synchronization Cooperating Process process that can affect or be affected by other processes directly share a logical address space (threads) be allowed to share data via files or messages

More information

Chapter 6: Process Synchronization

Chapter 6: Process Synchronization Chapter 6: Process Synchronization Module 6: Process Synchronization Background The Critical-Section Problem Peterson s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization

More information

Operating Systems. Designed and Presented by Dr. Ayman Elshenawy Elsefy

Operating Systems. Designed and Presented by Dr. Ayman Elshenawy Elsefy Operating Systems Designed and Presented by Dr. Ayman Elshenawy Elsefy Dept. of Systems & Computer Eng.. AL-AZHAR University Website : eaymanelshenawy.wordpress.com Email : eaymanelshenawy@yahoo.com Reference

More information

CS370 Operating Systems Midterm Review. Yashwant K Malaiya Spring 2019

CS370 Operating Systems Midterm Review. Yashwant K Malaiya Spring 2019 CS370 Operating Systems Midterm Review Yashwant K Malaiya Spring 2019 1 1 Computer System Structures Computer System Operation Stack for calling functions (subroutines) I/O Structure: polling, interrupts,

More information

Semaphore. Originally called P() and V() wait (S) { while S <= 0 ; // no-op S--; } signal (S) { S++; }

Semaphore. Originally called P() and V() wait (S) { while S <= 0 ; // no-op S--; } signal (S) { S++; } Semaphore Semaphore S integer variable Two standard operations modify S: wait() and signal() Originally called P() and V() Can only be accessed via two indivisible (atomic) operations wait (S) { while

More information

Introduction to Operating Systems

Introduction to Operating Systems Introduction to Operating Systems Lecture 4: Process Synchronization MING GAO SE@ecnu (for course related communications) mgao@sei.ecnu.edu.cn Mar. 18, 2015 Outline 1 The synchronization problem 2 A roadmap

More information

Process Synchronization

Process Synchronization Process Synchronization Concurrent access to shared data may result in data inconsistency Multiple threads in a single process Maintaining data consistency requires mechanisms to ensure the orderly execution

More information

Lecture 3: Synchronization & Deadlocks

Lecture 3: Synchronization & Deadlocks Lecture 3: Synchronization & Deadlocks Background Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating

More information

Background. Module 6: Process Synchronization. Bounded-Buffer (Cont.) Bounded-Buffer. Background

Background. Module 6: Process Synchronization. Bounded-Buffer (Cont.) Bounded-Buffer. Background Module 6: Process Synchronization Background Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors Synchronization

More information

Synchronization. CS 475, Spring 2018 Concurrent & Distributed Systems

Synchronization. CS 475, Spring 2018 Concurrent & Distributed Systems Synchronization CS 475, Spring 2018 Concurrent & Distributed Systems Review: Threads: Memory View code heap data files code heap data files stack stack stack stack m1 m1 a1 b1 m2 m2 a2 b2 m3 m3 a3 m4 m4

More information

Module 6: Process Synchronization

Module 6: Process Synchronization Module 6: Process Synchronization Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors Synchronization in Solaris

More information

Process Coordination

Process Coordination Process Coordination Why is it needed? Processes may need to share data More than one process reading/writing the same data (a shared file, a database record, ) Output of one process being used by another

More information

COP 4225 Advanced Unix Programming. Synchronization. Chi Zhang

COP 4225 Advanced Unix Programming. Synchronization. Chi Zhang COP 4225 Advanced Unix Programming Synchronization Chi Zhang czhang@cs.fiu.edu 1 Cooperating Processes Independent process cannot affect or be affected by the execution of another process. Cooperating

More information

Process Co-ordination OPERATING SYSTEMS

Process Co-ordination OPERATING SYSTEMS OPERATING SYSTEMS Prescribed Text Book Operating System Principles, Seventh Edition By Abraham Silberschatz, Peter Baer Galvin and Greg Gagne 1 PROCESS - CONCEPT Processes executing concurrently in the

More information

CS370: System Architecture & Software [Fall 2014] Dept. Of Computer Science, Colorado State University

CS370: System Architecture & Software [Fall 2014] Dept. Of Computer Science, Colorado State University Frequently asked questions from the previous class survey CS 370: SYSTEM ARCHITECTURE & SOFTWARE [PROCESS SYNCHRONIZATION] Shrideep Pallickara Computer Science Colorado State University Semaphores From

More information

Process Synchronization (Part I)

Process Synchronization (Part I) Process Synchronization (Part I) Amir H. Payberah amir@sics.se Amirkabir University of Technology (Tehran Polytechnic) Amir H. Payberah (Tehran Polytechnic) Process Synchronization 1393/7/14 1 / 44 Motivation

More information

Interprocess Communication By: Kaushik Vaghani

Interprocess Communication By: Kaushik Vaghani Interprocess Communication By: Kaushik Vaghani Background Race Condition: A situation where several processes access and manipulate the same data concurrently and the outcome of execution depends on the

More information

Lecture 5: Inter-process Communication and Synchronization

Lecture 5: Inter-process Communication and Synchronization Lecture 5: Inter-process Communication and Synchronization Real-Time CPU Scheduling Periodic processes require the CPU at specified intervals (periods) p is the duration of the period d is the deadline

More information

Maximum CPU utilization obtained with multiprogramming. CPU I/O Burst Cycle Process execution consists of a cycle of CPU execution and I/O wait

Maximum CPU utilization obtained with multiprogramming. CPU I/O Burst Cycle Process execution consists of a cycle of CPU execution and I/O wait Basic Concepts Scheduling Criteria Scheduling Algorithms Multiple-Processor Scheduling Real-Time Scheduling Thread Scheduling Operating Systems Examples Java Thread Scheduling Algorithm Evaluation CPU

More information

UNIT 2 Basic Concepts of CPU Scheduling. UNIT -02/Lecture 01

UNIT 2 Basic Concepts of CPU Scheduling. UNIT -02/Lecture 01 1 UNIT 2 Basic Concepts of CPU Scheduling UNIT -02/Lecture 01 Process Concept An operating system executes a variety of programs: **Batch system jobs **Time-shared systems user programs or tasks **Textbook

More information

$ %! 0,-./ + %/ 0"/ C (" &() + A &B' 7! .+ N!! O8K + 8 N. (Monitors) 3+!

$ %! 0,-./ + %/ 0/ C ( &() + A &B' 7! .+ N!! O8K + 8 N. (Monitors) 3+! "#! $ %! *+ &' & "-/ &+, :/!! &+ 8/!.!"!! > &, < &+ 7!! "-/ :/= +. :/= 0 0/ 7!@?+ C (" & + A &B' 7! G' 3/ 0"=' 7> H 0 4 0! &D E.! 0 n I"2 &+ % &B' 0!!! n 1 + counter J " &B' & K n

More information

Process Synchronization

Process Synchronization Process Synchronization Mandar Mitra Indian Statistical Institute M. Mitra (ISI) Process Synchronization 1 / 28 Cooperating processes Reference: Section 4.4. Cooperating process: shares data with other

More information

Process Synchronization: Semaphores. CSSE 332 Operating Systems Rose-Hulman Institute of Technology

Process Synchronization: Semaphores. CSSE 332 Operating Systems Rose-Hulman Institute of Technology Process Synchronization: Semaphores CSSE 332 Operating Systems Rose-Hulman Institute of Technology Critical-section problem solution 1. Mutual Exclusion - If process Pi is executing in its critical section,

More information

Operating Systems Antonio Vivace revision 4 Licensed under GPLv3

Operating Systems Antonio Vivace revision 4 Licensed under GPLv3 Operating Systems Antonio Vivace - 2016 revision 4 Licensed under GPLv3 Process Synchronization Background A cooperating process can share directly a logical address space (code, data) or share data through

More information

Chapter 7 Process Synchronization

Chapter 7 Process Synchronization Contents 1. Introduction 2. Computer-System Structures 3. Operating-System Structures 4. Processes 5. Threads 6. CPU Scheduling 7. Process Synchronization 8. Deadlocks 9. Memory Management 10. Virtual

More information

Dept. of CSE, York Univ. 1

Dept. of CSE, York Univ. 1 EECS 3221.3 Operating System Fundamentals No.5 Process Synchronization(1) Prof. Hui Jiang Dept of Electrical Engineering and Computer Science, York University Background: cooperating processes with shared

More information

9/29/2014. CS341: Operating System Mid Semester Model Solution Uploaded Semaphore ADT: wait(), signal()

9/29/2014. CS341: Operating System Mid Semester Model Solution Uploaded Semaphore ADT: wait(), signal() CS341: Operating System Mid Semester Model Solution Uploaded Semaphore ADT: wait(), signal() Lect23: 30 th Sept 2014 Dr. A. Sahu Dept of Comp. Sc. & Engg. Indian Institute of Technology Guwahati Classical

More information

Synchronization. CSE 2431: Introduction to Operating Systems Reading: Chapter 5, [OSC] (except Section 5.10)

Synchronization. CSE 2431: Introduction to Operating Systems Reading: Chapter 5, [OSC] (except Section 5.10) Synchronization CSE 2431: Introduction to Operating Systems Reading: Chapter 5, [OSC] (except Section 5.10) 1 Outline Critical region and mutual exclusion Mutual exclusion using busy waiting Sleep and

More information

Background. The Critical-Section Problem Synchronisation Hardware Inefficient Spinning Semaphores Semaphore Examples Scheduling.

Background. The Critical-Section Problem Synchronisation Hardware Inefficient Spinning Semaphores Semaphore Examples Scheduling. Background The Critical-Section Problem Background Race Conditions Solution Criteria to Critical-Section Problem Peterson s (Software) Solution Concurrent access to shared data may result in data inconsistency

More information

UNIT II PROCESS MANAGEMENT 9

UNIT II PROCESS MANAGEMENT 9 UNIT II PROCESS MANAGEMENT 9 Processes-Process Concept, Process Scheduling, Operations on Processes, Interprocess Communication; Threads- Overview, Multicore Programming, Multithreading Models; Windows

More information

Process Synchronization(2)

Process Synchronization(2) EECS 3221.3 Operating System Fundamentals No.6 Process Synchronization(2) Prof. Hui Jiang Dept of Electrical Engineering and Computer Science, York University Semaphores Problems with the software solutions.

More information

Process Synchronization(2)

Process Synchronization(2) CSE 3221.3 Operating System Fundamentals No.6 Process Synchronization(2) Prof. Hui Jiang Dept of Computer Science and Engineering York University Semaphores Problems with the software solutions. Not easy

More information

Processes. Rafael Ramirez Dep Tecnologia Universitat Pompeu Fabra

Processes. Rafael Ramirez Dep Tecnologia Universitat Pompeu Fabra Processes Rafael Ramirez Dep Tecnologia Universitat Pompeu Fabra Processes Process Concept Process Scheduling Operation on Processes Cooperating Processes Interprocess Communication Process Concept Early

More information

IV. Process Synchronisation

IV. Process Synchronisation IV. Process Synchronisation Operating Systems Stefan Klinger Database & Information Systems Group University of Konstanz Summer Term 2009 Background Multiprogramming Multiple processes are executed asynchronously.

More information

CS370 Operating Systems

CS370 Operating Systems CS370 Operating Systems Colorado State University Yashwant K Malaiya Spring 1018 L10 Synchronization Slides based on Text by Silberschatz, Galvin, Gagne Various sources 1 1 FAQ Development project: You

More information

Synchronization Principles II

Synchronization Principles II CSC 256/456: Operating Systems Synchronization Principles II John Criswell University of Rochester 1 Synchronization Issues Race conditions and the need for synchronization Critical Section Problem Mutual

More information

CS370 Operating Systems Midterm Review

CS370 Operating Systems Midterm Review CS370 Operating Systems Midterm Review Yashwant K Malaiya Fall 2015 Slides based on Text by Silberschatz, Galvin, Gagne 1 1 What is an Operating System? An OS is a program that acts an intermediary between

More information

CS370 Opera;ng Systems Midterm Review. Yashwant K Malaiya Spring 2018

CS370 Opera;ng Systems Midterm Review. Yashwant K Malaiya Spring 2018 CS370 Opera;ng Systems Midterm Review Yashwant K Malaiya Spring 2018 1 1 Computer System Structures Computer System Opera2on Stack for calling func2ons (subrou2nes) I/O Structure: polling, interrupts,

More information

Process Synchronization. studykorner.org

Process Synchronization. studykorner.org Process Synchronization 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

More information

High-level Synchronization

High-level Synchronization Recap of Last Class High-level Synchronization CS 256/456 Dept. of Computer Science, University of Rochester Concurrent access to shared data may result in data inconsistency race condition. The Critical-Section

More information

Process Synchronization(2)

Process Synchronization(2) EECS 3221.3 Operating System Fundamentals No.6 Process Synchronization(2) Prof. Hui Jiang Dept of Electrical Engineering and Computer Science, York University Semaphores Problems with the software solutions.

More information

Concurrency: Mutual Exclusion and

Concurrency: Mutual Exclusion and Concurrency: Mutual Exclusion and Synchronization 1 Needs of Processes Allocation of processor time Allocation and sharing resources Communication among processes Synchronization of multiple processes

More information

Background. Old Producer Process Code. Improving the Bounded Buffer. Old Consumer Process Code

Background. Old Producer Process Code. Improving the Bounded Buffer. Old Consumer Process Code Old Producer Process Code Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes Our

More information

Che-Wei Chang Department of Computer Science and Information Engineering, Chang Gung University

Che-Wei Chang Department of Computer Science and Information Engineering, Chang Gung University Che-Wei Chang chewei@mail.cgu.edu.tw Department of Computer Science and Information Engineering, Chang Gung University 1. Introduction 2. System Structures 3. Process Concept 4. Multithreaded Programming

More information

Prof. Hui Jiang Dept of Computer Science and Engineering York University

Prof. Hui Jiang Dept of Computer Science and Engineering York University 0./ ' )-, ' ' # # 2 H; 2 7 E 7 2 $&% ( Prof. Hui Jiang ept of omputer Science and Engineering York University )+* Problems with the software solutions. Not easy to generalize to more complex synchronization

More information

Process Synchronization

Process Synchronization Process Synchronization Concurrent access to shared data in the data section of a multi-thread process, in the shared memory of multiple processes, or in a shared file Although every example in this chapter

More information

PESIT Bangalore South Campus

PESIT Bangalore South Campus INTERNAL ASSESSMENT TEST II Date: 04/04/2018 Max Marks: 40 Subject & Code: Operating Systems 15CS64 Semester: VI (A & B) Name of the faculty: Mrs.Sharmila Banu.A Time: 8.30 am 10.00 am Answer any FIVE

More information

Operating Systems. Synchronization Based on Ch. 5 of OS Concepts by SGG

Operating Systems. Synchronization Based on Ch. 5 of OS Concepts by SGG Operating Systems Synchronization Based on Ch. 5 of OS Concepts by SGG Need to Synchronize We already saw that if we write on a shared data structure w/o synchronization bad things can happen. The parts

More information

1. Motivation (Race Condition)

1. Motivation (Race Condition) COSC4740-01 Operating Systems Design, Fall 2004, Byunggu Yu Chapter 6 Process Synchronization (textbook chapter 7) Concurrent access to shared data in the data section of a multi-thread process, in the

More information

Process Synchronization

Process Synchronization Process Synchronization Reading: Silberschatz chapter 6 Additional Reading: Stallings chapter 5 EEL 358 1 Outline Concurrency Competing and Cooperating Processes The Critical-Section Problem Fundamental

More information

Chapter 6 Synchronization

Chapter 6 Synchronization Chapter 6 Synchronization Images from Silberschatz Pacific University 1 My code is slow Don't worry about speed at this point Later solutions: use the optimizer with gcc: -O# # is 0,1,2,3 0 do not optimize

More information

Unit 1: Introduction

Unit 1: Introduction Unit 1: Introduction What is an Operating System? Objectives and Funcations Computer System Architecture OS Structure OS Operations Evolution of Operating System Distributed Systems Clustered System Real

More information

Roadmap. Readers-Writers Problem. Readers-Writers Problem. Readers-Writers Problem (Cont.) Dining Philosophers Problem.

Roadmap. Readers-Writers Problem. Readers-Writers Problem. Readers-Writers Problem (Cont.) Dining Philosophers Problem. CSE 421/521 - Operating Systems Fall 2011 Lecture - X Process Synchronization & Deadlocks Roadmap Classic Problems of Synchronization Readers and Writers Problem Dining-Philosophers Problem Sleeping Barber

More information

Synchronization for Concurrent Tasks

Synchronization for Concurrent Tasks Synchronization for Concurrent Tasks Minsoo Ryu Department of Computer Science and Engineering 2 1 Race Condition and Critical Section Page X 2 Algorithmic Approaches Page X 3 Hardware Support Page X 4

More information

Learning Outcomes. Concurrency and Synchronisation. Textbook. Concurrency Example. Inter- Thread and Process Communication. Sections & 2.

Learning Outcomes. Concurrency and Synchronisation. Textbook. Concurrency Example. Inter- Thread and Process Communication. Sections & 2. Learning Outcomes Concurrency and Synchronisation Understand concurrency is an issue in operating systems and multithreaded applications Know the concept of a critical region. Understand how mutual exclusion

More information