Unit-2: Operating system lecturenotes (Process Synchronization) P.R.Engineering college

Unit-2: Operating system lecturenotes (Process Synchronization) in Operating System uploaded at P.R.Engineering college

Unit-2: Operating system lecturenotes (Process Synchronization) in Operating System at P.R.Engineering college P.R.Engineering college Staff uploaded in lecturenotes.net

Summary / document preview text:

UNIT II
Process Synchronization
Background
 Concurrent access to shared data may result in data inconsistency.
 Maintaining data consistency requires mechanisms to ensure the orderly execution of 
cooperating processes.
 Shared-memory solution to bounded-butter problem (Chapter 4) allows at most n – 1 items in 
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, 
initialized to 0 and incremented each time a new item is added to the buffer
Bounded-Buffer 
 Shared data
#define BUFFER_SIZE 10
typedef struct {
. . .
} item;
item buffer[BUFFER_SIZE];
int in = 0;
int out = 0;
int counter = 0;
Bounded-Buffer 
 Producer process 
item nextProduced;
while (1) {
while (counter == BUFFER_SIZE)
; /* do nothing */
buffer[in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
counter++;
}
Bounded-Buffer 
 Consumer process 
item nextConsumed;
while (1) {
while (counter == 0)
; /* do nothing */
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
counter--;
}Process Synchronization
Operating Systems Page 2
Bounded Buffer
 The statements
counter++;
counter--;
must be performed atomically.
 Atomic operation means an operation that completes in its entirety without interruption.
 The statement “count++” may be implemented in machine language as:
register1 = counter
register1 = register1 + 1
counter = register1
The statement “count—” may be implemented as:
register2 = counter
register2 = register2 – 1
counter = register2
 If both the producer and consumer attempt to update the buffer concurrently, the assembly 
language statements may get interleaved.
 Interleaving depends upon how the producer and consumer processes are scheduled.
 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.
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.
 To prevent race conditions, concurrent processes must be synchronized.
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.
Solution to Critical-Section Problem
1. Mutual Exclusion. If process Pi is executing in its critical section, then no other processes 
can be executing in their critical sections.
2. 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.
3. 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 Process Synchronization
Operating Systems Page 3
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.
Initial Attempts to Solve Problem
 Only 2 processes, P0 and P1
 General structure of process Pi (other process Pj)
do {
entry section
critical section
exit section
reminder section
} while (1);
 Processes may share some common variables to synchronize their actions.
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;
reminder section
} while (1);
 Satisfies mutual exclusion, but not progress
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);Process Synchronization
Operating Systems Page 4
 Satisfies mutual exclusion, but not progress requirement.
Algorithm 3
 Combined 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.
Bakery Algorithm
 Before entering its critical section, 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...
 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
boolean choosing[n];
int number[n];
 Data structures are initialized to false and 0 respectively
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);Process Synchronization
Operating Systems Page 5
Synchronization Hardware
 Test and modify the content of a word atomically
. boolean TestAndSet(boolean &target) {
boolean rv = target;
tqrget = true;
return rv;
}
Mutual Exclusion with Test-and-Set
 Shared data: 
boolean lock = false;
 Process Pi
do {
while (TestAndSet(lock)) ;
critical section
lock = false;
remainder section
}
 Atomically swap two variables.
void Swap(boolean &a, boolean &b)

Title:
Unit-2: Operating system lecturenotes (Process Synchronization)

Subject:
Operating System

Institute:
P.R.Engineering college

Unit-2: Operating system lecturenotes (Process Synchronization) P.R.Engineering college

Unit-2: Operating system lecturenotes (Process Synchronization) in Operating System uploaded at P.R.Engineering college

Summary / document preview text:

Modal

Are you sure to delete this information ?