Lecture 9: Process Synchronization Joe McCarthy CSS 430: Operating Systems - Process Synchronization

Chapter 6: Process Synchronization Background The Critical-Section Problem Peterson’s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Atomic Transactions Material derived, in part, from Operating Systems Concepts with Java, 8th Ed. © 2009 Silberschatz, Galvin & Gagne CSS 430: Operating Systems - Process Synchronization

Circular Buffer (Queue) CSS 430: Operating Systems - Process Synchronization

Producer-Consumer Problem public void insert () { // Producer E item; while (count == BUFFER_SIZE) ; // busy wait buffer[in] = item; in = (in + 1) % BUFFER_SIZE; ++count; } public E remove() { // Consumer E item; while (count == 0) ; // busy wait item = buffer[out]; out = (out + 1) % BUFFER_SIZE; --count; return item; } CSS 430: Operating Systems - Process Synchronization

Producer-Consumer Problem public void insert () { // Producer E item; while (count == BUFFER_SIZE) ; // busy wait buffer[in] = item; in = (in + 1) % BUFFER_SIZE; ++count; } LDA COUNT INCA STA COUNT public E remove() { // Consumer E item; while (count == 0) ; // busy wait item = buffer[out]; out = (out + 1) % BUFFER_SIZE; --count; return item; } LDA COUNT DECA STA COUNT CSS 430: Operating Systems - Process Synchronization

Producer-Consumer Problem LDA COUNT INCA STA COUNT import java.util.Date; public class Factory { public static void main( String[] args ) { // create the message queue Channel<Date> queue = new MessageQueue<Date>(); // create the producer and consumer threads Thread producer = new Thread( new Producer(queue) ); Thread consumer = new Thread( new Consumer(queue) ); // start the threads producer.start(); consumer.start(); } LDA COUNT DECA STA COUNT [from Chapter 3: Processes] CSS 430: Operating Systems - Process Synchronization

Producer-Consumer Problem LDA COUNT INCA STA COUNT import java.util.Date; public class Factory { public static void main( String[] args ) { // create the message queue Channel<Date> queue = new MessageQueue<Date>(); Integer count = new Integer( 0 ); // create the producer and consumer threads Thread producer = new Thread( new Producer(queue, count) ); Thread consumer = new Thread( new Consumer(queue, count) ); // start the threads producer.start(); consumer.start(); } LDA COUNT DECA STA COUNT [from Chapter 3: Processes] CSS 430: Operating Systems - Process Synchronization

Producer-Consumer Problem LDA COUNT INCA STA COUNT LDA COUNT DECA STA COUNT CSS 430: Operating Systems - Process Synchronization

Producer-Consumer Problem LDA COUNT INCA STA COUNT producer consumer LDA COUNT INCA LDA COUNT DECA LDA COUNT DECA STA COUNT STA COUNT STA COUNT CSS 430: Operating Systems - Process Synchronization

Producer-Consumer Problem LDA COUNT INCA STA COUNT producer consumer LDA COUNT INCA LDA COUNT DECA LDA COUNT DECA STA COUNT STA COUNT STA COUNT What’s the value of count? CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Race Condition LDA COUNT INCA STA COUNT Who will get there first? LDA COUNT DECA STA COUNT CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Race Condition LDA COUNT INCA STA COUNT Who will get there first? LDA COUNT DECA STA COUNT http://en.wikipedia.org/wiki/Race_condition CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Critical Section Definition: segment of code that accesses a shared resource Problem: multiple processes have concurrent access to shared resource Solution: prevent multiple processes from having concurrent access to shared resource No two processes are executing in their critical section at the same time. CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization General Structure Protocol: Request entry to critical section Execute critical section Exit critical section Do other stuff (remainder section) CSS 430: Operating Systems - Process Synchronization

Solution to Critical-Section Problem Mutual Exclusion - 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 CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization A simple solution Assume: 2 processes, P0 & P1 2 shared variables int turn; // if 0, P0’s turn; if 1, P1’s turn boolean flag[2]; // if flag[i], Pi wants to enter CS LOAD (LDA) & STORE (STA) are atomic i.e., assignment statements are indivisible How would you implement this? CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Peterson’s Solution while ( true ) { flag[i] = true; turn = j; while ( flag[j] && turn == j ) ; // busy wait // critical section // … flag[i] = false; // remainder section } entry section exit section CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Peterson’s Solution while ( true ) { flag[i] = true; turn = j; while ( flag[j] && turn == j ) ; // busy wait // critical section // … flag[i] = false; // remainder section } entry section exit section Software-based solution CSS 430: Operating Systems - Process Synchronization

Synchronization via Locks Hardware-based solution CSS 430: Operating Systems - Process Synchronization

Synchronization via Hardware Disable interrupts during CS Preempt preemption Feasible on uniprocessors What about multiprocessors? Atomic machine instructions Indivisible (non-interruptable) Examples: Test & modify word Swap two words CSS 430: Operating Systems - Process Synchronization

S/W abstraction for H/W Synch. public class HardwareData { private boolean value = false; public HardwareData( boolean initialValue ) { this.value = initialValue; } public boolean get() { return value; public void set( boolean newValue ) { this.value = newValue; public boolean getAndSet( boolean newValue ) { boolean oldValue = this.get(); this.set( newValue ); return oldValue; public void swap( HardwareData other ) { boolean temp = this.get(); this.set( other.get() ); other.set( temp ); /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Using getAndSet() public class Worker1 implements Runnable { private String name; private HardwareData mutex; public Worker1( String name, HardwareData mutex ) { this.name = name; this.mutex = mutex; } public void run() { // mutex initialized when Worker instantiated while ( true ) { System.out.println( name + " wants to enter CS" ); while ( mutex.getAndSet( true ) ) Thread.yield(); System.out.println( name + " is in critical section" ); MutualExclusionUtilities.criticalSection( name ); System.out.println( name + " is out of critical section" ); mutex.set( false ); MutualExclusionUtilities.remainderSection( name ); Do you [fore]see any problems? /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

Using getAndSet() Does this enforce mutual exclusion? public class Worker1 implements Runnable { private String name; private HardwareData mutex; public Worker1( String name, HardwareData mutex ) { this.name = name; this.mutex = mutex; } public void run() { // mutex initialized when Worker instantiated while ( true ) { System.out.println( name + " wants to enter CS" ); while ( mutex.getAndSet( true ) ) Thread.yield(); System.out.println( name + " is in critical section" ); MutualExclusionUtilities.criticalSection( name ); System.out.println( name + " is out of critical section" ); mutex.set( false ); MutualExclusionUtilities.remainderSection( name ); Does this enforce mutual exclusion? Do you [fore]see any problems? /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Using swap() public class Worker2 implements Runnable { private String name; private HardwareData mutex; public Worker2( String name, HardwareData mutex ) { this.name = name; this.mutex = mutex; } public void run() { key = new HardwareData( true ); while ( true ) { System.out.println( name + " wants to enter CS" ); key.set( true ); do { mutex.swap( key ); } while ( key.get() ); System.out.println( name + " is in critical section" ); MutualExclusionUtilities.criticalSection( name ); System.out.println( name + " is out of critical section" ); mutex.set( false ); MutualExclusionUtilities.remainderSection( name ); /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Using swap() public class Worker2 implements Runnable { private String name; private HardwareData mutex; public Worker2( String name, HardwareData mutex ) { this.name = name; this.mutex = mutex; } public void run() { key = new HardwareData( true ); while ( true ) { System.out.println( name + " wants to enter CS" ); key.set( true ); do { mutex.swap( key ); } while ( key.get() ); System.out.println( name + " is in critical section" ); MutualExclusionUtilities.criticalSection( name ); System.out.println( name + " is out of critical section" ); mutex.set( false ); MutualExclusionUtilities.remainderSection( name ); Do you [fore]see any new problems? /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

Using swap() Does not work & play well w/ others public class Worker2 implements Runnable { private String name; private HardwareData mutex; public Worker2( String name, HardwareData mutex ) { this.name = name; this.mutex = mutex; } public void run() { key = new HardwareData( true ); while ( true ) { System.out.println( name + " wants to enter CS" ); key.set( true ); do { mutex.swap( key ); } while ( key.get() ); System.out.println( name + " is in critical section" ); MutualExclusionUtilities.criticalSection( name ); System.out.println( name + " is out of critical section" ); mutex.set( false ); MutualExclusionUtilities.remainderSection( name ); Does not work & play well w/ others Do you [fore]see any new problems? /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

Using swap() Rewrite using while & yield() public class Worker2 implements Runnable { private String name; private HardwareData mutex; public Worker2( String name, HardwareData mutex ) { this.name = name; this.mutex = mutex; } public void run() { key = new HardwareData( true ); while ( true ) { System.out.println( name + " wants to enter CS" ); key.set( true ); while ( key.get() ) { Thread.yield(); mutex.swap( key ); } System.out.println( name + " is in critical section" ); MutualExclusionUtilities.criticalSection( name ); System.out.println( name + " is out of critical section" ); mutex.set( false ); MutualExclusionUtilities.remainderSection( name ); Rewrite using while & yield() /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Using AtomicBoolean public class Worker1a implements Runnable { private String name; private AtomicBoolean mutex; public Worker1a( String name, AtomicBoolean mutex ) { this.name = name; this.mutex = mutex; } public void run() { // mutex initialized when Worker instantiated while ( true ) { System.out.println( name + " wants to enter CS" ); while ( mutex.getAndSet( true ) ) Thread.yield(); System.out.println( name + " is in critical section" ); MutualExclusionUtilities.criticalSection( name ); System.out.println( name + " is out of critical section" ); mutex.set( false ); MutualExclusionUtilities.remainderSection( name ); /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

AtomicBooleanFactory import java.util.concurrent.atomic.AtomicBoolean; public class AtomicBooleanFactory { public static void main( String args[] ) { AtomicBoolean lock = new AtomicBoolean( false ); Thread[] worker = new Thread[5]; for ( int i = 0; i < 5; i++ ) { worker[i] = new Thread( new Worker1a( String.format( "worker %d", i ), lock ) ); worker[i].start(); } /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Semaphores Software-based synchronization mechanism Avoids busy waiting Semaphore S – integer variable Value  # of shared resources available Binary (1), aka mutex locks, or Counting (> 1) [Only] 2 indivisible operations modify S: acquire() & release() Originally: P() [proberen, “test”] & V() [verhogen, “increment”] CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Semaphores Indivisible testing & modification of value CSS 430: Operating Systems - Process Synchronization

Semaphores for Synchronization Critical section protection, other synchronization Process P0: Process P1: CSS 430: Operating Systems - Process Synchronization

getAndSet vs. Semaphores private AtomicBoolean mutex; … while ( mutex.getAndSet( true ) ) Thread.yield(); // critical section mutex.set( false ); // remainder section CSS 430: Operating Systems - Process Synchronization

Busy waiting vs. Blocking CSS 430: Operating Systems - Process Synchronization

Busy waiting vs. Blocking CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Blocking & Waking up CSS 430: Operating Systems - Process Synchronization

A Semaphore Implementation public class Semaphore { private int value; public Semaphore( int initialValue ) { this.value = initialValue; } public synchronized void acquire() { while ( value <= 0 ) { try { wait(); } catch ( InterruptedException e ) { value--; public synchronized void release() { ++value; notify(); /usr/apps/CSS430/examples/os-book/ch6/semaphores CSS 430: Operating Systems - Process Synchronization

Java Thread Transitions http://etutorials.org/cert/java+certification/Chapter+9.+Threads/9.5+Thread+Transitions/ CSS 430: Operating Systems - Process Synchronization

AtomicBoolean vs. Semaphore public class Worker1a implements Runnable { private String name; private AtomicBoolean mutex; public Worker1a( String name, AtomicBoolean mutex ) { this.name = name; this.mutex = mutex; } public void run() { // mutex initialized when Worker instantiated while ( true ) { System.out.println( name + " wants to enter CS" ); while ( mutex.getAndSet( true ) ) Thread.yield(); System.out.println( name + " is in critical section" ); MutualExclusionUtilities.criticalSection( name ); System.out.println( name + " is out of critical section" ); mutex.set( false ); MutualExclusionUtilities.remainderSection( name ); /usr/apps/CSS430/examples/os-book/ch6/hardware CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization A Semaphore Example import java.util.concurrent.Semaphore; public class Worker implements Runnable { private Semaphore sem; private String name; public Worker( String name, Semaphore sem ) { this.name = name; this.sem = sem; } public void run() { while ( true ) { sem.acquire(); System.out.println( name + " is in critical section" ); MutualExclusionUtilities.criticalSection( name ); System.out.println( name + " is out of critical section" ); sem.release(); MutualExclusionUtilities.remainderSection( name ); /usr/apps/CSS430/examples/os-book/ch6/semaphores CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization A Semaphore Example import java.util.concurrent.Semaphore; public class SemaphoreFactory { public static void main( String args[] ) { Semaphore sem = new Semaphore( 1 ); Thread[] bee = new Thread[5]; for ( int i = 0; i < 5; i++ ) bee[i] = new Thread( new Worker( String.format( "worker %d", i), sem ) ); bee[i].start(); } /usr/apps/CSS430/examples/os-book/ch6/semaphores CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Deadlock & 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 Starvation – indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended. CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Priority Inversion 3 processes, 3 priorities: L < M < H Scenario: L has acquired shared resource R H wants to acquire R M preempts L (which still has R) M has effectively preempted H Solution? CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Priority Inversion 3 processes, 3 priorities: L < M < H Scenario: L has acquired shared resource R H wants to acquire R M preempts L (which still has R) M has effectively preempted H Solution: Priority-inheritance protocol CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization Next Time: Background The Critical-Section Problem Peterson’s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Atomic Transactions Material derived, in part, from Operating Systems Concepts with Java, 8th Ed. © 2009 Silberschatz, Galvin & Gagne CSS 430: Operating Systems - Process Synchronization

CSS 430: Operating Systems - Process Synchronization this.suspend(); CSS 430: Operating Systems - Process Synchronization