CSC 323 – Principles of Operating Systems

Instructor: Dr. M. Hasan Jamal

Lecture# 03(b): Inter-Process Communication

1
Inter-process Communication
• Processes within a system may be independent or cooperating.

• Cooperating process can affect or be affected by other processes, including

sharing data

• Reasons for cooperating processes:

• Information sharing
• Computation speedup
• Modularity
• Convenience

• Cooperating processes need inter-process communication (IPC) 2

Inter-process Communication
• Two models of IPC.
• Shared memory
• Message passing

(a) Shared memory. b) Message passing.

IPC – Shared Memory Model
• An area of memory shared among the processes that wish to communicate

• The communication is under the control of the users’ process and not the OS.

• Used for large amount of data transfer.

• Major issue is to provide mechanism that allows the user processes to

synchronize their actions when they access shared memory.

• Mostly used in shared memory systems.

4
IPC – Message Passing Model
• Processes communicate with each other without resorting to shared variables

• IPC facility provides two operations:

• send(message) – message size fixed or variable
• receive(message)

• If two processes wish to communicate, they need to:

• Establish a communication link between them
• Exchange messages via send/receive

• Implementation of communication link:

• physical (e.g., shared memory, hardware bus, network)
• logical (e.g., direct/indirect, synchronous/asynchronous, automatic/explicit buffering)
5
• Mostly used in distributed systems, for small amount of data transfer (fixed or
variable length messages) as it is time consuming.
Message Format
• Consists of header and body of the message.

• In UNIX: no ID, only message type

• Control Information
• What to do if run out of buffer space
• Sequence numbers
• Priority

• Queuing discipline: usually FIFO but can

also include priorities

6
Implementation Questions
• How are links established?

• Can a link be associated with more than two processes?

• How many links can there be between every pair of communicating processes?

• What is the capacity of a link?

• Is the size of a message that the link can accommodate fixed or variable?

• Is a link unidirectional or bi-directional?

7
Direct Communication
• Processes must name each other explicitly:
• send (P, message) – send a message to process P
• receive(Q, message) – receive a message from process Q

• Properties of direct communication link:

• Links are established automatically
• A link is associated with exactly one pair of communicating processes
• Between each pair there exists exactly one link
• The link may be unidirectional, but is usually bi-directional

8
Indirect Communication
• Messages are directed and received from mailboxes (also referred to as ports)
• Each mailbox has a unique id
• Processes can communicate only if they share a mailbox

• Properties of indirect communication link:

• Link established only if processes share a common mailbox
• A link may be associated with many processes
• Each pair of processes may share several communication links
• Link may be unidirectional or bi-directional

• Operations:
• create a new mailbox
• send and receive messages through mailbox
9
• destroy a mailbox
Indirect Communication
• Primitives are defined as:
• send (A, message) – send a message to mailbox A
• receive(A, message) – receive a message from mailbox A

• Mailbox sharing – consider the following …

• P1, P2, and P3 share mailbox A
• P1, sends; P2 and P3 receive
• Who gets the message?

• Possible Solutions to avoid unpredictable behavior

• Allow a link to be associated with at most two processes
• Allow only one process at a time to execute a receive operation
• Allow system to select an arbitrarily receiver. Sender is notified who the receiver was. 10
Synchronization
• Message passing may be either blocking or non-blocking.

• Blocking is considered synchronous.

• Blocking send – the sender is blocked until the message is received
• Blocking receive – the receiver is blocked until a message is available

• Non-blocking is considered asynchronous.

• Non-blocking send – the sender sends the message and continues
• Non-blocking receive – the receiver receives a valid message or null message

message next_produced; message next_consumed;

while (true) { while (true) {
/* produce an item */ receive(next_consumed); 11
send(next_produced); /* consume the item */
} }
Link Capacity – Buffering
• Regardless of how messages are exchanged between processes, queue of
messages attached to the link.

• Queuing can be implemented in one of three ways

• Zero capacity – no messages are queued on a link.
• Sender must wait (or block) until the receiver gets the message
• Bounded capacity – queue has finite length of n messages
• Sender must wait if link full
• Unbounded capacity – queue has “infinite” length
• Sender never waits

