CSS430 Process Synchronization Textbook Chapter 6

1. CSS430 Process SynchronizationTextbook Chapter 6 Instructor: Stephen G. Dame e-mail: sdame@uw.edu These slides were adapted from the OSC textbook slides (Silberschatz, Galvin, and Gagne), Professor Munehiro Fukuda and the instructor’s class materials. CSS430 Operating Systems : Process Synchronization

2. WKP 17 “Programming is the process of converting caffeine into error messages” - Unknown

3. Learning Objectives • Introduction to the Critical-Section Problem • Discuss HW & SW solutions to C-S Problem • Atomic Transactions and mechanisms • Java Synchronization techniques: • Mutex • Semaphores • Monitors CSS430 Operating Systems : Process Synchronization

4. Revisiting Bounded Buffer Producer Process Consumer Process Buffer[0] [1] [2] [3] [4] Let’s Dissect the problem! I I I out=1 in=4 CSS430 Operating Systems : Process Synchronization

5. Race Condition • ++count: • reg1 = mem[count]; • reg1 = reg1 + 1; • mem[count] = reg1; • - count: • reg2 = mem[count]; • reg2 = reg2 – 1; • mem[count] = reg2; Producer: reg1 = mem[count]; {reg1=5} Producer: reg1 = reg1 + 1; {reg1=6} Consumer: reg2 = mem[count]; {reg2=5} Consumer: reg2 = reg2 – 1; {reg2=4} Producer: mem[count] = reg1; {count=6} Consumer: mem[count] = reg2; {count=4} The outcome of concurrent thread execution depends on the particular order in which the access takes place race condition! CSS430 Operating Systems : Process Synchronization

6. The Critical Section (“CS”) The critical section is a block of code in which no two processes can be executing their instructions at the same time. • while (true) { • entry section • critical section • exit section • remainder section • } CSS430 Operating Systems : Process Synchronization

7. Critical Section (3) Requirements When entering CS Bounded times Pick up a process to enter When exiting from CS • Mutual Exclusion. If processPiis executing in its critical section(CS), then no other processes can be executing in their corresponding critical sections. • Progress. If no process is executing in its CS, and there exist some processes that wish to enter their CS, then the selection of the processes that will enter the CS next cannot be postponed indefinitely. • Bounded Waiting. A bound must exist on the number of times that other processes are allowed to enter their CS after a process has made a request to enter its CS and before that request is granted. Critical Section only one process CSS430 Operating Systems : Process Synchronization

8. Peterson’s Solution (Algorithm) Pi, i=0 Pj, j=1 • intturn; // shared var • booleanflag[2]; // shared var • while(true) { • flag[i] = true; • turn = j; • while(flag[j] && turn == j); • critical section • flag[i] = false; • remainder section • } Must demonstrate: • Mutual Exclusionis preserved. • Progressrequirement is satisfied. • Bounded Waitingrequirement is met Peterson's algorithm (solution) G.L. Peterson White Paper CSS430 Operating Systems : Process Synchronization

9. Mutual Exclusion Class CSS430 Operating Systems : Process Synchronization

10. Worker Thread CSS430 Operating Systems : Process Synchronization

11. Test Algorithm (Algorithm Factory) CSS430 Operating Systems : Process Synchronization

12. Algorithm 1　(yielding by turn) • Violates CS rule #1 – mutual exclusion • Both threads 0 and 1 cannot be in CS at same time. CSS430 Operating Systems : Process Synchronization

13. Algorithm 2 (flag I’m using…) • Violates CS rule #2, #3 – progress + bounded waiting • Thread 0 sets flag[0] true. • A context switch occurs. • Thread 1 sets flag[1]. • Thread 1 finds out flag[0] is true, and waits for Thread 0. • A context switch occurs. • Thread 0 finds out flag[1] is true, and waits for Thread 1. CSS430 Operating Systems : Process Synchronization

14. Algorithm 3 (Mixed of 1 and 2)(Peterson’s Solution) • Complies with all three CS rules– • Even in case both threads declared, will enter CS in an orderly manner • Turn eventually points to either thread A or B! CSS430 Operating Systems : Process Synchronization

15. No Guarantees! There no guarantees that Peterson’s solution will work correctly on modern computer architectures due to complex load and store instructions CSS430 Operating Systems : Process Synchronization

16. Discussion 1 • What is the definition of atomicity, and where does it apply? • What is the meaning of busy waiting? What is an alternative to busy waiting? • Fill out the following table with your analysis of the different CS methods: CSS430 Operating Systems : Process Synchronization

17. Synchronization • Software solutions: • Algorithm 3 (Peterson’s Solution) works only for a pair of threads. How about a mutual execution (n > 2) threads? Lamport’s Algorithm (See Appendix). • Interrupt Masking: • Disables even time interrupts, thus not allowing preemption. • Malicious user program may hog CPU forever. • Operating systems using this technique are not broadly scalable • Hardware solutions: • Modern machines provide special atomic hardware instructions • Many systems provide hardware support for critical section code • Atomic = non-interruptible sequence of instructions • Test-and-set (or read-modify-write) • Swap contents of two memory words CSS430 Operating Systems : Process Synchronization

18. Critical Section (“CS”) Locks • while (true) { • acquire lock • critical section • release lock • remainder section • } CSS430 Operating Systems : Process Synchronization

19. Hardware Data Simulator CSS430 Operating Systems : Process Synchronization

20. Sleep Utilities CSS430 Operating Systems : Process Synchronization

