POSIX shared-memory API

22 Mar, 2022
Several IPC mechanisms are available for POSIX systems, including shared memory and message passing. Here, we explore the POSIX API for shared memory.
POSIX shared memory is organized using memory-mapped files, which associate the region of shared memory with a file. A process must first create a shared-memory object using the shm_open() system call, as follows:
shm_fd = shm_open(name, O_CREAT | O_RDWR, 0666);
Parameters:
name: The first parameter specifies the name of the shared-memory object. 
Processes that wish to access this shared memory must refer to the 
object by this name.
O_CREAT | O_RDWR : The subsequent parameters specify that the shared-memory 
object is to be created if it does not yet exist (O_CREAT) and that the object is 
open for reading and writing (O_RDWR).

The last parameter establishes the directory permissions of the 
shared-memory object.
A successful call to shm_open() returns an integer file descriptor for the shared-memory object. Once the object is established, the ftruncate() function is used to configure the size of the object in bytes. The call
 ftruncate(shm_fd, 4096);
sets the size of the object to 4, 096 bytes. Finally, the mmap() function establishes a memory-mapped file containing the shared-memory object. It also returns a pointer to the memory-mapped file that is used for accessing the shared-memory object. 
Programs showing POSIX shared memory API for producer and consumer 
C
//C program for Producer process illustrating POSIX shared-memory API. #include <stdio.h>#include <stdlib.h>#include <string.h>#include <fcntl.h>#include <sys/shm.h>#include <sys/stat.h>#include <sys/mman.h> int main(){    /* the size (in bytes) of shared memory object */    const int SIZE = 4096;     /* name of the shared memory object */    const char* name = "OS";     /* strings written to shared memory */    const char* message_0 = "Hello";    const char* message_1 = "World!";     /* shared memory file descriptor */    int shm_fd;     /* pointer to shared memory object */    void* ptr;     /* create the shared memory object */    shm_fd = shm_open(name, O_CREAT | O_RDWR, 0666);     /* configure the size of the shared memory object */    ftruncate(shm_fd, SIZE);     /* memory map the shared memory object */    ptr = mmap(0, SIZE, PROT_WRITE, MAP_SHARED, shm_fd, 0);     /* write to the shared memory object */    sprintf(ptr, "%s", message_0);     ptr += strlen(message_0);    sprintf(ptr, "%s", message_1);    ptr += strlen(message_1);    return 0;}
C
// C program for Consumer process illustrating// POSIX shared-memory API.#include <stdio.h>#include <stdlib.h>#include <fcntl.h>#include <sys/shm.h>#include <sys/stat.h>#include <sys/mman.h> int main(){    /* the size (in bytes) of shared memory object */    const int SIZE = 4096;     /* name of the shared memory object */    const char* name = "OS";     /* shared memory file descriptor */    int shm_fd;     /* pointer to shared memory object */    void* ptr;     /* open the shared memory object */    shm_fd = shm_open(name, O_RDONLY, 0666);     /* memory map the shared memory object */    ptr = mmap(0, SIZE, PROT_READ, MAP_SHARED, shm_fd, 0);     /* read from the shared memory object */    printf("%s", (char*)ptr);     /* remove the shared memory object */    shm_unlink(name);    return 0;}
The above programs can be compiled by typing the following commands in terminal opened in working directory –
gcc producer.c -pthread -lrt -o producer
gcc consumer.c -pthread -lrt -o consumer
./consumer & ./producer & 
This should output the following –
HelloWorld!
The above programs use the producer–consumer model in implementing shared memory. 
The producer establishes a shared memory object and writes to shared memory, and the consumer reads from shared memory.
The producer, creates a shared-memory object named OS and writes the famous string “Hello World!” to shared memory.
The program memory-maps a shared-memory object of the specified size and allows writing to the object. (Obviously, only writing is necessary for the producer.)
The flag MAP SHARED specifies that changes to the shared memory object will be visible to all processes sharing the object. Notice that we write to the shared-memory object by calling the sprintf() function and writing the formatted string to the pointer ptr.
After each write, we must increment the pointer by the number of bytes written. The consumer process, reads and outputs the contents of the shared memory.
The consumer also invokes the shm_unlink() function, which removes the shared-memory segment after the consumer has accessed it.
References Silberschatz’s Operating System concepts 
http://www.cse.cuhk.edu.hk/~ericlo/teaching/os/lab/7-IPC2/sync-pro.html
This article is contributed by Mayank Rana. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
HamidRamazani
anikakapoor
siddharthakapoor
Articles
Linux-Unix
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Docker - COPY Instruction
Time complexities of different data structures
SQL | DROP, TRUNCATE
Difference Between Object And Class
Implementation of LinkedList in Javascript
Sed Command in Linux/Unix with examples
AWK command in Unix/Linux with examples
grep command in Unix/Linux
cut command in Linux with examples
cp command in Linux with examples