Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Class template cached_adaptive_pool

boost::interprocess::cached_adaptive_pool

Synopsis

// In header: <boost/interprocess/allocators/cached_adaptive_pool.hpp>

template<typename T, typename SegmentManager,  NodesPerBlock, 
          MaxFreeBlocks,  OverheadPercent> 
class cached_adaptive_pool {
public:
  // types
  typedef  ;
  typedef            ;   
  typedef          ;        
  typedef    ;  
  typedef                                        ;     
  typedef                              ;      
  typedef                              ;
  typedef               ;      
  typedef         ;

  // member classes/structs/unions
  template<typename T2> 
  struct rebind {
    // types
    typedef cached_adaptive_pool<  ;
  };

  // construct/copy/destruct
  ();
  (cached_adaptive_pool &);
  template<typename T2> 
    (cached_adaptive_pool< );
  template<typename T2, typename SegmentManager2,  N2, 
            F2,  OP2> 
    cached_adaptive_pool & 
    (cached_adaptive_pool< );
  cached_adaptive_pool & (cached_adaptive_pool &);
  ~();

  // public member functions
   () ;
   () ;
   () ;
   (,  = );
   (, );
   ();
   () ;
   () ;
   (, );
   ();
   () ;
   (, , 
                             , );
   (, , );
   (, , );
   ();
   ();
   ();
   ();
   ();
   ();
   () ;

  // friend functions
   (, );
};

Description

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 node allocator shares a segregated storage between all instances of cached_adaptive_pool with equal sizeof(T) placed in the same memory segment. But also caches some nodes privately to avoid some synchronization overhead.

NodesPerBlock is the minimum number of nodes of nodes allocated at once when the allocator needs runs out of nodes. MaxFreeBlocks is the maximum number of totally free blocks that the adaptive node pool will hold. The rest of the totally free blocks will be deallocated with the segment manager.

OverheadPercent is the (approximated) maximum size overhead (1-20%) of the allocator: (memory usable for nodes / total memory allocated from the segment manager)

cached_adaptive_pool public construct/copy/destruct

  1. ( 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

  2. (cached_adaptive_pool & other);

    Copy constructor from other cached_adaptive_pool. Increments the reference count of the associated node pool. Never throws

  3. template<typename T2> 
      (cached_adaptive_pool<  other);

    Copy constructor from related cached_adaptive_pool. If not present, constructs a node pool. Increments the reference count of the associated node pool. Can throw boost::interprocess::bad_alloc

  4. template<typename T2, typename SegmentManager2,  N2, 
              F2,  OP2> 
      cached_adaptive_pool & 
      (cached_adaptive_pool< );

    Not assignable from related cached_adaptive_pool

  5. cached_adaptive_pool & (cached_adaptive_pool &);

    Not assignable from other cached_adaptive_pool

  6. ~();

    Destructor, removes node_pool_t from memory if its reference count reaches to zero. Never throws

cached_adaptive_pool public member functions

  1.  () ;

    Returns a pointer to the node pool. Never throws

  2.  () ;

    Returns the segment manager. Never throws

  3.  () ;

    Returns the number of elements that could be allocated. Never throws

  4.  ( count,  hint = );

    Allocate memory for an array of count elements. Throws boost::interprocess::bad_alloc if there is no enough memory

  5.  ( ptr,  count);

    Deallocate allocated memory. Never throws

  6.  ();

    Deallocates all free blocks of the pool

  7.  ( value) ;

    Returns address of mutable object. Never throws

  8.  ( value) ;

    Returns address of non mutable object. Never throws

  9.  ( ptr,  v);

    Copy construct an object. Throws if T's copy constructor throws

  10.  ( ptr);

    Destroys object. Throws if object's destructor throws

  11.  ( p) ;

    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.

  12.  ( command, 
                                limit_size, 
                                prefer_in_recvd_out_size, 
                                reuse);
  13.  ( elem_size,  num_elements, 
                        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(...)

  14.  ( elem_sizes,  n_elements, 
                        chain);

    Allocates n_elements elements, each one of size elem_sizes[i]in a contiguous block of memory. The elements must be deallocated

  15.  ( 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(...)

  16.  ();

    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

  17.  ( 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().

  18.  ( 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

  19.  ( 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().

  20.  ( newmax);

    Sets the new max cached nodes value. This can provoke deallocations if "newmax" is less than current cached nodes. Never throws

  21.  () ;

    Returns the max cached nodes parameter. Never throws

cached_adaptive_pool friend functions

  1.  ( alloc1,  alloc2);

    Swaps allocators. Does not throw. If each allocator is placed in a different memory segment, the result is undefined.


PrevUpHomeNext