Study with the several resources on Docsity
Earn points by helping other students or get them with a premium plan
Prepare for your exams
Study with the several resources on Docsity
Earn points to download
Earn points by helping other students or get them with a premium plan
An in-depth explanation of monitor with condition variables and their implementation in various operating systems. It covers the concept of semaphores, the operation of wait and signal, and the use of condition variables in synchronization. The document also discusses the synchronization techniques used in solaris, windows xp, linux, and pthreads, as well as atomic transactions and log-based recovery.
Typology: Study notes
1 / 32
This page cannot be seen from the preview
Don't miss anything!
Operating System Concepts 6.2 Silberschatz, Galvin and Gagne ©
Background The Critical-Section Problem Peterson’s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Atomic Transactions
Operating System Concepts 6.3 Silberschatz, Galvin and Gagne ©
Concurrent access to shared data may result in data inconsistency Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes Suppose that we wanted to provide a solution to the consumer-producer problem that fills all the buffers. We can do so by having an integer count that keeps track of the number of full buffers. Initially, count 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.
Operating System Concepts 6.4 Silberschatz, Galvin and Gagne ©
while (true) {
/* produce an item and put in nextProduced */ while (count == BUFFER_SIZE) ; // do nothing buffer [in] = nextProduced; in = (in + 1) % BUFFER_SIZE; count++; }
Operating System Concepts 6.7 Silberschatz, Galvin and Gagne ©
Operating System Concepts 6.8 Silberschatz, Galvin and Gagne ©
Two process solution Assume that the LOAD and STORE 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 Pi is ready!
Operating System Concepts 6.9 Silberschatz, Galvin and Gagne ©
while (true) { flag[i] = TRUE; turn = j; while ( flag[j] && turn == j);
CRITICAL SECTION
flag[i] = FALSE;
REMAINDER SECTION
}
Operating System Concepts 6.10 Silberschatz, Galvin and Gagne ©
Many systems provide hardware support for critical section code 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-interruptable Either test memory word and set value Or swap contents of two memory words
Operating System Concepts 6.13 Silberschatz, Galvin and Gagne ©
Definition:
void Swap (boolean *a, boolean *b) { boolean temp = *a; *a = *b; *b = temp: }
Operating System Concepts 6.14 Silberschatz, Galvin and Gagne ©
Shared Boolean variable lock initialized to FALSE; Each process has a local Boolean variable key. Solution: while (true) { key = TRUE; while ( key == TRUE) Swap (&lock, &key );
// critical section
lock = FALSE;
// remainder section
Operating System Concepts 6.15 Silberschatz, Galvin and Gagne ©
Synchronization tool that does not require busy waiting Semaphore S – integer variable Two standard operations modify S: wait() and signal() Originally called P() and V() Less complicated Can only be accessed via two indivisible (atomic) operations wait (S) { while S <= 0 ; // no-op S--; } signal (S) { S++; }
Operating System Concepts 6.16 Silberschatz, Galvin and Gagne ©
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 Also known as mutex locks Can implement a counting semaphore S as a binary semaphore Provides mutual exclusion Semaphore S; // initialized to 1 wait (S); Critical Section signal (S);
Operating System Concepts 6.19 Silberschatz, Galvin and Gagne ©
Implementation of wait:
wait (S){ value--; if (value < 0) { add this process to waiting queue block(); } }
Implementation of signal:
Signal (S){ value++; if (value < = 0) { remove a process P from the waiting queue wakeup(P); } }
Operating System Concepts 6.20 Silberschatz, Galvin and Gagne ©
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 P 0 P 1 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 6.21 Silberschatz, Galvin and Gagne ©
Bounded-Buffer Problem Readers and Writers Problem Dining-Philosophers Problem
Operating System Concepts 6.22 Silberschatz, Galvin and Gagne ©
N buffers, each can hold one item Semaphore mutex initialized to the value 1 Semaphore full initialized to the value 0 Semaphore empty initialized to the value N.
Operating System Concepts 6.25 Silberschatz, Galvin and Gagne ©
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.
Shared Data Data set Semaphore mutex initialized to 1. Semaphore wrt initialized to 1. Integer readcount initialized to 0.
Operating System Concepts 6.26 Silberschatz, Galvin and Gagne ©
The structure of a writer process
while (true) { wait (wrt) ;
// writing is performed
signal (wrt) ; }
Operating System Concepts 6.27 Silberschatz, Galvin and Gagne ©
The structure of a reader process
while (true) { wait (mutex) ; readcount ++ ; if (readercount == 1) wait (wrt) ; signal (mutex)
// reading is performed
wait (mutex) ; readcount - - ; if (redacount == 0) signal (wrt) ; signal (mutex) ; }
Operating System Concepts 6.28 Silberschatz, Galvin and Gagne ©
Shared data Bowl of rice (data set) Semaphore chopstick [5] initialized to 1
Operating System Concepts 6.31 Silberschatz, Galvin and Gagne ©
A high-level abstraction that provides a convenient and effective mechanism for process synchronization Only one process may be active within the monitor at a time
monitor monitor-name { // shared variable declarations procedure P1 (…) { …. } …
procedure Pn (…) {……}
Initialization code ( ….) { … } … } }
Operating System Concepts 6.32 Silberschatz, Galvin and Gagne ©
Operating System Concepts 6.33 Silberschatz, Galvin and Gagne ©
condition x, y;
Two operations on a condition variable: x.wait () – a process that invokes the operation is suspended. x.signal () – resumes one of processes (if any) that invoked x.wait ()
Operating System Concepts 6.34 Silberschatz, Galvin and Gagne ©
Operating System Concepts 6.37 Silberschatz, Galvin and Gagne ©
Each philosopher I invokes the operations pickup() and putdown() in the following sequence:
dp.pickup (i)
dp.putdown (i)
Operating System Concepts 6.38 Silberschatz, Galvin and Gagne ©
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.
Operating System Concepts 6.39 Silberschatz, Galvin and Gagne ©
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--;
Operating System Concepts 6.40 Silberschatz, Galvin and Gagne ©
The operation x.signal can be implemented as:
if (x-count > 0) { next-count++; signal(x-sem); wait(next); next-count--; }
