Linux shared memory: shmget() vs mmap()?

Interviewer: Hello, could you explain what you know about the shmget() and mmap() functions in Linux shared memory? Please also outline their use cases and advantages and disadvantages.

Interviewee: Hello, I'm glad to discuss these two technologies related to Linux shared memory here. First, both shmget() and mmap() are techniques for inter-process communication (IPC), enabling data sharing by allowing different processes to access the same physical memory region.

1. shmget()

shmget() is one of the System V shared memory system calls, used in conjunction with functions like shmat() and shmdt() for creating and accessing shared memory.

Use Cases:

• shmget() is commonly used for scenarios requiring long-term sharing of large data blocks, such as continuously sharing a large data structure across multiple processes.

Advantages:

• System V shared memory provides rich control and management capabilities for shared memory, such as retrieving and setting status parameters using IPC_STAT and IPC_SET commands.

Disadvantages:

• Its interface is relatively complex, and improper usage can lead to resource leaks. For instance, if a process forgets to detach or remove the shared memory, it may cause memory leaks.
• It requires additional permission control and error handling.

Example Code:

c
#include <sys/ipc.h>
#include <sys/shm.h>

int main() {
    key_t key = ftok("somefile", 65);
    int shm_id = shmget(key, 1024, 0666|IPC_CREAT);
    char *str = (char*) shmat(shm_id, (void*)0, 0);

    // Write data to shared memory
    sprintf(str, "Hello World\n");

    // Detach shared memory
    shmdt(str);

    return 0;
}

2. mmap()

mmap() is a more general approach for memory-mapping files, which can be used to map files into memory or for anonymous mapping (i.e., not associated with any file, solely for sharing between memory regions).

Use Cases:

• mmap() is suitable for sharing memory regions of variable size or for scenarios where file content is directly mapped into memory, which is particularly beneficial for improving performance in file I/O operations.

Advantages:

• It provides a concise interface, requiring only a single call to achieve mapping, making it simpler to use than System V shared memory.
• It allows mapping partial regions of a file and supports lazy loading of files.

Disadvantages:

• For anonymous mapping, it lacks the management and control features provided by System V shared memory.
• It requires handling more file system-related issues, such as changes in file size.

Example Code:

c
#include <sys/mman.h>
#include <fcntl.h>

int main() {
    int fd = open("example.dat", O_RDWR);
    char *map = mmap(0, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    // Modify data in the file mapping region
    sprintf(map, "Using mmap\n");

    // Unmap the memory
    munmap(map, 4096);

    close(fd);
    return 0;
}

Summary: Both shmget() and mmap() are effective solutions for shared memory, but their applicable scenarios and ease of use differ. For applications requiring rich management features and large memory sharing, shmget() may be a better choice. For scenarios involving file mapping or simpler shared memory needs, mmap() might be more suitable.