6.5. 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 programming technique that allows different processes to access the same block of memory. This means both the kernel (which is the core part of the operating system) and user-space applications (which are programs that users interact with) can use this shared memory area to exchange data quickly. Unlike other methods where one side must copy data to send it to the other side, shared memory allows both sides to read from and write to the same location directly, making it a very fast way to communicate.

Think of shared memory like a communal whiteboard in an office. Instead of writing a message on one board, erasing it, and rewriting the updated message on another board, everyone can write directly on the same board whenever they need to. This saves time, and messages can be added or updated instantly by anyone who has access. Similarly, shared memory lets programs quickly share and update data without needing to make copies.

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

Shared memory works by the kernel reserving a block of memory that programs can use. To use this shared memory, programs employ a system call called mmap() that maps this area of memory into their own address space. Once this mapping is done, both the kernel and the user programs can read from and write to that memory, facilitating fast communication. The ability for both the kernel and user space to access the same memory area means there is no need for data copying, which can slow down processes.

Imagine a shared storage room in a building. Instead of carrying boxes of files from one room to another, everyone involved can go to the storage room, take what they need, or add new items directly. This makes it much quicker to collaborate compared to if everyone had to transfer documents back and forth all the time. In the same way, shared memory enables rapid data exchange between the kernel and user applications.

#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 snippet demonstrates the use of shared memory in a C program. First, it opens /dev/zero, which is a special file used to create memory. It then uses the mmap() function to map a block of memory (4096 bytes) into the user’s address space, which allows the program to read and write to that memory. Afterward, it writes a message into this shared memory and prints it out to the screen. Finally, it cleans up by unmapping the memory and closing the file descriptor.

Think of the code as a group project where you have a poster board (the shared memory) that everyone can draw on. At first, you put some text on the poster. When you want to share what you've done, you all gather around the poster to see the work and even add more text or drawings together. Just like in the code where different parts of the program can read or write to the shared memory, every team member can contribute to the poster simultaneously, making collaboration easy.

--