Shared Memory in Unix Using C Programming

🎯 Introduction

🎯 Concept

🎯 Shared memory Program

🎯 Shared memory Program Explanation

🎯 Sample Output

🎯 Summary

🎯 Key Points

👉 More Unix Network Programs

🎯 Introduction

Shared memory is a powerful interprocess communication mechanism in Unix-based operating systems that allows multiple processes to access the same region of memory. This shared memory region can be used to share data among processes efficiently and is particularly useful when processes need to collaborate and exchange information without the overhead of inter-process communication (IPC).

In this blog post, we will explore the concept of shared memory in Unix using C programming. We'll cover the basics of shared memory, create a C program that demonstrates its usage, and provide a detailed explanation of the code and its output. We will also highlight some key points and potential use cases for shared memory.

🎯 Concept

Shared memory provides a common memory area that is mapped into the address space of multiple processes. This means that each participating process can read from and write to the shared memory segment as if it were its own memory. The critical aspect of shared memory is proper synchronization, as multiple processes accessing the same memory region simultaneously can lead to data corruption and other issues.

To ensure proper synchronization, Unix provides the concept of semaphores. Semaphores are simple integer variables used as a signaling mechanism to control access to shared resources. Processes can increment, decrement, and test the value of semaphores, allowing them to request and release access to shared memory segments safely.

🎯 Shared memory Program

#include <stdio.h>

#include <sys/ipc.h>

#include <sys/shm.h>

#include <sys/sem.h>

#include <unistd.h>

int main() {

int id, semid, count = 0, i = 1, j;

int *ptr;

// Create a shared memory segment

id = shmget(8078, sizeof(int), IPC_CREAT | 0666);

ptr = (int *)shmat(id, NULL, 0);

// Create a semaphore

union semun {

int val;

struct semid_ds *buf;

ushort *array;

} u;

struct sembuf sem;

semid = semget(1011, 1, IPC_CREAT | 0666);

ushort a[1] = {1};

u.array = a;

semctl(semid, 0, SETALL, u);

while (1) {

sem.sem_num = 0;

sem.sem_op = -1;

sem.sem_flg = 0;

semop(semid, &sem, 1);

*ptr = *ptr + 1;

printf("Process ID: %d Count is: %d \n", getpid(), *ptr);

for (j = 1; j <= 1000000; j++) {

sem.sem_num = 0;

sem.sem_op = +1;

sem.sem_flg = 0;

semop(semid, &sem, 1);

}

// Detach shared memory

shmdt(ptr);

return 0;

}

🎯 Shared memory Program Explanation

The program starts by including necessary header files, including <stdio.h>, <sys/ipc.h>, <sys/shm.h>, <sys/sem.h>, and <unistd.h> for system calls.
The main() function initializes variables id, semid, count, and i. It also declares an integer pointer ptr, which will be used to access the shared memory segment.
The program creates a shared memory segment using the shmget function with key 8078 and the size of an integer (sizeof(int)). The IPC_CREAT flag ensures that the shared memory segment is created if it does not exist already, and 0666 provides read and write permissions.
The shared memory segment is attached to the process's address space using the shmat function. The return value of shmat is assigned to the ptr pointer, allowing us to read and write to the shared memory region.
Next, we define a union semun that will be used to initialize the semaphore. The semid variable is set to the identifier of the semaphore set created by semget. We create a semaphore set with one semaphore using the key 1011 and IPC_CREAT | 0666 to ensure that it is created if it doesn't exist.
The semaphore value is initialized to 1 using the ushort a[1] array and the semctl function. This ensures that the first process to access the shared memory is allowed in while subsequent processes are blocked.
The main loop of the program runs infinitely (while (1)) to demonstrate the shared memory usage.
Before accessing the shared memory (*ptr), the process performs a down operation (sem.sem_op = -1) on the semaphore using semop. This decrements the semaphore value, effectively blocking other processes from accessing the shared memory.
The process increments the shared integer value (*ptr) and prints the process ID and the current count.
To simulate some work being done in the critical section, the process enters a loop where it performs an up operation (sem.sem_op = +1) on the semaphore after each iteration. This increments the semaphore value, allowing the next process to access the shared memory.
After the loop, the process detaches the shared memory segment using shmdt(ptr) to release the memory resources.

🎯 Sample Output

The output of running the program will be a continuous stream of process IDs and the count value, as each process continuously increments the shared count. The exact values may vary each time the program is executed.

Process ID: 4568 Count is: 1012310

Process ID: 4568 Count is: 1012311

Process ID: 4568 Count is: 1012312

Process ID: 4568 Count is: 1012313

Process ID: 4568 Count is: 1012315

Process ID: 4568 Count is: 1012317

Process ID: 4568 Count is: 1012319

Process ID: 4568 Count is: 1012321

Process ID: 4607 Count is: 1012322

Process ID: 4607 Count is: 1012324

Process ID: 4607 Count is: 1012326

Process ID: 4607 Count is: 1012328

Process ID: 4607 Count is: 1012330

Process ID: 4607 Count is: 1012332

Process ID: 4607 Count is: 1012334

...

🎯 Summary

This blog post explored the concept of shared memory in Unix using C programming. Shared memory allows multiple processes to access the same memory region, enabling efficient inter-process communication. To ensure proper synchronization, we used semaphores to control access to the shared memory segment. The C program demonstrated how to create a shared memory segment, initialize a semaphore, and implement synchronization using semaphores.

🎯 Key Points

Shared memory is a powerful inter-process communication mechanism in Unix.
Multiple processes can access the same shared memory region.
Proper synchronization using semaphores is crucial to avoid data corruption and other issues.
Semaphores are used to control access to shared memory, allowing processes to request and release access to shared resources safely.
The shmget function is used to create a shared memory segment, and shmat attaches it to the process's address space.
The semget function creates a semaphore set, and semctl initializes the semaphore's value.
Semaphores are manipulated using the semop function, where a negative value (-1) represents the down operation (decrementing the semaphore) and a positive value (+1) represents the up operation (incrementing the semaphore).
Shared memory provides a high-performance communication method, as data can be exchanged directly between processes without the need for copying data between address spaces.
However, shared memory also requires careful handling to prevent data inconsistencies and race conditions between processes.
Proper synchronization using semaphores ensures that only one process can access the shared resource at a time.
Shared memory is suitable for scenarios where processes need to collaborate and share data rapidly, such as in inter-process communication or parallel computing applications.
Be cautious about the data structure used in shared memory, as different processes might have different byte alignments and architectures.