Linux Shared Memory Synchronization

Question

I have implemented two applications that share data using the POSIX shared memory API (ie shm_open ). One process updates data stored in the shared memory segment and another process reads it. I want to synchronize the access to the shared memory region using some sort of mutex or semaphore. What is the most efficient way of do this? Some mechanisms I am considering are

• A POSIX mutex stored in the shared memory segment (Setting the PTHREAD_PROCESS_SHARED attribute would be required)
• Creating a System V semaphore using semget

Answer 1

而不是System V信号灯，我将使用sem_open()等使用名为semaphore的POSIX。

Answer 2

Might as well make this an answer.

You can use sem_init with pshared true to create a POSIX semaphore in your shared memory space. I have used this successfully in the past.

As for whether this is faster or slower than a shared mutex and condition variable, only profiling can tell you. On Linux I suspect they are all pretty similar since they rely on the "futex" machinery.

Answer 3

If efficiency is important, I would go with process-shared mutexes and condition variables.

AFAIR, each operation with a semaphore requires a syscall, so uncontended mutex should be faster than the semaphore [ab]used in mutex-like manner.

Answer 4

First, really benchmark to know if performance is important. The cost of these things is often overestimated. So if you don't find that the access to the control structure is of same order of magnitude than the writes, just take whatever construct is semantically the best for your use case. This would be the case usually if you'd have some 100 bytes written per access to the control structure.

Otherwise, if the control structure is the bottleneck, you should perhaps avoid to use them. C11 has the new concept of _Atomic types and operations that can be used in cases where there are races in access to data. C11 is not yet widely implemented but probably all modern compilers have extensions that implement these features already.