0

I am working in a project which have two different processes.

  • The first process is a cache base on a std::map or std::set which allocate all the data in a share memory region.
  • The second process is a producer/consumer which will have access to the share memory, so whenever it needs some data it will ask through an unix pipe to the cache process the starting address of the shared memory which contain the requested data.

So far, I came up with two approaches, first is changing the allocation function for std::set to always allocate in the shared memory, or maybe in a easier approach storing as the value of the map a pointer to that shared region:

map<key, pointer to share region>

Any idea? :D

Thanks!!

Vicente Bolea
  • 1,409
  • 16
  • 39
  • 1
    There is Boost.Interprocess - http://www.boost.org/doc/libs/1_55_0/doc/html/interprocess/quick_guide.html#interprocess.quick_guide.qg_interprocess_map - maybe it's worth using it. The library also comes with synchronization primitives. We did something similar - Producer -> Consumer via shared memory here and it works fine. – duselbaer Feb 05 '14 at 09:39

1 Answers1

2

In theory, you can use a custom allocator for std::set or std::map to do this. Of course, you'll have to ensure that any contents that might dynamically allocate also use the same custom allocator.

The real problem is that the mapped addresses of the shared memory might not be the same. It's often possible to work around this by using mmap and specifying the address, but the address range must be free in both processes. I've done this under Solaris, which always allocates (or allocated) static and heap at the bottom of the address space, and stack at the top, leaving a big hole in the middle, but even there, I don't think there was any guarantee, and other systems have different policies. Still, if the processes aren't too big otherwise, you may be able to find a solution empirically. (I'd recommend making the address and the size a configuration parameter.)

Alternatively, in theory, the allocator defines a pointer type, which the container should use; you should be able to define a pointer type which works with just the offset into the shared memory. I've no experience with this, however, and I fear that it could be very tricky, since the reference type will still be a true reference (and thus a pointer under the hood), and you cannot change this.

James Kanze
  • 150,581
  • 18
  • 184
  • 329
  • I would consider it a vulnerability if you could know which data is stored at a known memory address of a process. – fex Feb 05 '14 at 11:31
  • @fex It could be. A lot depends on context; if the two processes never access the network, for example, there should be no problem; or if the machine they run on only has very limited access. – James Kanze Feb 05 '14 at 11:50