Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Class template adaptive_pool

boost::container::adaptive_pool

Synopsis

// In header: <boost/container/adaptive_pool.hpp>

template<typename T,  NodesPerBlock = , 
          MaxFreeBlocks = , 
          OverheadPercent = > 
class adaptive_pool {
public:
  // types
  typedef                                                                                                    ;
  typedef adaptive_pool<  ;         
  typedef                                                                                                               ;     
  typedef                                                                                                             ;        
  typedef                                                                                                       ;  
  typedef ::                                                                 ;      
  typedef ::                                                            ;
  typedef                                                                                                     ;      
  typedef                                                                                                  ;
  typedef self_t,                                                          ;        

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

  // public member functions
   ();
  () ;
  (adaptive_pool &) ;
  adaptive_pool & (adaptive_pool &) ;
  template<typename T2> 
    (adaptive_pool< ) ;
  ~() ;
   () ;
   (,  = );
   (, ) ;
   (, , , 
                             );
   () ;
   ();
   (, );
   () ;
   () ;
   (, , );
   (, , );
   () ;

  // public static functions
   () ;

  // friend functions
   (adaptive_pool &, adaptive_pool &) ;
   (adaptive_pool &, adaptive_pool &) ;
   (adaptive_pool &, adaptive_pool &) ;

  // private member functions
   (, , , 
                                  );

  // public data members
   nodes_per_block;
   max_free_blocks;
   overhead_percent;
   real_nodes_per_block;
};

Description

An STL node allocator that uses a modified DLMalloc as memory source.

This node allocator shares a segregated storage between all instances of adaptive_pool with equal sizeof(T).

NodesPerBlock is the number 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 to the memory manager.

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

adaptive_pool public types

  1. typedef ;

    If Version is 1, the allocator is a STL conforming allocator. If Version is 2, the allocator offers advanced expand in place and burst allocation capabilities.

adaptive_pool public member functions

  1.  ();
  2. () ;
    Default constructor.
  3. (adaptive_pool &) ;
    Copy constructor from other adaptive_pool.
  4. adaptive_pool & (adaptive_pool &) ;
    Copy assignment from other adaptive_pool.
  5. template<typename T2> 
      (adaptive_pool< ) ;
    Copy constructor from related adaptive_pool.
  6. ~() ;
    Destructor.
  7.  () ;

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

  8.  ( count,  = );

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

  9.  ( ptr,  count) ;

    Deallocate allocated memory. Never throws

  10.  ( command,  limit_size, 
                                prefer_in_recvd_out_size, 
                                reuse);
  11.  ( p) ;

    Returns maximum the number of objects the previously allocated memory pointed by p can hold.

  12.  ();

    Allocates just one object. Memory allocated with this function must be deallocated only with deallocate_one(). Throws bad_alloc if there is no enough memory

  13.  ( num_elements, 
                              chain);

    Allocates many elements of size == 1. Elements must be individually deallocated with deallocate_one()

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

  15.  ( chain) ;
  16.  ( elem_size,  n_elements, 
                        chain);

    Allocates many elements of size elem_size. Elements must be individually deallocated with deallocate()

  17.  ( elem_sizes,  n_elements, 
                        chain);

    Allocates n_elements elements, each one of size elem_sizes[i] Elements must be individually deallocated with deallocate()

  18.  ( chain) ;

adaptive_pool public static functions

  1.  () ;
    Deallocates all free blocks of the pool.

adaptive_pool friend functions

  1.  (adaptive_pool &, adaptive_pool &) ;

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

  2.  (adaptive_pool &, adaptive_pool &) ;

    An allocator always compares to true, as memory allocated with one instance can be deallocated by another instance

  3.  (adaptive_pool &, adaptive_pool &) ;

    An allocator always compares to false, as memory allocated with one instance can be deallocated by another instance

adaptive_pool private member functions

  1.  ( command, 
                                     limit_size, 
                                     prefer_in_recvd_out_size, 
                                     reuse_ptr);

PrevUpHomeNext