Shared Memory

communicate and coordinate with one another. Among the fastest and most efficient methods of doing so is Shared Memory.

Let’s explore what shared memory is, how it works, and why it's a powerful tool for high-performance interprocess communication.

📘 What is Shared Memory?

Shared memory is a method of Interprocess Communication (IPC) in which multiple processes share a region of memory, allowing them to read and write to the same data space.

Once set up, processes can access the shared memory directly without kernel intervention, making it one of the fastest IPC mechanisms.

Unlike message passing, where the kernel mediates communication, shared memory allows direct access — ideal for large volumes of data or high-speed processing.

🔄 Real-Life Analogy

Imagine a whiteboard in a room where team members (processes) can write messages, numbers, or diagrams. Instead of sending messages back and forth, they all look at the same board, update it, and react accordingly.

This whiteboard is like shared memory — a common space accessible by all participants.

⚙️ How Shared Memory Works

1. One process creates the shared memory segment.

2. Other processes attach to it using a unique identifier (name or key).

3. All attached processes can read/write to the memory region.

4. The memory remains until it's explicitly destroyed, even if a process exits.

5. Synchronization mechanisms like semaphores or mutexes are needed to avoid race conditions.

🧩 Shared Memory in Different Systems

🛠️ POSIX Shared Memory Example (C)

#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main() {
    const int SIZE = 4096;
    const char* name = "/my_shm";
    const char* message = "Hello from shared memory!";

    int shm_fd = shm_open(name, O_CREAT | O_RDWR, 0666);
    ftruncate(shm_fd, SIZE);
    void* ptr = mmap(0, SIZE, PROT_WRITE, MAP_SHARED, shm_fd, 0);

    sprintf(ptr, "%s", message);
    printf("Message written to shared memory.\n");

    return 0;
}

This creates a shared memory segment, writes a message to it, and can be read by another process that opens the same shared memory object.

🛡️ Synchronization in Shared Memory

Because multiple processes can simultaneously access the memory region, synchronization is crucial to avoid data races and inconsistency.

Common tools used:

• 🛑 Semaphores

• 🔒 Mutexes

• ⏳ Condition Variables

• ⚙️ Atomic Operations

Always use synchronization when writing to shared memory. Read-only operations may not need protection.

✅ Advantages of Shared Memory

❌ Disadvantages / Challenges

🔍 When to Use Shared Memory

• Real-time image processing

• Interprocess cache or buffer

• Data analytics pipelines

• Game engines

• Embedded systems