This document discusses interprocessor communication and process synchronization. It describes how independent processes can cooperate by exchanging data through interprocessor communication methods like shared memory and message passing. It also explains process synchronization techniques like semaphores, locks, and barriers that allow processes to coordinate access to shared resources and prevent race conditions. The key synchronization methods of semaphores, locks, and barriers are defined and semaphore implementation using wait and signal operations is demonstrated using the classic producer-consumer problem example.

1. INTERPROCESSOR
COMMUNICATION AND
PROCESS SYNCHRONIZATION
Presented By
Neena R Krishna
S8,BTECH CSE
SNGIST

2. CONTENTS
• INTRODUCTION
• INTERPROCESSOR COMMUNICATION
• PROCESS SYNCHRONIZATION AND
SEMAPHORE

3. INTRODUCTION
• Independent process cannot affect or be
affected by the execution of another process
• Cooperating process can affect or be affected by
the execution of another process
• Advantages of process cooperation
– Information sharing
– Modularity
– Convenience

4. Interprocessor Communication
• Exchange of data between two or more processes.
– Os provide facilities for IPC.
• IPC facility provides two operations:
send(message)and receive(message) (message size fixed or
variable).
• If P and Q wish to communicate, they need to:
–establish a communication link between them
exchange messages via send/receive

5. Contd..
• Multiprocessor and multiple memory modules are
connected together via some interconnection
network.
• They fall on two categories:-
1)Shared memory
2)Message passing

6. INTERPROCESSOR COMMUNICATION
THROUGH ADDRESS SPACE SHARING

7. INTERPROCESSOR COMMUNICATION
VIA KERNAL SPACE

8. SHARED MEMORY
• Processors exchange information through
their central shared memory system.
• Inter co-ordination through a global memory
shared by all processor.
• Server system that communicate through a
bus and cache memory controller.
• Access to shared memory is balanced
– Symmetric multiprocessor

9. Contd..
• Each processor has equal opportunities to
read/write to memory including equal access
speed.
PROCESSORs
Registers
Local memory
banks (additional
memory resource
Cache
Buffers

12. Contd..
• Basic issues in the design of shared memory
system have to be taken in consideration :-
1)Access Control
2)Synchronization
3)Protection and Security

13. ACCESS CONTROL
• Determines which process access are possible to
which resource.
• The latter contain flag that determine the legality
of each access attempt.
• If there are access attempt to resources then until
the desired access is completed, all disallowed
access are attempt and illegal process are blocked.

14. SYNCHRONIZATION
• Constraints limit the time of access from
sharing processes to shared resource.
• Appropriate synchronization ensures that the
information flows properly and ensure system
functionality.

15. PROTECTION AND SECURITY
• It is a system feature that prevents processes
from making arbitrary access to resource
belonging to other processes.
• Sharing and protection are incompatible:-
– Sharing allow access & protection restricts it.

16. FEATURES
• All communications are done using implicit
loads and stores to a global address space.
• Synchronization and communication are
distinct.

17. MESSAGE PASSING
• Combine the local memory and processor at
each node of the interconnection network.
• There is no global memory.
– Move data from one local memory to another by
means of message passing.
– Done by a send/reciever pair of commands and
dealing consistency issues.
– Eg: c.1990 Ncube.

19. Contd..
• A node in message passing system of
processor and its local memory.
• They are able to store message buffers and
able to perform send/receive operation at the
same time as processing.
• Processor do not share a global memory and
each processor has access to its own address
space.

20. • Basic advantage :-
– Scalable.

21. SYNCHRONIZATION
• Required when one process must wait for
another to complete some operation before
proceeding.
– Eg:-one process (called a writer) may be writing
data to a certain main memory area, while
another process (a reader) may be reading data
from that area and sending it to the printer. The
reader and writer must be synchronized so that
the writer does not overwrite.

22. IMPORTANCE OF SYNCHRONIZATION
• Prevention and elimination of race conditions,
deadlocks and starvation.
• Data integrity/consistency.
• Collaboration.
• Efficiency.

23. SYNCHRONIZATION PROBLEMS
• Race conditions
– the exact timing in the execution of concurrent
processes is critical
• Critical sections
– part of a program that must be protected from
interference
– usually resolved via mutual exclusion
• Mutual exclusion
– the usage of resources by processes is restricted
– usually: only one process may use one instance of a
resource

24. RACE CONDITION

25. TYPES OF SYNCHRONIZATION
• Barrier
• Lock
• Semaphore

26. BARRIER
• Usually implies that all tasks are involved
• Each task performs its work until it reaches
the barrier. It then stops, or "blocks".
• When the last task reaches the barrier, all
tasks are synchronized.
• What happens from here varies. Often, a
serial section of work must be done. In other
cases, the tasks are automatically released to
continue their work.

27. LOCK
Suppose there are 2 processes
– Write-process 1 and Read-process 2
PROCESS 1
WRITE
MEMORY LOCKED
AFTER WRITING
UNLOCK MEMORY
PROCESS 2
READ

28. Contd..
• 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 yx;//wait until gate is open //
x1 //set gate to unavailable status //
end

29. • The UNLOCK(x) operation may be
implemented as
UNLOCK(x): x  0;

30. SEMAPHORE
• It is a resource that contains an integer value
and allows process to synchronize by testing
and setting this value on a single atomic
operations.
– Process that test the value of a semaphore and
sets it to a different value,is guaranteed no other
process will interfere with the operation in the
middle.

31. Contd..
• Two types of operations :-
– Wait
– Signal.

32. FEATURES OF SEMAPHORE
• Semaphores are used to synchronize operations
when processes access a common, limited, and
possibly non-shareable resource.
• Each time a process wants to obtain the resource,
the associated semaphore is tested. A positive,
non-zero semaphore value indicates the resource
is available.
• Semaphore system calls will, by default, cause the
invoking process to block if the semaphore value
indicates the resource is not available

33. TYPES OF SEMPAHORE
• COUNTING SEMAPHORE
– Semaphores controlling access to N (multiple)
resources, thus assuming a range of non-negative
values, are frequently.
• BINARY SEMAPHORE
– Semaphores that control access to a single
resource, taking the value of 0 (resource is in use)
or 1 (resource is available).

34. SEMAPHORE IMPLEMENTATION

36. 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

37. V(s): MUTEXBEGIN (s)
SS + 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

38. EXAMPLE
PRODUCER CONSUMER PROBLEM
Producer
While(true)
{
while(((in+1) % Buffer_Size)==out);
buffer[in]=item;
in=(in+1)%Buffer_Size;
}

39. Contd..
Consumer
While(true)
{
while(in==out);
item=buffer[out];
out=(out+1)%Buffer_Size;
return item;
}

40. Contd..

41. Solution with Semaphore
Empty=n,full=0.mutex=1
Producer
Do
{
//Produce item
wait(empty);
wait(mutex);
//add item to the buffer
signal(mutex);
signal(full);
}while(true);

42. Contd..
Consumer
Do
{
wait(full);
wait(mutex);
//Remove an item from buffer
signal(mutex);
signal(empty);
//consume the remove item
}while(true);