Basically the problem seems to be that the underlying mmap’ed file (owned by shm within read_from_shm) is being closed when shm is garbage collected when the function returns. Then shmData refers back to it, which is where you get the segfault (for referring to a closed mmap) This seems to be a known bug, but … Read more
Both methods are viable. mmap method is a little bit more restrictive then shmget, but easier to use. shmget is the old System V shared memory model and has the widest support. mmap/shm_open is the new POSIX way to do shared memory and is easier to use. If your OS permits the use of POSIX … Read more
You can use a custom comparator struct MyLess { template <typename T, typename U> bool operator()(const T&t, const U&u) const { return t<u; } }; In your code you can just typedef it as StringComparator UPDATE To the comments Multi Index To The Rescue If you want to replace the std::map/boost::container::map with a Boost Multi … Read more
You need to tell the mutex to be process-shared when it’s inited: http://www.opengroup.org/onlinepubs/007908775/xsh/pthread_mutexattr_setpshared.html Note in particular, “The default value of the attribute is PTHREAD_PROCESS_PRIVATE”, meaning that accessing it from different processes is undefined behaviour.
Is it possible to attach that region of memory to the server POST forking, after the client creates it? MAP_ANONYMOUS|MAP_SHARED mapped memory can only be accessed by the process which does that mmap() call or its child processes. There is no way for another process to map the same memory because that memory can not … Read more
Let’s say I create a semaphore. If I fork a bunch of child processes, will they all still use that same semaphore? If you are using a SysV IPC semaphore (semctl), then yes. If you are using POSIX semaphores (sem_init), then yes, but only if you pass a true value for the pshared argument on … Read more
The problem you are facing is the misunderstanding of sem_init() function. When you read the manual page you will see this: The pshared argument indicates whether this semaphore is to be shared between the threads of a process, or between processes. If you are done reading up to this point, you will think that the … Read more
Barrier #2 guarentees that the write to _complete gets committed immediately. Otherwise it could remain in a queued state meaning that the read of _complete in B would not see the change caused by A even though B effectively used a volatile read. Of course, this example does not quite do justice to the problem … Read more
Boost Interprocess has support for Shared Memory. Boost Lockfree has a Single-Producer Single-Consumer queue type (spsc_queue). This is basically what you refer to as a circular buffer. Here’s a demonstration that passes IPC messages (in this case, of type string) using this queue, in a lock-free fashion. Defining the types First, let’s define our types: … Read more
You can use Memory Mapped Files. Here is an article describing how to use them.