...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
boost::interprocess::private_node_allocator
// In header: <boost/interprocess/allocators/private_node_allocator.hpp> template<typename T, typename SegmentManager, std::size_t NodesPerBlock> class private_node_allocator { public: // types typedef implementation_defined::segment_manager segment_manager; typedef segment_manager::void_pointer void_pointer; typedef implementation_defined::pointer pointer; typedef implementation_defined::const_pointer const_pointer; typedef T value_type; typedef unspecified reference; typedef unspecified const_reference; typedef segment_manager::size_type size_type; typedef segment_manage::difference_type difference_type; // member classes/structs/unions template<typename T2> struct rebind { // types typedef private_node_allocator< T2, SegmentManager, NodesPerBlock > other; }; // construct/copy/destruct private_node_allocator(segment_manager *); private_node_allocator(const private_node_allocator &); template<typename T2> private_node_allocator(const private_node_allocator< T2, SegmentManager, NodesPerBlock > &); template<typename T2, typename SegmentManager2, std::size_t N2> private_node_allocator& operator=(const private_node_allocator< T2, SegmentManager2, N2 > &); private_node_allocator& operator=(const private_node_allocator &); ~private_node_allocator(); // public member functions node_pool_t * get_node_pool() const; segment_manager * get_segment_manager() const; size_type max_size() const; pointer allocate(size_type, cvoid_pointer = 0); void deallocate(const pointer &, size_type); void deallocate_free_blocks(); pointer address(reference) const; const_pointer address(const_reference) const; void construct(const pointer &, const_reference); void destroy(const pointer &); size_type size(const pointer &) const; std::pair< pointer, bool > allocation_command(boost::interprocess::allocation_type, size_type, size_type, size_type &, const pointer & = 0); multiallocation_chain allocate_many(size_type, size_type); multiallocation_chain allocate_many(const size_type *, size_type); void deallocate_many(multiallocation_chain); pointer allocate_one(); multiallocation_chain allocate_individual(size_type); void deallocate_one(const pointer &); void deallocate_individual(multiallocation_chain); // friend functions friend void swap(self_t &, self_t &); };
An STL node allocator that uses a segment manager as memory source. The internal pointer type will of the same type (raw, smart) as "typename SegmentManager::void_pointer" type. This allows placing the allocator in shared memory, memory mapped-files, etc... This allocator has its own node pool. NodesPerBlock is the number of nodes allocated at once when the allocator needs runs out of nodes
private_node_allocator
public
construct/copy/destructprivate_node_allocator(segment_manager * segment_mngr);
Constructor from a segment manager. If not present, constructs a node pool. Increments the reference count of the associated node pool. Can throw boost::interprocess::bad_alloc
private_node_allocator(const private_node_allocator & other);
Copy constructor from other private_node_allocator
. Increments the reference count of the associated node pool. Never throws
template<typename T2> private_node_allocator(const private_node_allocator< T2, SegmentManager, NodesPerBlock > & other);
Copy constructor from related private_node_allocator
. If not present, constructs a node pool. Increments the reference count of the associated node pool. Can throw boost::interprocess::bad_alloc
template<typename T2, typename SegmentManager2, std::size_t N2> private_node_allocator& operator=(const private_node_allocator< T2, SegmentManager2, N2 > &);
Not assignable from related private_node_allocator
private_node_allocator& operator=(const private_node_allocator &);
Not assignable from other private_node_allocator
~private_node_allocator();
Destructor, removes node_pool_t from memory if its reference count reaches to zero. Never throws
private_node_allocator
public member functionsnode_pool_t * get_node_pool() const;
Returns a pointer to the node pool. Never throws
segment_manager * get_segment_manager() const;
Returns the segment manager. Never throws
size_type max_size() const;
Returns the number of elements that could be allocated. Never throws
pointer allocate(size_type count, cvoid_pointer hint = 0);
Allocate memory for an array of count elements. Throws boost::interprocess::bad_alloc
if there is no enough memory
void deallocate(const pointer & ptr, size_type count);
Deallocate allocated memory. Never throws
void deallocate_free_blocks();
Deallocates all free blocks of the pool
pointer address(reference value) const;
Returns address of mutable object. Never throws
const_pointer address(const_reference value) const;
Returns address of non mutable object. Never throws
void construct(const pointer & ptr, const_reference v);
Copy construct an object. Throws if T's copy constructor throws
void destroy(const pointer & ptr);
Destroys object. Throws if object's destructor throws
size_type size(const pointer & p) const;
Returns maximum the number of objects the previously allocated memory pointed by p can hold. This size only works for memory allocated with allocate, allocation_command and allocate_many.
std::pair< pointer, bool > allocation_command(boost::interprocess::allocation_type command, size_type limit_size, size_type preferred_size, size_type & received_size, const pointer & reuse = 0);
multiallocation_chain allocate_many(size_type elem_size, size_type num_elements);
Allocates many elements of size elem_size in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. The elements must be deallocated with deallocate(...)
multiallocation_chain allocate_many(const size_type * elem_sizes, size_type n_elements);
Allocates n_elements elements, each one of size elem_sizes[i]in a contiguous block of memory. The elements must be deallocated
void deallocate_many(multiallocation_chain chain);
Allocates many elements of size elem_size in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. The elements must be deallocated with deallocate(...)
pointer allocate_one();
Allocates just one object. Memory allocated with this function must be deallocated only with deallocate_one(). Throws boost::interprocess::bad_alloc
if there is no enough memory
multiallocation_chain allocate_individual(size_type num_elements);
Allocates many elements of size == 1 in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. Memory allocated with this function must be deallocated only with deallocate_one().
void deallocate_one(const pointer & p);
Deallocates memory previously allocated with allocate_one(). You should never use deallocate_one to deallocate memory allocated with other functions different from allocate_one(). Never throws
void deallocate_individual(multiallocation_chain chain);
Allocates many elements of size == 1 in a contiguous block of memory. The minimum number to be allocated is min_elements, the preferred and maximum number is preferred_elements. The number of actually allocated elements is will be assigned to received_size. Memory allocated with this function must be deallocated only with deallocate_one().