Question

I know this is strange but I’m just having fun.

I am attempting to transmit a std::map (instantiated using placement new in a fixed region of memory) between two processes via a socket between two machines: Master and Slave. The map I’m using has this typedef:

   // A vector of Page objects
   typedef
      std::vector<Page*,
           PageTableAllocator<Page*> >
      PageVectorType;

   // A mapping of binary 'ip address' to a PageVector
   typedef
      std::map<uint32_t,
           PageVectorType*,
           std::less<uint32_t>,
           PageTableAllocator<std::pair<uint32_t, PageVectorType*> > >
      PageTableType;

The PageTableAllocator<T> class is responsible for allocating whatever memory the STL containers may want/need into a fixed location in memory. E.g., all Page objects and STL internal structures are being instantiated in this fixed memory region. This ensures that both the std::map object and the allocator are both placed in a fixed region of memory. I’ve used GDB to make sure the map and allocator behave correctly (all memory used is in the fixed region, nothing ever goes on the application’s normal heap).

Assuming Master starts up, initializes all of it’s STL structures and the special memory region, the following happens. Slave starts, prints out its version of the page table, then looks for a Master. Slave finds a master, deletes its version of the page table, copies Master‘s version of the page table (and the special memory region), and successfully prints it out the Master‘s version of the page table. From what prodding I’ve done in GDB I can perform many read-only operations.

When trying to add to the newly copied PageTableType object, Slave faults in the allocator’s void construct (pointer p, const T& value) method. The value passed in as p points to an already allocated area of memory (as per Master‘s version of the std::map).

I don’t know anything about C++ object structure, but I’m guessing that object state from Slave‘s version of the PageTableType must be hanging around even after I replace all of the memory that the PageTableType and its allocator used. My question is if this is a valid concern. Does C++ maintain some sort of object state outside of the area of memory that object was instantiate din?

All of the objects used in the map are non-POD. Same is true for the allocator.

Answer 1

To answer your specific question:

Does C++ maintain some sort of object state outside of the area of memory that object was instantiated in?

The answer is no. There are no other data structures set up to “track” objects or anything of the sort. C++ uses an explicit memory allocation model, so if you choose to be responsible for allocation and deallocation, then you have complete control.

I suspect there’s something wrong in your code somewhere, but since you believe the code is correct you’re inventing some other reason why your code might be failing, and following that path instead. I would pull back, and carefully examine everything about the way your code is working right now, and see if you can determine the problem. Although the STL classes are complex (especially std::map), they’re ultimately just code and there is no hidden magic in there.