1 / 68

CMSC 421 Spring 2004 Section 0202

CMSC 421 Spring 2004 Section 0202. Part II: Process Management Chapter 7 Process Synchronization. Contents. Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors

nibaw
Download Presentation

CMSC 421 Spring 2004 Section 0202

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CMSC 421 Spring 2004 Section 0202 Part II: Process Management Chapter 7 Process Synchronization

  2. Contents • Background • The Critical-Section Problem • Synchronization Hardware • Semaphores • Classical Problems of Synchronization • Critical Regions • Monitors • Synchronization in Solaris 2 & Windows 2000 Operating System Concepts

  3. Background • Concurrent access to shared data may result in data inconsistency • Problem stems from non-atomic operations on the shared data • Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes. Operating System Concepts

  4. Bounded-buffer Producer-Consumer Problem (Revisited) • Consider the Shared-memory solution to the bounded buffer producer-consumer problem from Chapter 4 • It allowed at most n – 1 items in the buffer at the same time. • A solution, where all N buffers are used is not simple. • Suppose that we modify the producer-consumer code by adding a variable counter that • Is initialized to 0, and • Is incremented each time a new item is added to the buffer Operating System Concepts

  5. Bounded-Buffer Producer-Consumer Problem • Shared data #define BUFFER_SIZE 10 typedef struct { . . . } item; item buffer[BUFFER_SIZE]; int in = 0; int out = 0; int counter = 0; Operating System Concepts

  6. Bounded-Buffer Producer-Consumer Problem • Producer process item nextProduced; while (1) { while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = nextProduced; in = (in + 1) % BUFFER_SIZE; counter++; } Operating System Concepts

  7. Bounded-Buffer Producer-Consumer Problem • Consumer process item nextConsumed; while (1) { while (counter == 0) ; /* do nothing */ nextConsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; } Operating System Concepts

  8. Bounded-Buffer Producer-Consumer Problem • The statements counter++;counter--; in the producer and consumer code must be performed atomically. • Atomic operation means an operation that completes in its entirety without interruption. Operating System Concepts

  9. Bounded-Buffer Producer-Consumer Problem • The statement “count++” may be implemented in assembly language as: LOAD register1, counter INCREMENT register1STORE register1, counter • The statement “count—” may be implemented as: LOAD register2, counter DECREMENT register2STORE register2, counter Operating System Concepts

  10. Bounded-Buffer Producer-Consumer Problem • If both the producer and consumer processes attempt to update the buffer concurrently, the assembly language statements may get interleaved • Because the CPU scheduler may preempt any of these processes at any time between assembly instructions • Interleaving depends upon how the producer and consumer processes are scheduled • Such interleaving may lead into an unpredictable and likely incorrect value for the shared data (counter variable) Operating System Concepts

  11. Problem Continues.. • Assume counter is initially 5. One interleaving of statements is:producer: register1 = counter (register1 = 5)producer: register1 = register1 + 1 (register1 = 6)consumer: register2 = counter (register2 = 5)consumer: register2 = register2 – 1 (register2 = 4)producer: counter = register1 (counter = 6)consumer: counter = register2 (counter = 4) • The value of count may be either 4 or 6, where the correct result should be 5. Operating System Concepts

  12. Race Condition • Race condition • The situation where several processes access – and manipulate shared data concurrently. The final value of the shared data depends upon which process finishes last • Final result is non-deterministic !! • To prevent race conditions, concurrent processes must be synchronized. Operating System Concepts

  13. The Critical-Section Problem • n processes all competing to use some shared data • Each process has a code segment, called critical section, in which the shared data is accessed. • Problem • ensure that when one process is executing in its critical section, no other process is allowed to execute in its critical section. Operating System Concepts

  14. Solution Requirements for CS Problem 1. Mutual Exclusion (Mutex) • If process Pi is executing in its critical section, then no other processes can be executing in their critical sections. • 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. • 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. Operating System Concepts

  15. Initial Attempts to Solve Problem.. • Assume there are only 2 processes, P0 and P1 • General structure of process Pi(other process Pj) do { entry section critical section exit section remainder section } while (1); • Processes may share some common variables to synchronize their actions. Operating System Concepts

  16. Algorithm 1 • Shared variables: • int turn;initially turn = 0 • turn = i Pi can enter its critical section • Process Pi do { while (turn != i) ; critical section turn = j; remainder section } while (1); • Satisfies mutual exclusion, but not progress Operating System Concepts

  17. Progress Not Satisfied • Process Pi do { while (turn != i) ; critical section turn = j; remainder section } while (1); • Process Pj do { while (turn != j) ; critical section turn = i; remainder section } while (1); • Pi executes CS; Pj executes CS; Pj executes CS Operating System Concepts

  18. Algorithm 2 • Shared variables • boolean flag[2];initially flag [0] = flag [1] = false. • flag [i] = true Pi ready to enter its critical section • Process Pi do { flag[i] := true; while (flag[j]); critical section flag [i] = false; remainder section } while (1); • Satisfies mutual exclusion, but not progress requirement • How can that happen? Operating System Concepts

  19. Algorithm 3 • Combine shared variables of algorithms 1 and 2. • Process Pi do { flag [i]:= true; turn = j; while (flag [j] and turn = j) ; critical section flag [i] = false; remainder section } while (1); • Meets all three requirements; solves the critical-section problem for two processes. Operating System Concepts

  20. Attempting to Solve the CS Problem • CS problem is now solved for 2 processes. • How about n processes? • The Bakery algorithm Operating System Concepts

  21. Bakery Algorithm: CS for n processes • Main idea • Before entering its critical section, a process receives a number. • Holder of the smallest number enters the critical section. • If processes Pi and Pj receive the same number, if i < j, then Pi is served first; else Pj is served first. • The numbering scheme always generates numbers in increasing order of enumeration; i.e., 1,2,3,3,3,3,4,5... Operating System Concepts

  22. Bakery Algorithm • Notation: <  lexicographical order (ticket #, process id #) • (a,b) < (c,d) if a < c or if a = c and b < d • max (a0,…, an-1) is a number, k, such that k ai for i = 0, …, n – 1 • Shared data among the processes • boolean choosing[n]; • int number[n]; • Data structures are initialized to false and 0 respectively Operating System Concepts

  23. Bakery Algorithm Process i do { choosing[i] = true; number[i] = max(number[0], number[1], …, number [n – 1])+1; choosing[i] = false; for (j = 0; j<n; j++) { while (choosing[j]) ; while ((number[j] != 0) && (number[j,j] < number[i,i])) ; } critical section number[i] = 0; remainder section } while (1); Operating System Concepts

  24. Bakery Algorithm (revisited) Process i do { choosing[i] = true; number[i] = max(number[0], number[1], …, number [n – 1])+1; choosing[i] = false; for (j = 0; j<n; j++) { while (choosing[j]) ; while ((number[j] != 0) && (number[j,j] < number[i,i])) ; } critical section number[i] = 0; remainder section } while (1); • Mutex condition is violated Operating System Concepts

  25. Synchronization Hardware • Suppose that machine supports the test and modify of the content of a word atomically boolean TestAndSet(boolean &target) { boolean rv = target; target = true; return rv; } Operating System Concepts

  26. Mutual Exclusion with Test-and-Set • Shared data: boolean lock = false; • Process Pi do { while ( TestAndSet(lock) ) ; critical section lock = false; remainder section } while (1); Operating System Concepts

  27. Synchronization Hardware • Suppose that machine supports the atomic swap of two variables void Swap(boolean &a, boolean &b) { boolean temp = a; a = b; b = temp; } Operating System Concepts

  28. Mutual Exclusion with Swap • Shared data boolean lock = false; • Process Pi do { key = true; while (key == true) Swap(lock,key); critical section lock = false; remainder section } • Does not meet bounded wait condition Operating System Concepts

  29. Bounded waiting Mutual Exclusion with TestAndSet • Shared data (intialized to false) boolean lock = false; boolean waiting[n]; • Process Pi do { waiting[i] = true; key = true; while (waiting[i] && key) key = TestAndSet(lock); waiting[i] = false; critical section j=(i+1)%n; while ( j != i && !waiting[j] ) j = (j+1) % n; if ( j == i ) lock = false; else waiting[j] = false; remainder section } Operating System Concepts

  30. Semaphores • Simpler way to synchronize processes • A semaphore can only be accessed via two atomic operations wait (S): while S 0 do no-op;S--; signal (S): S++; Operating System Concepts

  31. Critical Section of n Processes • Shared data: semaphore mutex; //initially mutex = 1 • Process Pi: do { wait(mutex);critical section signal(mutex); remainder section} while (1); • Still does not remove busy waiting Operating System Concepts

  32. Solution to Busy Waiting • Modify the Definition of a semaphore • Previous Definition int S; • Current Definition typedef struct { int S; struct process *L; } semaphore; Operating System Concepts

  33. Semaphore Implementation • Introduce two simple operations: • block(P) suspends the calling process P that invokes it. • wakeup(P) resumes the execution of a blocked process P • These operations can be implemented in the kernel by removing/adding the process P from/to the CPU ready queue Operating System Concepts

  34. Semaphore Implementation wait(S): S.value--; if (S.value < 0) { add this process to S.L; block; } signal(S): S.value++; if (S.value <= 0) { remove a process P from S.L; wakeup(P); } • Provided as basic system calls by OS Operating System Concepts

  35. Semaphore (Cont.) • Semaphore value may be negative in current definition • Magnitude of the value= no. of waiting processes • The queue of waiting processes could follow any queueing algorithm • Queueing algorithm should address bounded waiting • Wait and Signal must execute atomically • Made possible by inhibiting interrupts in a uniprocessor • Wait and Signal become the CS in a multiprocessor • They are protected by standard algorithms discussed before for the producer-consumer problem Operating System Concepts

  36. Semaphore as a General Synchronization Tool • Execute B in Pj only after A has executed in Pi • Use semaphore flag initialized to 0 • Code: Pi Pj   Await(flag) signal(flag) B Operating System Concepts

  37. Deadlock and Starvation • Deadlock • two or more processes are waiting indefinitely for an event that can only be caused by only one of these waiting processes. • Let S and Q be two semaphores initialized to 1 P0P1 wait(S); wait(Q); wait(Q); wait(S);   signal(S); signal(Q); signal(Q) signal(S); • Starvation • indefinite blocking; A process may never be removed from the semaphore queue in which it is suspended. Operating System Concepts

  38. Two Types of Semaphores • Counting semaphore • integer value can range over an unrestricted domain. • Binary semaphore • integer value can range only between 0 and 1; can be simpler to implement. • One can always implement a counting semaphore S as a binary semaphore Operating System Concepts

  39. Implementing a Counting Semaphore S as a Binary Semaphore • Data structures: binarySemaphore S1, S2; int C; • Initialization: S1 = 1 S2 = 0 C = initial value of semaphore S Operating System Concepts

  40. Implementing a Counting Semaphore S as a Binary Semaphore • wait operation wait(S1); C--; if (C < 0) { signal(S1); wait(S2); } signal(S1); • signal operation wait(S1); C ++; if (C <= 0) signal(S2); else signal(S1); • S1 is guarding concurrent access to C • S2 is making the processes wait in it’s queue Operating System Concepts

  41. Classical Problems of Synchronization • Bounded-Buffer Problem • Readers and Writers Problem • Dining-Philosophers Problem Operating System Concepts

  42. Bounded-Buffer Problem • Shared datasemaphore full=0, empty=n, mutex=1; Operating System Concepts

  43. Bounded-Buffer Problem Producer Process do { … produce an item in nextp … wait(empty); //wait if empty<0 wait(mutex); … add nextp to buffer … signal(mutex); signal(full); // add 1 to full } while (1); Operating System Concepts

  44. Bounded-Buffer Problem Consumer Process do { wait(full) // wait if full<0 wait(mutex); … remove an item from buffer to nextc … signal(mutex); signal(empty); // add 1 to empty … consume the item in nextc … } while (1); Operating System Concepts

  45. Readers-Writers Problem • Shared datasemaphore mutex=1, wrt=1; int readcount=0; • salient features • Multiple readers can read concurrently • Writers must be given exclusive access to shared space • Various flavors • Readers priority • Writers priority Operating System Concepts

  46. Readers-Writers Problem Writer Process wait(wrt); … writing is performed … signal(wrt); Operating System Concepts

  47. Readers-Writers Problem Reader Process wait(mutex); readcount++; if (readcount == 1) wait(wrt); signal(mutex); … reading is performed … wait(mutex); readcount--; if (readcount == 0) signal(wrt); signal(mutex): Operating System Concepts

  48. Dining-Philosophers Problem • Shared data semaphore chopstick[5]; Initially all values are 1 Operating System Concepts

  49. Dining-Philosophers Problem • Philosopher i: do { wait(chopstick[i]) wait(chopstick[(i+1) % 5]) … eat … signal(chopstick[i]); signal(chopstick[(i+1) % 5]); … think … } while (1); Operating System Concepts

  50. Critical Regions • Semaphores are convenient and efefctive • Yet using them correctly is not easy • Debugging is difficult • Critical regions are a high-level synchronization construct • A shared variable v of type T, is declared as: v:sharedT • Variable v accessed only inside statement regionvwhenBdoSwhere B is a boolean expression. Operating System Concepts

More Related