12
Examples of IPC Systems – POSIX
• POSIX Shared Memory
• Process first creates shared memory segment
shm_fd = shm_open(name, O CREAT | O RDWR, 0666);

• Also used to open an existing segment

• Set the size of the object
ftruncate(shm_fd, 4096);

• Use mmap() to memory-map a file pointer to the shared memory object

• Reading and writing to shared memory is done by using the pointer returned by
mmap(). 13
IPC POSIX Producer and Consumer

14
Examples of IPC Systems – Mach
• Mach communication is message based:
• Even system calls are messages.
• Each task gets two mailboxes at creation: Kernel and Notify.
• Messages are sent and received using the mach_msg() function
• Ports needed for communication, created via mach_port_allocate()
• Send and receive are flexible; for example, four options if mailbox full:
• Wait indefinitely
• Wait at most n milliseconds #include<mach/mach.h>
• Return immediately
• Temporarily cache a message struct message {
mach_msg_header_t header;
int data;
};
mach port t client; 15
mach port t server;

Mach Messages
Mach Message Passing – Client and
Server

16
Examples of IPC Systems – Windows
• Message-passing centric via advanced local procedure call (LPC) facility:
• Only works between processes on the same system.
• Uses ports (like mailboxes) to establish and maintain communication channels.
• Communication works as follows:
• The client opens a handle to the
subsystem’s connection port object.
• The client sends a connection request.
• The server creates two private
communication ports and returns the
handle to one of them to the client.
• The client and server use the
corresponding port handle to send
messages or callbacks and to listen for
replies. 17

Local Procedure Call in Windows XP

Pipes
• Acts as a channel allowing two processes to communicate.

• Some issues:
• Is communication unidirectional or bidirectional?
• In the case of two-way communication, is it half or full-duplex?
• Must there exist a relationship (i.e., parent-child) between the communicating
processes?
• Can the pipes be used over a network?

• Ordinary pipes – cannot be accessed from outside the process that created it.
Typically, a parent process creates a pipe and uses it to communicate with a
child process that it created.
18
• Named pipes – can be accessed without a parent-child relationship.
Ordinary Pipes
• Ordinary Pipes allow communication in standard producer-consumer style

• Producer writes to one end (the write-end of the pipe)

• Consumer reads from the other end (the read-end of the pipe)

• Ordinary pipes are therefore unidirectional

• Require parent-child relationship between communicating processes

19

• Windows calls it anonymous pipes

Named Pipes
• Named Pipes are more powerful than ordinary pipes

• Communication is bidirectional

• No parent-child relationship is necessary between the communicating processes

• Several processes can use the named pipe for communication

• Provided on both UNIX and Windows systems

20
Communication in Client-Server Systems
• Various mechanisms for communication between client-server systems
• Sockets
• Remote Procedure Calls (RPCs)

21
Sockets
• A socket is defined as an endpoint for communication.
• Concatenation of IP address and port.
• The socket 161.25.19.8:1625 refers to port 1625 on host 161.25.19.8
• Communication consists between a pair of sockets
• All ports below 1024 are well known, used for standard services
• Special IP address 127.0.0.1 (loopback) to refer to system on which process is
running

22
Sockets in Java
• Three types of sockets
• Connection-oriented (TCP)
• Connectionless (UDP)
• MulticastSocket class– data can be sent to multiple recipients

23
Remote Procedure Calls (RPCs)
• RPC abstracts procedure calls between processes on a networked system.
• Uses ports for service differentiation
• Stubs – client-side proxy for the actual procedure on the server.
• The client-side stub locates the server and marshals the parameters.
• The server-side stub receives this message, unpacks the marshalled parameters,
and performs the procedure on the server.
• On Windows, stub code compile from specification written in Microsoft Interface
Definition Language (MIDL)
• Data representation handled via External Data Representation (XDL) format to
account for different architectures (Big-endian and little-endian)
• Remote communication has more failure scenarios than local
24
• Messages can be delivered exactly once rather than at most once
• OS typically provides a matchmaker service to connect client and server
Remote Procedure Call Mechanism

25
Execution of Remote Procedure Call

26