21. Mutual Exclusion CSS430 Operating Systems : Process Synchronization

22. Worker Thread – Test and Set CSS430 Operating Systems : Process Synchronization

23. H/W Algorithm  Test and Set CSS430 Operating Systems : Process Synchronization

24. Test and Set Factory CSS430 Operating Systems : Process Synchronization

25. Run! Test and Set CSS430 Operating Systems : Process Synchronization

26. H/W Algorithm  Swap CSS430 Operating Systems : Process Synchronization

27. Worker Thread - Swap CSS430 Operating Systems : Process Synchronization

28. Swap Factory CSS430 Operating Systems : Process Synchronization

29. Run! Swap CSS430 Operating Systems : Process Synchronization

30. Semaphore • Synchronization tool that does not require busy waiting at a user level • Semaphore S – integer variable • Two standard operations modify S: acquire() and release() • Originally called P() andV() [Dutch P proberen, meaning “to test ”) and V (from verhogen, meaning “to increment”] • Less complicated (AND implemented by import java.util.concurrent.*) • Can only be accessed via two indivisible (atomic) operations acquire( ) { while value <= 0 ; // no-op value--; } release( ) { value++; wakeup( ); } P V P V P V CSS430 Operating Systems : Process Synchronization

31. Semaphore Eliminating Busy-Waiting Bee4 Bee4 Bee2 Bee2 Bee0 Bee0 P V Bee1 Bee3 Bee3 Waiting List Waiting List Wake one up P V Bee1 CSS430 Operating Systems : Process Synchronization

32. Semaphore Worker Thread Private Data + Constructor Main Body of Worker BEE Critical and Remainder Sections Sim CSS430 Operating Systems : Process Synchronization

33. Semaphore Factory SemaphoreFactory Initialize and Start N “worker bees” CSS430 Operating Systems : Process Synchronization

34. Run! Semaphore CSS430 Operating Systems : Process Synchronization

35. Deadlock and Starvation • Deadlock – two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes. • Let S and Q be two semaphores initialized to 1 P0P1 P(S); P(Q); P(Q); P(S);   V(Q); V(S); V(S); V(Q); • Starvation – indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended. • What if processes are waiting at P(S) in LIFO order CSS430 Operating Systems : Process Synchronization

36. Classical problem 1:Bounded-Buffer Problem consumer producer full.P( ) (full--) empty.P( ) (empty--) mutex.P( ) signal signal mutex.V( ) full.V( ) (full++) empty.V( ) (empty++) CSS430 Operating Systems : Process Synchronization

37. Insert and Remove Methods Lock Unlock 1 Lock Unlock 1 CSS430 Operating Systems : Process Synchronization

38. Producer and Consumer Threads buffer CSS430 Operating Systems : Process Synchronization

39. Bounded Buffer Problem: Factory CSS430 Operating Systems : Process Synchronization

40. Concurrent Programming “Programming concurrent applications is a difficult and error-prone undertaking” – Dietel** When thread synchronization is required use the following guidelines (in order of complexity): • Use existing classes from the Java API (e.g. importjava.util.concurrent.*) • Use synchronized keyword and Object methods wait, notify and notifyAll • Use Lock and Condition interfaces ** (p.678) Java for Programmers, Deitel & Deitel, 2nd Edition, Prentice Hall, 2011 CSS430 Operating Systems : Process Synchronization

41. Java Thread Model New acquire lock, interrupt, I/O completes runnable enter synchronized statement notify notifyAll Interval expires Notify notifyAll task completes wait sleep issue I/O request wait waiting timed waiting terminated blocked CSS430 Operating Systems : Process Synchronization

42. Monitors p8 p7 p6 Entry queue p2 p4 p1 X: Y: • High-level language construct • Only one process allowed in a monitor, thus executing its method • A process in the monitor can wait on a condition variable, say x, thus relinquishing the monitor and allowing another process to enter • A process can signal another process waiting on a condition variable (on x). • A process signaling another process should exit from the monitor, because the signal process may have begun to work in the monitor. p3 p5 MethodA MethodB MethodC x.wait( ); x.signal( ) p1 “…the happens-before relationship. This relationship is simply a guarantee that memory writes by one specific statement are visible to another specific statement. “ CSS430 Operating Systems : Process Synchronization

43. Java Synchronization intrinsic lock = monitor lock JavaSE Reference on Synchronization (PLEASE READ IN DETAIL!) CSS430 Operating Systems : Process Synchronization

44. Java Monitor CSS430 Operating Systems : Process Synchronization

45. Java Monitor - synchronized method • Every object has an intrinsic lock associated with it. • Calling a synchronized method requires ”owning” the lock. CSS430 Operating Systems : Process Synchronization

46. Statement vs. Method Sync Another way to create synchronized code is with synchronized statements. Synchronized statements must specify the object (i.e. "this") that provides the intrinsic lock: To make a method synchronized, simply add the synchronized keyword to its declaration: CSS430 Operating Systems : Process Synchronization

47. Insert and Remove with Java Synchronization (i.e. Monitors) Producer Consumer CS CSS430 Operating Systems : Process Synchronization

48. Classical Problem 2:The Readers-Writers Problem X X • Multiple readers or a single writer can use DB. X writer reader writer reader reader reader writer reader reader writer reader reader CSS430 Operating Systems : Process Synchronization

49. Database CSS430 Operating Systems : Process Synchronization

50. Readers CSS430 Operating Systems : Process Synchronization