From Shared Memory to Sockets: Understanding IPC for Efficient Process Communication

Inter-Process Communication (IPC) is a fundamental concept in operating systems that enables processes to exchange data and synchronize their actions. Since processes run in their own memory space, IPC mechanisms allow them to communicate efficiently. In this article, we’ll explore different IPC techniques, their trade-offs, and how they are used in real-world applications.

Why is IPC Needed?

Modern operating systems support multiple processes running simultaneously. These processes often need to share data or coordinate tasks. IPC provides a structured way to:

• Exchange information between processes.

• Synchronize execution to avoid race conditions.

• Improve performance by distributing workloads efficiently.

Types of IPC Mechanisms

1. Shared Memory

IPC through Shared Memory is a method where multiple processes are given access to the same region of memory. This shared memory allows the processes to communicate with each other by reading and writing data directly to that memory area.

Shared Memory in IPC can be visualized as Global variables in a program which are shared in the entire program but shared memory in IPC goes beyond global variables, allowing multiple processes to share data through a common memory space, whereas global variables are restricted to a single process.

2. Message Passing

Message passing involves processes sending and receiving structured messages to communicate. This method is often used when processes run on different machines. Below are some of the popular methods:-

(a) Pipes

• Used for one-way communication between a parent and child process.

• Example: The | (pipe) operator in Linux (e.g., ls | grep txt).

• Limited to inter-process communication on the same machine.

(b) Sockets

• Used for network-based IPC.

• Supports bidirectional communication between a client and server.

• Used in popular client-server models (e.g., Web applications, microservices, and APIs).

(c) RPC

• Procedure calls sent across a network to execute on another computer.

• Ideal for microservices and distributed systems.

Historical Perspective: Mach OS and Message Passing

Mach OS was one of the first operating systems to implement message passing as an IPC method. Instead of processes, Mach referred to them as TASKS, and messages were exchanged using PORTS (also known as Mailboxes).

How it Worked:

1. Each task had one or more ports for communication.

2. Messages were sent to these ports using IPC mechanisms.

3. The OS handled message routing between tasks.

This concept influenced many modern operating systems, including macOS and iOS.

System Calls for Message Passing

Since processes cannot directly access the kernel space, the operating system provides dedicated system calls to facilitate IPC:

• send() – Used to send messages between processes.

• receive() – Used to retrieve messages sent by another process.

These system calls abstract away the complexities of low-level memory management and ensure safe, structured communication.

Real-World Applications of IPC

1. Web Servers and Browsers: Communication between the browser (client) and web server using sockets.

2. Microservices Architecture: Services communicate over RPC for efficiency.

3. Database Systems: Shared memory is used for caching and fast query execution.

4. Inter-Container Communication: Docker containers communicate using IPC mechanisms like shared memory and sockets.

References

https://www.youtube.com/watch?v=Y2mDwW2pMv4

https://www.geeksforgeeks.org/methods-in-interprocess-communication/