SYNCHRONIZATION IN MULTIPROCESSING

PROCESS SYNCHRONIZATION

MULTIPROCESSOR SYSTEM

• Multiprocessor System is an interconnection of 2 or more CPU with memory and input-output equipments.

• Multiprocessors are classified as MIMD system(Multiple Instruction Multiple Data Stream).

PROCESS

• A process is program in execution.• A process can be either– Independent process– Cooperative process

Independent Process:– A process is independent if it is not affected by

other process executing in the system.– Process will not share data with other process.

Cooperative process:– A process can affect or be affected by other

process executing in the system.– Process share data with other process.

• Cooperative process requires interprocess communication(IPC) mechanism to exchange data and information.

• 2 fundamental models:– Shared memory–Message massing

Shared Memory

• A region of memory that is shared by cooperative process is established .

• Process can exchange information by reading and writing to shared memory.

• It allows maximum speed.• Processor communicates with shared address

space.• The main problem in shared memory is process

synchronization

MESSGAE PASSING

• Communication takes place by means of message exchange between cooperating process.

• It is useful for exchanging smaller amount of data.• It is time consuming as there is kernel intervention.• The process will be having separate address space.• Process have private memories.

PROCESS SYNCHRONIZATION MECHSNISMS

• Mainly 2 types of synchronizations are used:–Mutual exclusion– Condition synchronization

• Mutual Exclusion: If a process is executing its critical section then no other process can execute in their critical section.– A critical section is a piece of code that accesses a

shared resource that must not be concurrently accessed.

• Condition synchronization:–When a shared data object is in a state that is

inappropriate for executing a given operation.– Any process which attempt such an operation

should be delayed until the state of the data object changes to the desired value as a result of other process being executed.

• The mutual -exclusive execution of a critical section,S,whose access is controlled by a variable gate can be enforced by :

• an entry protocol denoted by MUTEXBEGIN(gate)

• and an exit protocol denoted by MUTEXEND (gate).

• Execution of the MUTEXBEGIN statement should detect the status of the critical section.

• If it is busy, the process attempting to enter the critical section must wait.

• Execution of the MUTEXEND statement should reset the status of the critical section to idle and provide a mechanism to schedule the waiting process to use the critical section.

IMPLEMENTATION

LOCK and UNLOCK operations :• consider that there is a single gate that each

process must pass through to enter a CS and also leave it.

• If a process attempting to enter the CS finds the gate unlocked (open) it locks (closes) it as it enters the CS so that all other processes attempting to enter the CS will find the gate locked.

• On completion, the process unlocks the gate and exits from the CS.

• Assuming that the variable• gate =0 means that the gate is open • gate=1 means that the gate is closed,• the access to a CS controlled by the gate can

be written as:

LOCK (gate)

execute critical section

UNLOCK (gate)

• The LOCK(x) operation may be implemented as follows:

Var x:shared integer;

LOCK (x):begin

var y: integer;

y x;

While y =1 do yx;//wait until gate is open //

x1 //set gate to unavailable status //

end

• The UNLOCK(x) operation may be implemented as

UNLOCK(x): x 0;

DISADVANTAGE OF LOCK MECHANISM:• two or more processes may find x=0 before

one reaches the x1 statement. • processes attempting to enter critical sections

are busy accessing common variables. • This is called busy –wait or spin -lock, which

results in performance degradation.

• An important property of locks is that :• a process does not relinquish the processor on

which it is executing while it is waiting for a lock held by another process.

• Thus, it is able to resume execution very quickly when the lock becomes available.

SYNCHRONIZATION WITH SEMAPHORE

• Dijkstra invented the two operations P and V, which can be shared by many processes and which implement the mutual -exclusion mechanism efficiently.

• The P and V operations are called primitives .• They operate on a special common variable

called a semaphore, which indicates the number of processes attempting to use the critical section.

• var s: semaphore• P(s): MUTEXBEGIN (s)

s s-1;

If s < 0 then

begin

Block the process executing the P(s) and put it in a FIFO queue associated with the semaphore s;

end

MUTEXEND

• V(s): MUTEXBEGIN (s)

SS + 1;

If s <= 0 then

begin

if an inactive process associated with semaphore s exists, then wake up the highest priority blocked process associated with s and

put it in a ready list.

end

MUTEXEND

• When s can take values of 0 or 1, it is called a

binary semaphore. • If s takes any integer value, it is called a

counting semaphore

• Eg.Producer Consumer Problem• consider a finite buffer BUFFER of size n arranged

as a circular queue in which the slot positions are named 0, 1,…., n-1.

• There are the two pointers c and p, which correspond to the "head" and "tail" of a circular queue, respectively.

• The consumer consumes the message from the head c by updating c and then retrieving the message.

• The producer adds a message to the buffer by updating p before the add operation.

• Initially, p= c = 0, which indicates that the buffer is empty.

• Let the variables empty and full be used to indicate the number of empty slots and occupied slots, respectively.

• The empty variable is used to inform the producer of the number of available slots.

• the full variable informs the consumer of the �number of messages needed to be consumed.

• The producer or consumer will be suspended when empty=0 or full = 0, respectively.

• shared record

begin

var p, c: integer;

var empty, full: semaphore;

var BUFFER [0:n -1]: message;

end

initial empty = n, full = 0, p = 0, c = 0;

• Cobegin

Producer: begin

var m: message;

Cycle

begin

Produce a message m;

P(emptv);

p(p+1)modn;

BUFFER [p] m; // place message in buffer//

V(full)

end

end

• Consumer: begin

var m: message;

Cycle

begin

P (full);

c(c+1) mod n;

m BUFFER [c]; // remove message from buffer //

V (emptv);

Consume message m;

end

end

coend

THANK YOU