I would like to create a std::vector in shared memory using the CreateFileMapping() windows API function. I know how to create shared memory and manage it, but how do I assign std::vector to a fixed address in memory?
I cannot use boost or other libraries in my case, I am using CBuilder++ 2010.
One variant I think is maybe to use
std::vector<int> myVec;
myVec *mv;
mv = shared_memory_addr ?
But how do I detect the real size of vectors to resize memory?
I'd use Boost.Interprocess, which has an explanation of how to do just this: http://www.boost.org/doc/libs/1_38_0/doc/html/interprocess/quick_guide.html#interprocess.quick_guide.qg_interprocess_container
Note that this does not use std::vector<>, which is not suitable for shared-memory use, because it is typically implemented in terms of three pointers (begin, end, capacity, or some equivalents), and addresses will differ between processes. So Boost.Interprocess has its own vector class, which is purpose-built for what you are trying to do.
Actually, you have to do both: use placement new to construct the std::vector instance in shared memory AND use a custom allocator to make the vector place its data within the shared memory as well.
Keep in mind that you need to synchronize any access to the vector (except if you need only read access) - std::vector is not generally thread-safe and doesn't declare any of its members volatile, which makes simultaneous access out of the compiler's scope - as it happens in a shared memory region - extremely dangerous.
... after all, I wouldn't do it. Shared memory is a very low-level, very tricky concept, it doesn't fit well with high-level data containers such as std::vector, in a language that (as of cpp03) doesn't provide good builtin solutions for concurrency problems and that is not aware that something like shared memory exists.
... it might even trigger undefined behaviour: while std::vector generally uses its allocator to fetch storage for its elements, it is (as far as I know) allowed to allocate further memory (i.e. for internal purposes, whatever that may be) using malloc or any other allocation strategy (I think Microsoft's std::vector implementation does that in debug builds) ... these pointers would only be valid for one side of the memory mapping.
To avoid the std::vector, I'd simply allocate sufficient memory in the mapped range upfront and use a simple counter to keep the number of valid elements. That should be safe.
You need to implement your own allocator to achieve that. The allocator is a std::vector<> template parameter.
Use placement new to construct a vector in shared memory. You will also need an allocator for the vector so that it can use shared memory for its element storage. If the vector is just storing int, and you can put the shared memory section at the same virtual address in each process, this just might work.
You could use shared memory, mapped at a fixed address, i.e., the address would be the same in each process allowing using raw pointers.
So if you do something like the following, you can have (multiple) regions of shared memory:
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
struct MySegment {
static const size_t alloc_size = 1048576;
static const void *getAddr() { return (void *)0x400000000LL; }
static const char *getSegmentName() { return "MySegment"; }
};
template <typename MemorySegment>
class SharedMemory {
public:
typedef boost::interprocess::fixed_managed_shared_memory shared_memory_t;
typedef shared_memory_t::segment_manager segment_manager_t;
static shared_memory_t *getSegment() {
if (!segment) {
assert(MemorySegment::getAddr() != 0 && "want a fixed address for all processes");
segment = new boost::interprocess::managed_shared_memory(
boost::interprocess::open_or_create,
MemorySegment::getSegmentName(),
MemorySegment::alloc_size,
MemorySegment::getAddr());
}
return segment;
}
static segment_manager_t *getSegmentManager() {
return getSegment()->get_segment_manager(); }
private:
static boost::interprocess::managed_shared_memory *segment;
};
template <typename MemorySegment>
typename SharedMemory<MemorySegment>::shared_memory_t *SharedMemory<MemorySegment>::segment = NULL;
template <class MemorySegment, class T>
class SharedMemoryAllocator {
public:
typedef boost::interprocess::allocator<T, typename SharedMemory<MemorySegment>::segment_manager_t> InterprocessAllocator;
// Delegate all calls to an instance of InterprocessAllocator,
pointer allocate(size_type n, const void *hint = 0) { return TempAllocator().allocate(n, hint); }
void deallocate(const pointer &p, size_type n) { return TempAllocator().deallocate(p, n); }
size_type max_size() const { return TempAllocator().max_size(); }
void construct(const pointer &ptr, const_reference v) { return TempAllocator().construct(ptr, v); }
void destroy(const pointer &ptr) { return TempAllocator().destroy(ptr); }
typedef typename InterprocessAllocator::value_type value_type;
typedef typename InterprocessAllocator::pointer pointer;
typedef typename InterprocessAllocator::reference reference;
typedef typename InterprocessAllocator::const_pointer const_pointer;
typedef typename InterprocessAllocator::const_reference const_reference;
typedef typename InterprocessAllocator::size_type size_type;
typedef typename InterprocessAllocator::difference_type difference_type;
SharedMemoryAllocator() {}
template <class U> SharedMemoryAllocator(const SharedMemoryAllocator<MemorySegment, U> &u) {}
template <typename OtherT> struct rebind { typedef SharedMemoryAllocator<MemorySegment, OtherT> other; };
private:
static InterprocessAllocator TempAllocator() {
return InterprocessAllocator(SharedMemory<MemorySegment>::getSegmentManager());
}
};
Then, you could use:
std::vector<int, SharedMemoryAllocator<MySegment, int> vec;
and the vector's elements would be put in shared memory (of course, vec will also have to be allocated there).
