Chapter 7 Synchronization Examples Operating System Concepts 10

Chapter 7: Synchronization Examples n Explain the bounded-buffer, readers-writers, and dining philosophers synchronization problems.

Classical Problems of Synchronization n Classical problems used to test newly-proposed synchronization schemes l

Bounded-Buffer Problem n n buffers, each can hold one item n Semaphore mutex initialized

Bounded Buffer Problem (Cont. ) n The structure of the producer process while (true)

Bounded Buffer Problem (Cont. ) n The structure of the consumer process while (true)

Readers-Writers Problem n A data set is shared among a number of concurrent processes

Readers-Writers Problem (Cont. ) n The structure of a writer process while (true) {

Readers-Writers Problem (Cont. ) n The structure of a reader process while (true){ wait(mutex);

Readers-Writers Problem Variations n First variation – no reader kept waiting unless writer has

Dining-Philosophers Problem n Philosophers spend their lives alternating thinking and eating n Don’t interact

Dining-Philosophers Problem Algorithm n Semaphore Solution n The structure of Philosopher i: while (true){

Monitor Solution to Dining Philosophers monitor Dining. Philosophers { enum { THINKING; HUNGRY, EATING)

Solution to Dining Philosophers (Cont. ) void test (int i) { if ((state[(i +

Solution to Dining Philosophers (Cont. ) n Each philosopher i invokes the operations pickup()

Kernel Synchronization - Windows n Uses interrupt masks to protect access to global resources

Kernel Synchronization - Windows n Mutex dispatcher object Operating System Concepts – 10 th

Linux Synchronization n Linux: l Prior to kernel Version 2. 6, disables interrupts to

Linux Synchronization n Atomic variables atomic_t is the type for atomic integer n Consider

POSIX Synchronization n POSIX API provides l mutex locks l semaphores l condition variable

POSIX Mutex Locks n Creating and initializing the lock n Acquiring and releasing the

POSIX Semaphores n POSIX provides two versions – named and unnamed. n Named semaphores

POSIX Named Semaphores n Creating an initializing the semaphore: n Another process can access

POSIX Unnamed Semaphores n Creating an initializing the semaphore: n Acquiring and releasing the

POSIX Condition Variables n Since POSIX is typically used in C/C++ and these languages

POSIX Condition Variables n Thread waiting for the condition a == b to become

Java Synchronization n Java provides rich set of synchronization features: Ø Java monitors Ø

Java Monitors n Every Java object has associated with it a single lock. n

Bounded Buffer – Java Synchronization Operating System Concepts – 10 th Edition 7. 29

Java Synchronization n A thread that tries to acquire an unavailable lock is placed

Java Synchronization n Similarly, each object also has a wait set. n When a

Java Synchronization n A thread typically calls wait() when it is waiting for a

Bounded Buffer – Java Synchronization Operating System Concepts – 10 th Edition 7. 33

Bounded Buffer – Java Synchronization Operating System Concepts – 10 th Edition 7. 34

Java Reentrant Locks n Similar to mutex locks n The finally clause ensures the

Java Semaphores n Constructor: n Usage: Operating System Concepts – 10 th Edition 7.

Java Condition Variables n Condition variables are associated with an Reentrant. Lock. n Creating

Java Condition Variables n Example: n Five threads numbered 0. . 4 n Shared

Java Condition Variables Operating System Concepts – 10 th Edition 7. 39 Silberschatz, Galvin

Alternative Approaches n Transactional Memory n Open. MP n Functional Programming Languages Operating System

Transactional Memory n Consider a function update() that must be called atomically. One option

Open. MP n Open. MP is a set of compiler directives and API that

Functional Programming Languages n Functional programming languages offer a different paradigm than procedural languages

End of Chapter 7 Operating System Concepts – 10 th Edition Silberschatz, Galvin and

Slides: 44

Download presentation

Chapter 7: Synchronization Examples n Explain the bounded-buffer, readers-writers, and dining philosophers synchronization problems. n Describe the tools used by Linux and Windows to solve synchronization problems. n Illustrate how POSIX and Java can be used to solve process synchronization problems. Operating System Concepts – 10 th Edition 7. 2 Silberschatz, Galvin and Gagne © 2018

Classical Problems of Synchronization n Classical problems used to test newly-proposed synchronization schemes l Bounded-Buffer Problem l Readers and Writers Problem l Dining-Philosophers Problem Operating System Concepts – 10 th Edition 7. 3 Silberschatz, Galvin and Gagne © 2018

Bounded-Buffer Problem n n buffers, each can hold one item n Semaphore mutex initialized to the value 1 n Semaphore full initialized to the value 0 n Semaphore empty initialized to the value n Operating System Concepts – 10 th Edition 7. 4 Silberschatz, Galvin and Gagne © 2018

Bounded Buffer Problem (Cont. ) n The structure of the producer process while (true) {. . . /* produce an item in next_produced */. . . wait(empty); wait(mutex); . . . /* add next produced to the buffer */. . . signal(mutex); signal(full); } Operating System Concepts – 10 th Edition 7. 5 Silberschatz, Galvin and Gagne © 2018

Bounded Buffer Problem (Cont. ) n The structure of the consumer process while (true) { wait(full); wait(mutex); . . . /* remove an item from buffer to next_consumed */. . . signal(mutex); signal(empty); . . . /* consume the item in next consumed */. . . } Operating System Concepts – 10 th Edition 7. 6 Silberschatz, Galvin and Gagne © 2018

Readers-Writers Problem n A data set is shared among a number of concurrent processes l Readers – only read the data set; they do not perform any updates l Writers – can both read and write n Problem – allow multiple readers to read at the same time l Only one single writer can access the shared data at the same time n Several variations of how readers and writers are considered – all involve some form of priorities n Shared Data l Data set l Semaphore rw_mutex initialized to 1 l Semaphore mutex initialized to 1 l Integer read_count initialized to 0 Operating System Concepts – 10 th Edition 7. 7 Silberschatz, Galvin and Gagne © 2018

Readers-Writers Problem (Cont. ) n The structure of a writer process while (true) { wait(rw_mutex); . . . /* writing is performed */. . . signal(rw_mutex); } Operating System Concepts – 10 th Edition 7. 8 Silberschatz, Galvin and Gagne © 2018

Readers-Writers Problem (Cont. ) n The structure of a reader process while (true){ 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); } Operating System Concepts – 10 th Edition 7. 9 Silberschatz, Galvin and Gagne © 2018

Readers-Writers Problem Variations n First variation – no reader kept waiting unless writer has permission to use shared object n Second variation – once writer is ready, it performs the write ASAP n Both may have starvation leading to even more variations n Problem is solved on some systems by kernel providing reader-writer locks Operating System Concepts – 10 th Edition 7. 10 Silberschatz, Galvin and Gagne © 2018

Dining-Philosophers Problem n Philosophers spend their lives alternating thinking and eating n Don’t interact with their neighbors, occasionally try to pick up 2 chopsticks (one at a time) to eat from bowl l n Need both to eat, then release both when done In the case of 5 philosophers l Shared data 4 Bowl of rice (data set) 4 Semaphore chopstick [5] initialized to 1 Operating System Concepts – 10 th Edition 7. 11 Silberschatz, Galvin and Gagne © 2018

Dining-Philosophers Problem Algorithm n Semaphore Solution n The structure of Philosopher i: while (true){ wait (chopstick[i] ); wait (chop. Stick[ (i + 1) % 5] ); /* eat for awhile */ signal (chopstick[i] ); signal (chopstick[ (i + 1) % 5] ); /* think for awhile */ } n What is the problem with this algorithm? Operating System Concepts – 10 th Edition 7. 12 Silberschatz, Galvin and Gagne © 2018

Monitor Solution to Dining Philosophers monitor Dining. Philosophers { 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); } Operating System Concepts – 10 th Edition 7. 13 Silberschatz, Galvin and Gagne © 2018

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; } } Operating System Concepts – 10 th Edition 7. 14 Silberschatz, Galvin and Gagne © 2018

Solution to Dining Philosophers (Cont. ) n Each philosopher i invokes the operations pickup() and putdown() in the following sequence: Dining. Philosophers. pickup(i); /** EAT **/ Dining. Philosophers. putdown(i); n No deadlock, but starvation is possible Operating System Concepts – 10 th Edition 7. 15 Silberschatz, Galvin and Gagne © 2018

Kernel Synchronization - Windows n Uses interrupt masks to protect access to global resources on uniprocessor systems n Uses spinlocks on multiprocessor systems l Spinlocking-thread will never be preempted n Also provides dispatcher objects user-land which may act mutexes, semaphores, events, and timers l Events 4 An event acts much like a condition variable l Timers notify one or more thread when time expired l Dispatcher objects either signaled-state (object available) or non-signaled state (thread will block) Operating System Concepts – 10 th Edition 7. 16 Silberschatz, Galvin and Gagne © 2018

Linux Synchronization n Linux: l Prior to kernel Version 2. 6, disables interrupts to implement short critical sections l Version 2. 6 and later, fully preemptive n Linux provides: l Semaphores l atomic integers l spinlocks l reader-writer versions of both n On single-cpu system, spinlocks replaced by enabling and disabling kernel preemption Operating System Concepts – 10 th Edition 7. 18 Silberschatz, Galvin and Gagne © 2018

Linux Synchronization n Atomic variables atomic_t is the type for atomic integer n Consider the variables atomic_t counter; int value; Operating System Concepts – 10 th Edition 7. 19 Silberschatz, Galvin and Gagne © 2018

POSIX Synchronization n POSIX API provides l mutex locks l semaphores l condition variable n Widely used on UNIX, Linux, and mac. OS Operating System Concepts – 10 th Edition 7. 20 Silberschatz, Galvin and Gagne © 2018

POSIX Semaphores n POSIX provides two versions – named and unnamed. n Named semaphores can be used by unrelated processes, unnamed cannot. Operating System Concepts – 10 th Edition 7. 22 Silberschatz, Galvin and Gagne © 2018

POSIX Named Semaphores n Creating an initializing the semaphore: n Another process can access the semaphore by referring to its name SEM. n Acquiring and releasing the semaphore: Operating System Concepts – 10 th Edition 7. 23 Silberschatz, Galvin and Gagne © 2018

POSIX Condition Variables n Since POSIX is typically used in C/C++ and these languages do not provide a monitor, POSIX condition variables are associated with a POSIX mutex lock to provide mutual exclusion: Creating and initializing the condition variable: Operating System Concepts – 10 th Edition 7. 25 Silberschatz, Galvin and Gagne © 2018

POSIX Condition Variables n Thread waiting for the condition a == b to become true: n Thread signaling another thread waiting on the condition variable: Operating System Concepts – 10 th Edition 7. 26 Silberschatz, Galvin and Gagne © 2018

Java Synchronization n Java provides rich set of synchronization features: Ø Java monitors Ø Reentrant locks Ø Semaphores Ø Condition variables Operating System Concepts – 10 th Edition 7. 27 Silberschatz, Galvin and Gagne © 2018

Java Monitors n Every Java object has associated with it a single lock. n If a method is declared as synchronized, a calling thread must own the lock for the object. n If the lock is owned by another thread, the calling thread must wait for the lock until it is released. n Locks are released when the owning thread exits the synchronized method. Operating System Concepts – 10 th Edition 7. 28 Silberschatz, Galvin and Gagne © 2018

Java Synchronization n Similarly, each object also has a wait set. n When a thread calls wait(): 1. It releases the lock for the object 2. The state of the thread is set to blocked 3. The thread is placed in the wait set for the object Operating System Concepts – 10 th Edition 7. 31 Silberschatz, Galvin and Gagne © 2018

Java Synchronization n A thread typically calls wait() when it is waiting for a condition to become true. n How does a thread get notified? n When a thread calls notify(): 1. An arbitrary thread T is selected from the wait set 2. T is moved from the wait set to the entry set 3. Set the state of T from blocked to runnable. n T can now compete for the lock to check if the condition it was waiting for is now true. Operating System Concepts – 10 th Edition 7. 32 Silberschatz, Galvin and Gagne © 2018

Java Reentrant Locks n Similar to mutex locks n The finally clause ensures the lock will be released in case an exception occurs in the try block. Operating System Concepts – 10 th Edition 7. 35 Silberschatz, Galvin and Gagne © 2018

Java Condition Variables n Condition variables are associated with an Reentrant. Lock. n Creating a condition variable using new. Condition() method of Reentrant. Lock: n A thread waits by calling the await() method, and signals by calling the signal() method. Operating System Concepts – 10 th Edition 7. 37 Silberschatz, Galvin and Gagne © 2018

Java Condition Variables n Example: n Five threads numbered 0. . 4 n Shared variable turn indicating which thread’s turn it is. n Thread calls do. Work() when it wishes to do some work. (But it may only do work if it is their turn. n If not their turn, wait n If their turn, do some work for awhile …. . . n When completed, notify the thread whose turn is next. n Necessary data structures: Operating System Concepts – 10 th Edition 7. 38 Silberschatz, Galvin and Gagne © 2018

Transactional Memory n Consider a function update() that must be called atomically. One option is to use mutex locks: n A memory transaction is a sequence of read-write operations to memory that are performed atomically. A transaction can be completed by adding atomic{S} which ensure statements in S are executed atomically: Operating System Concepts – 10 th Edition 7. 41 Silberschatz, Galvin and Gagne © 2018

Open. MP n Open. MP is a set of compiler directives and API that support parallel progamming. void update(int value) { #pragma omp critical { count += value } } The code contained within the #pragma omp critical directive is treated as a critical section and performed atomically. Operating System Concepts – 10 th Edition 7. 42 Silberschatz, Galvin and Gagne © 2018

Functional Programming Languages n Functional programming languages offer a different paradigm than procedural languages in that they do not maintain state. n Variables are treated as immutable and cannot change state once they have been assigned a value. n There is increasing interest in functional languages such as Erlang and Scala for their approach in handling data races. Operating System Concepts – 10 th Edition 7. 43 Silberschatz, Galvin and Gagne © 2018