6.5.2. Example of Shared Memory

Shared memory is a mechanism that allows kernel and user-space applications to directly share a region of memory. It provides an efficient way to exchange large amounts of data between the kernel and user space, as both sides can read and write to the same memory location without the need for copying data.

Shared memory is a special feature in computing that enables both the kernel and user-space applications to access the same designated memory area. This means that they can immediately read and write data from this space without needing to copy it back and forth, saving time and resources.

Imagine two coworkers sharing a whiteboard in an office. Instead of writing notes on separate pieces of paper and passing them back and forth, they both have access to a single whiteboard where they can write and update information directly. This allows them to work collaboratively and efficiently.

● The kernel allocates a region of memory that can be accessed by user-space processes. ● This region is typically mapped into the user space using mmap(). ● Both the kernel and the user space processes can read and write data to this shared region, making it an efficient communication mechanism.

The process of using shared memory involves several key steps. First, the kernel creates a specific portion of memory that applications can use. This memory area is made accessible to user-space processes by using a system call called mmap(). Once mapped, both the kernel and user processes can communicate by reading from and writing to this shared memory area. This direct access helps facilitate faster data exchange compared to conventional methods.

Think of this like a shared desk space where both coworkers can leave notes for each other. By writing directly on the desk, they can quickly share ideas or updates without needing to go back and forth with private messages, which would take longer.

#include <sys/mman.h> #include <stdio.h> #include <fcntl.h> int main() { int fd = open("/dev/zero", O_RDWR); if (fd < 0) { perror("open"); return 1; } void *shared_mem = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (shared_mem == MAP_FAILED) { perror("mmap"); close(fd); return 1; } // Access shared memory sprintf((char *)shared_mem, "Hello from user space"); // Print data from shared memory printf("Shared Memory: %s\n", (char *)shared_mem); // Cleanup munmap(shared_mem, 4096); close(fd); return 0; }

This code demonstrates how to create and utilize shared memory in a practical application. First, it opens a special file (/dev/zero) which provides a way to access memory. It then uses mmap() to map a memory region of 4096 bytes into the process's address space. After successfully mapping the memory, it can write this memory space by formatting a string into it. Finally, it reads from the memory and prints it out, showing the data stored there before cleaning up by unmapping and closing the file descriptor.

Imagine that the coworkers use a designated space (like a whiteboard) that everyone can write on. The excerpt here translates that concept into code, showing how one coworker can write a message on the shared spot, and then another coworker can read that message directly from the same spot without any delays.

--