1. Overview of Shared Memory Technology

Shared Memory is one of the fastest inter-process communication (IPC) methods in Linux systems, allowing multiple processes to access the same physical memory area, thus avoiding the performance overhead of data copying between processes. Compared to other IPC mechanisms such as pipes and message queues, shared memory has the following significant advantages:

• Zero-Copy: Data does not need to be copied back and forth between kernel and user space
• Low Latency: Direct memory access results in extremely low communication latency
• High Throughput: Suitable for scenarios involving large data transfers
• Flexibility: Supports random access, unlike pipes which are sequential

2. Detailed Explanation of Core Shared Memory APIs

2.1 Key System Functions

Linux provides two sets of APIs for shared memory: System V shared memory and POSIX shared memory. This article focuses on the System V interface:

1. shmget – Create/Get a shared memory segment

   int shmget(key_t key, size_t size, int shmflg);
   

2. shmat – Attach shared memory to the process address space

   void *shmat(int shmid, const void *shmaddr, int shmflg);
   

3. shmdt – Detach shared memory

   int shmdt(const void *shmaddr);
   

4. shmctl – Control shared memory segment

   int shmctl(int shmid, int cmd, struct shmid_ds *buf);
   

3. Complete C++ Implementation Example

3.1 Shared Memory Wrapper Class

#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <iostream>
#include <cstring>
#include <unistd.h>

class SharedMemory {
public:
    SharedMemory(key_t key, size_t size, bool create = false) 
        : m_key(key), m_size(size), m_shmid(-1), m_data(nullptr) {
        int flags = IPC_CREAT | 0666;
        if (!create) flags = 0666;
        
        m_shmid = shmget(m_key, m_size, flags);
        if (m_shmid == -1) {
            perror("shmget failed");
            exit(EXIT_FAILURE);
        }
        
        m_data = shmat(m_shmid, nullptr, 0);
        if (m_data == (void*)-1) {
            perror("shmat failed");
            exit(EXIT_FAILURE);
        }
    }
    
    ~SharedMemory() {
        if (m_data != nullptr && m_data != (void*)-1) {
            shmdt(m_data);
        }
    }
    
    void* data() const { return m_data; }
    size_t size() const { return m_size; }
    
    void remove() {
        shmctl(m_shmid, IPC_RMID, nullptr);
    }

private:
    key_t m_key;
    size_t m_size;
    int m_shmid;
    void* m_data;
};

3.2 Writer Process Example

int main() {
    const key_t SHM_KEY = 1234;
    const size_t SHM_SIZE = 1024;
    
    // Create shared memory
    SharedMemory shm(SHM_KEY, SHM_SIZE, true);
    
    // Write data
    const char* message = "Hello from Writer Process!";
    std::memcpy(shm.data(), message, std::strlen(message) + 1);
    
    std::cout << "Writer: Data written to shared memory" << std::endl;
    
    // Wait for reader process to finish
    sleep(10);
    
    // Clean up shared memory
    shm.remove();
    
    return 0;
}

3.3 Reader Process Example

int main() {
    const key_t SHM_KEY = 1234;
    const size_t SHM_SIZE = 1024;
    
    // Get existing shared memory
    SharedMemory shm(SHM_KEY, SHM_SIZE);
    
    // Read data
    char buffer[SHM_SIZE];
    std::memcpy(buffer, shm.data(), SHM_SIZE);
    
    std::cout << "Reader: Received message: " << buffer << std::endl;
    
    return 0;
}

4. Advanced Application Techniques

4.1 Synchronization Mechanisms

Shared memory itself does not provide inter-process synchronization, and typically needs to be used in conjunction with other mechanisms:

// Example of synchronization using semaphores
#include <semaphore.h>
#include <fcntl.h>

class SharedMemoryWithSemaphore : public SharedMemory {
public:
    SharedMemoryWithSemaphore(key_t key, size_t size, bool create = false)
        : SharedMemory(key, size, create) {
        m_sem = sem_open("/mysem", O_CREAT, 0666, 1);
        if (m_sem == SEM_FAILED) {
            perror("sem_open failed");
            exit(EXIT_FAILURE);
        }
    }
    
    void lock() { sem_wait(m_sem); }
    void unlock() { sem_post(m_sem); }
    
    ~SharedMemoryWithSemaphore() {
        sem_close(m_sem);
        sem_unlink("/mysem");
    }

private:
    sem_t* m_sem;
};

4.2 C++ Objects in Shared Memory

#include <new> // for placement new

template<typename T>
class SharedObject {
public:
    SharedObject(key_t key, bool create = false) 
        : m_shm(key, sizeof(T), create) {
        if (create) {
            new (m_shm.data()) T(); // Construct object in shared memory
        }
    }
    
    T* operator->() { return static_cast<T*>(m_shm.data()); }
    T& operator*() { return *static_cast<T*>(m_shm.data()); }

private:
    SharedMemory m_shm;
};

5. Performance Optimization and Security Considerations

1. Performance Optimization:

• Set shared memory size reasonably to avoid frequent expansions
• Align memory access boundaries (64-byte alignment is optimal)
• Batch operations to reduce synchronization overhead

Security Considerations:

• Use reasonable permission flags (e.g., 0600 instead of 0666)
• Validate all input data to prevent shared memory pollution
• Consider using POSIX shared memory (shm_open) for better access control

Enhanced Error Handling:

// Enhanced error handling for shared memory attachment
void* safe_shmat(int shmid) {
    void* ptr = shmat(shmid, nullptr, 0);
    if (ptr == (void*)-1) {
        if (errno == EINVAL) {
            std::cerr << "Invalid shmid" << std::endl;
        } else if (errno == EACCES) {
            std::cerr << "Permission denied" << std::endl;
        } // Other error handling...
        throw std::runtime_error("shmat failed");
    }
    return ptr;
}

6. Conclusion

Linux shared memory provides the most efficient data exchange channel for inter-process communication, especially suitable for the following scenarios:

• High-performance computing applications
• Real-time data processing systems
• Large game servers
• Financial trading systems

By using reasonable encapsulation and synchronization mechanisms, data consistency and system stability can be ensured while maintaining high performance. The C++ implementation examples provided in this article demonstrate how to safely use shared memory in an object-oriented manner, and developers can further expand and optimize based on actual needs.