passenger 6.0.2 → 6.0.3

data/src/cxx_supportlib/vendor-modified/boost/container/allocator.hpp

@@ -284,7 +284,7 @@ class allocator
    //!This function is available only with Version == 2
    void allocate_many(size_type elem_size, std::size_t n_elements, multiallocation_chain &chain)
    {
-      BOOST_STATIC_ASSERT(( Version > 1 ));/*
+      BOOST_STATIC_ASSERT(( Version > 1 ));
       dlmalloc_memchain ch;
       BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
       if(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){
@@ -293,10 +293,11 @@ class allocator
       chain.incorporate_after(chain.before_begin()
                              ,(T*)BOOST_CONTAINER_MEMCHAIN_FIRSTMEM(&ch)
                              ,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
-                             ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );*/
+                             ,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );
+/*
       if(!dlmalloc_multialloc_nodes(n_elements, elem_size*sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain))){
          boost::container::throw_bad_alloc();
-      }
+      }*/
    }
 
    //!Allocates n_elements elements, each one of size elem_sizes[i]

data/src/cxx_supportlib/vendor-modified/boost/container/allocator_traits.hpp

@@ -151,7 +151,7 @@ struct allocator_traits
       //! Allocator::void_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<void>.
       //!
       typedef see_documentation void_pointer;
-      //! Allocator::const_void_pointer if such a type exists ; otherwis e, pointer_traits<pointer>::rebind<const
+      //! Allocator::const_void_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<const
       //!
       typedef see_documentation const_void_pointer;
       //! Allocator::difference_type if such a type exists ; otherwise, pointer_traits<pointer>::difference_type.

data/src/cxx_supportlib/vendor-modified/boost/container/deque.hpp

@@ -2238,6 +2238,13 @@ class deque : protected deque_base<Allocator>
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+template <typename InputIterator>
+deque(InputIterator, InputIterator) -> deque<typename iterator_traits<InputIterator>::value_type>;
+template <typename InputIterator, typename Allocator>
+deque(InputIterator, InputIterator, Allocator const&) -> deque<typename iterator_traits<InputIterator>::value_type, Allocator>;
+#endif
+
 }}
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

data/src/cxx_supportlib/vendor-modified/boost/container/detail/adaptive_node_pool.hpp

@@ -39,17 +39,6 @@ namespace boost {
 namespace container {
 namespace dtl {
 
-template<bool AlignOnly>
-struct select_private_adaptive_node_pool_impl
-{
-   typedef boost::container::dtl::
-         private_adaptive_node_pool_impl
-            < fake_segment_manager
-            , unsigned(AlignOnly)*::boost::container::adaptive_pool_flag::align_only
-            | ::boost::container::adaptive_pool_flag::size_ordered | ::boost::container::adaptive_pool_flag::address_ordered
-            > type;
-};
-
 //!Pooled memory allocator using an smart adaptive pool. Includes
 //!a reference count but the class does not delete itself, this is
 //!responsibility of user classes. Node size (NodeSize) and the number of
@@ -60,24 +49,38 @@ template< std::size_t NodeSize
         , std::size_t OverheadPercent
         >
 class private_adaptive_node_pool
-   :  public select_private_adaptive_node_pool_impl<(OverheadPercent == 0)>::type
+   :  public private_adaptive_node_pool_impl_ct
+            < fake_segment_manager
+            , MaxFreeBlocks
+            , NodeSize
+            , NodesPerBlock
+            , OverheadPercent
+            , unsigned(OverheadPercent == 0)*::boost::container::adaptive_pool_flag::align_only
+               | ::boost::container::adaptive_pool_flag::size_ordered
+               | ::boost::container::adaptive_pool_flag::address_ordered
+            >
 {
-   typedef typename select_private_adaptive_node_pool_impl<OverheadPercent == 0>::type base_t;
+   typedef private_adaptive_node_pool_impl_ct
+            < fake_segment_manager
+            , MaxFreeBlocks
+            , NodeSize
+            , NodesPerBlock
+            , OverheadPercent
+            , unsigned(OverheadPercent == 0)*::boost::container::adaptive_pool_flag::align_only
+               | ::boost::container::adaptive_pool_flag::size_ordered
+               | ::boost::container::adaptive_pool_flag::address_ordered
+            > base_t;
+
    //Non-copyable
    private_adaptive_node_pool(const private_adaptive_node_pool &);
    private_adaptive_node_pool &operator=(const private_adaptive_node_pool &);
 
    public:
-   typedef typename base_t::multiallocation_chain multiallocation_chain;
    static const std::size_t nodes_per_block = NodesPerBlock;
 
    //!Constructor. Never throws
    private_adaptive_node_pool()
-      :  base_t(0
-               , NodeSize
-               , NodesPerBlock
-               , MaxFreeBlocks
-               , (unsigned char)OverheadPercent)
+      : base_t(0)
    {}
 };
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/adaptive_node_pool_impl.hpp

@@ -87,7 +87,7 @@ template<class SizeType>
 struct less_func<SizeType, adaptive_pool_flag::address_ordered>
 {
    static bool less(SizeType, SizeType, const void *la, const void *ra)
-   {  return &la < &ra;   }
+   {  return la < ra;   }
 };
 
 template<class SizeType>
@@ -97,7 +97,7 @@ struct less_func<SizeType, adaptive_pool_flag::size_ordered | adaptive_pool_flag
    {  return (ls < rs) || ((ls == rs) && (la < ra));  }
 };
 
-template<class VoidPointer, class SizeType, bool ordered>
+template<class VoidPointer, class SizeType, unsigned OrderFlags>
 struct block_container_traits
 {
    typedef typename bi::make_set_base_hook
@@ -116,11 +116,21 @@ struct block_container_traits
    static void reinsert_was_used(Container &container, typename Container::reference v, bool)
    {
       typedef typename Container::const_iterator const_block_iterator;
-      const const_block_iterator this_block
-         (Container::s_iterator_to(const_cast<typename Container::const_reference>(v)));
-      const_block_iterator next_block(this_block);
-      if(++next_block != container.cend()){
-         if(this_block->free_nodes.size() > next_block->free_nodes.size()){
+      typedef typename Container::iterator       block_iterator;
+      typedef typename Container::value_compare  value_compare;
+
+      const block_iterator this_block(Container::s_iterator_to(v));
+      const const_block_iterator cendit(container.cend());
+      block_iterator next_block(this_block);
+
+      if(++next_block != cendit && value_compare()(*next_block, v)){
+         const_block_iterator next2_block(next_block);
+         //Test if v should be swapped with next (optimization)
+         if(++next2_block == cendit || !value_compare()(*next2_block, v)){
+            v.swap_nodes(*next_block);
+            BOOST_ASSERT(++next_block == this_block);
+         }
+         else{
             container.erase(this_block);
             container.insert(v);
          }
@@ -147,7 +157,7 @@ struct block_container_traits
 };
 
 template<class VoidPointer, class SizeType>
-struct block_container_traits<VoidPointer, SizeType, false>
+struct block_container_traits<VoidPointer, SizeType, 0u>
 {
    typedef typename bi::make_list_base_hook
       < bi::void_pointer<VoidPointer>
@@ -193,11 +203,16 @@ struct block_container_traits<VoidPointer, SizeType, false>
    }
 };
 
+/////////////////////////////
+//
+//    adaptive_pool_types
+//
+/////////////////////////////
 template<class MultiallocationChain, class VoidPointer, class SizeType, unsigned int Flags>
 struct adaptive_pool_types
 {
    typedef VoidPointer void_pointer;
-   static const bool ordered = (Flags & (adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered)) != 0;
+   static const unsigned ordered = (Flags & (adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered));
    typedef block_container_traits<VoidPointer, SizeType, ordered> block_container_traits_t;
    typedef typename block_container_traits_t::hook_t hook_t;
    typedef hdr_offset_holder_t<SizeType> hdr_offset_holder;
@@ -222,95 +237,210 @@ struct adaptive_pool_types
    typedef typename block_container_traits_t:: template container<block_info_t>::type  block_container_t;
 };
 
-template<class size_type>
-inline size_type calculate_alignment
-   ( size_type overhead_percent, size_type real_node_size
-   , size_type hdr_size, size_type hdr_offset_size, size_type payload_per_allocation)
+
+/////////////////////////////////////////////
+//
+//       candidate_power_of_2_ct
+//
+/////////////////////////////////////////////
+template< std::size_t alignment
+        , std::size_t real_node_size
+        , std::size_t payload_per_allocation
+        , std::size_t min_elements_per_block
+        , std::size_t hdr_size
+        , std::size_t hdr_offset_size
+        , std::size_t overhead_percent>
+struct candidate_power_of_2_ct_helper
 {
-   //to-do: handle real_node_size != node_size
-   const size_type divisor  = overhead_percent*real_node_size;
-   const size_type dividend = hdr_offset_size*100;
-   size_type elements_per_subblock = (dividend - 1)/divisor + 1;
-   size_type candidate_power_of_2 =
-      upper_power_of_2(elements_per_subblock*real_node_size + hdr_offset_size);
-   bool overhead_satisfied = false;
-   //Now calculate the wors-case overhead for a subblock
-   const size_type max_subblock_overhead  = hdr_size + payload_per_allocation;
-   while(!overhead_satisfied){
-      elements_per_subblock = (candidate_power_of_2 - max_subblock_overhead)/real_node_size;
-      const size_type overhead_size = candidate_power_of_2 - elements_per_subblock*real_node_size;
-      if(overhead_size*100/candidate_power_of_2 < overhead_percent){
-         overhead_satisfied = true;
-      }
-      else{
-         candidate_power_of_2 <<= 1;
-      }
-   }
-   return candidate_power_of_2;
-}
+   static const std::size_t hdr_subblock_elements_alone = (alignment - hdr_size - payload_per_allocation)/real_node_size;
+   static const std::size_t hdr_subblock_elements_first = (alignment - hdr_size - payload_per_allocation)/real_node_size;
+   static const std::size_t elements_per_b_subblock_mid = (alignment - hdr_offset_size)/real_node_size;
+   static const std::size_t elements_per_b_subblock_end = (alignment - hdr_offset_size - payload_per_allocation)/real_node_size;
+   static const std::size_t num_b_subblock =
+      hdr_subblock_elements_alone >= min_elements_per_block
+         ? 0
+         : (   ((hdr_subblock_elements_first + elements_per_b_subblock_end) >= min_elements_per_block)
+               ? 1
+               : 2 + (min_elements_per_block - hdr_subblock_elements_first - elements_per_b_subblock_end - 1)/elements_per_b_subblock_mid
+            )
+         ;
+
+   static const std::size_t num_b_subblock_mid = (num_b_subblock > 1) ? (num_b_subblock - 1) : 0;
+
+   static const std::size_t total_nodes = (num_b_subblock == 0)
+                                         ? hdr_subblock_elements_alone
+                                         : ( (num_b_subblock == 1)
+                                           ? (hdr_subblock_elements_first + elements_per_b_subblock_end)
+                                           : (hdr_subblock_elements_first + num_b_subblock_mid*elements_per_b_subblock_mid + elements_per_b_subblock_end)
+                                           )
+                                         ;
+   static const std::size_t total_data = total_nodes*real_node_size;
+   static const std::size_t total_size = alignment*(num_b_subblock+1);
+   static const bool overhead_satisfied = (total_size - total_data)*100/total_size < overhead_percent;
+};
 
-template<class size_type>
-inline void calculate_num_subblocks
-   (size_type alignment, size_type real_node_size, size_type elements_per_block
-   , size_type &num_subblocks, size_type &real_num_node, size_type overhead_percent
-   , size_type hdr_size, size_type hdr_offset_size, size_type payload_per_allocation)
+template< std::size_t initial_alignment
+        , std::size_t real_node_size
+        , std::size_t payload_per_allocation
+        , std::size_t min_elements_per_block
+        , std::size_t hdr_size
+        , std::size_t hdr_offset_size
+        , std::size_t overhead_percent
+        , bool Loop = true>
+struct candidate_power_of_2_ct
+{
+   typedef candidate_power_of_2_ct_helper
+        < initial_alignment
+        , real_node_size
+        , payload_per_allocation
+        , min_elements_per_block
+        , hdr_size
+        , hdr_offset_size
+        , overhead_percent> helper_t;
+
+   static const std::size_t candidate_power_of_2 = initial_alignment << std::size_t(!helper_t::overhead_satisfied);
+
+   typedef typename candidate_power_of_2_ct
+      < candidate_power_of_2
+      , real_node_size
+      , payload_per_allocation
+      , min_elements_per_block
+      , hdr_size
+      , hdr_offset_size
+      , overhead_percent
+      , !helper_t::overhead_satisfied
+      >::type type;
+
+   static const std::size_t alignment     = type::alignment;
+   static const std::size_t num_subblocks = type::num_subblocks;
+   static const std::size_t real_num_node = type::real_num_node;
+};
+
+template< std::size_t initial_alignment
+        , std::size_t real_node_size
+        , std::size_t payload_per_allocation
+        , std::size_t min_elements_per_block
+        , std::size_t hdr_size
+        , std::size_t hdr_offset_size
+        , std::size_t overhead_percent
+        >
+struct candidate_power_of_2_ct
+      < initial_alignment
+      , real_node_size
+      , payload_per_allocation
+      , min_elements_per_block
+      , hdr_size
+      , hdr_offset_size
+      , overhead_percent
+      , false>
+{
+   typedef candidate_power_of_2_ct
+      < initial_alignment
+      , real_node_size
+      , payload_per_allocation
+      , min_elements_per_block
+      , hdr_size
+      , hdr_offset_size
+      , overhead_percent
+      , false> type;
+
+   typedef candidate_power_of_2_ct_helper
+        < initial_alignment
+        , real_node_size
+        , payload_per_allocation
+        , min_elements_per_block
+        , hdr_size
+        , hdr_offset_size
+        , overhead_percent> helper_t;
+
+   static const std::size_t alignment = initial_alignment;
+   static const std::size_t num_subblocks = helper_t::num_b_subblock+1;
+   static const std::size_t real_num_node = helper_t::total_nodes;
+};
+
+/////////////////////////////////////////////
+//
+//       candidate_power_of_2_rt
+//
+/////////////////////////////////////////////
+inline void candidate_power_of_2_rt ( std::size_t initial_alignment
+                                    , std::size_t real_node_size
+                                    , std::size_t payload_per_allocation
+                                    , std::size_t min_elements_per_block
+                                    , std::size_t hdr_size
+                                    , std::size_t hdr_offset_size
+                                    , std::size_t overhead_percent
+                                    , std::size_t &alignment
+                                    , std::size_t &num_subblocks
+                                    , std::size_t &real_num_node)
 {
-   const size_type hdr_subblock_elements = (alignment - hdr_size - payload_per_allocation)/real_node_size;
-   size_type elements_per_subblock = (alignment - hdr_offset_size)/real_node_size;
-   size_type possible_num_subblock = (elements_per_block - 1)/elements_per_subblock + 1;
-   while(((possible_num_subblock-1)*elements_per_subblock + hdr_subblock_elements) < elements_per_block){
-      ++possible_num_subblock;
-   }
-   elements_per_subblock = (alignment - hdr_offset_size)/real_node_size;
    bool overhead_satisfied = false;
-   while(!overhead_satisfied){
-      const size_type total_data = (elements_per_subblock*(possible_num_subblock-1) + hdr_subblock_elements)*real_node_size;
-      const size_type total_size = alignment*possible_num_subblock;
-      if((total_size - total_data)*100/total_size < overhead_percent){
-         overhead_satisfied = true;
-      }
-      else{
-         ++possible_num_subblock;
-      }
+   std::size_t num_b_subblock = 0;
+   std::size_t total_nodes = 0;
+
+   while(!overhead_satisfied)
+   {
+      std::size_t hdr_subblock_elements_alone = (initial_alignment - hdr_size - payload_per_allocation)/real_node_size;
+      std::size_t hdr_subblock_elements_first = (initial_alignment - hdr_size - payload_per_allocation)/real_node_size;
+      std::size_t elements_per_b_subblock_mid = (initial_alignment - hdr_offset_size)/real_node_size;
+      std::size_t elements_per_b_subblock_end = (initial_alignment - hdr_offset_size - payload_per_allocation)/real_node_size;
+
+      num_b_subblock =
+         hdr_subblock_elements_alone >= min_elements_per_block
+            ? 0
+            : (   ((hdr_subblock_elements_first + elements_per_b_subblock_end) >= min_elements_per_block)
+                  ? 1
+                  : 2 + (min_elements_per_block - hdr_subblock_elements_first - elements_per_b_subblock_end - 1)/elements_per_b_subblock_mid
+               )
+            ;
+
+      std::size_t num_b_subblock_mid = (num_b_subblock > 1) ? (num_b_subblock - 1) : 0;
+
+      total_nodes = (num_b_subblock == 0)
+                                          ? hdr_subblock_elements_alone
+                                          : ( (num_b_subblock == 1)
+                                             ? (hdr_subblock_elements_first + elements_per_b_subblock_end)
+                                             : (hdr_subblock_elements_first + num_b_subblock_mid*elements_per_b_subblock_mid + elements_per_b_subblock_end)
+                                             )
+                                          ;
+      std::size_t total_data = total_nodes*real_node_size;
+      std::size_t total_size = initial_alignment*(num_b_subblock+1);
+      overhead_satisfied = (total_size - total_data)*100/total_size < overhead_percent;
+      initial_alignment = initial_alignment << std::size_t(!overhead_satisfied);
    }
-   num_subblocks = possible_num_subblock;
-   real_num_node = (possible_num_subblock-1)*elements_per_subblock + hdr_subblock_elements;
+   alignment     = initial_alignment;
+   num_subblocks = num_b_subblock+1;
+   real_num_node = total_nodes;
 }
 
-template<class SegmentManagerBase, unsigned int Flags>
-class private_adaptive_node_pool_impl
+/////////////////////////////////////////////
+//
+// private_adaptive_node_pool_impl_common
+//
+/////////////////////////////////////////////
+template< class SegmentManagerBase, unsigned int Flags>
+class private_adaptive_node_pool_impl_common
 {
-   //Non-copyable
-   private_adaptive_node_pool_impl();
-   private_adaptive_node_pool_impl(const private_adaptive_node_pool_impl &);
-   private_adaptive_node_pool_impl &operator=(const private_adaptive_node_pool_impl &);
-   typedef private_adaptive_node_pool_impl this_type;
-
-   typedef typename SegmentManagerBase::void_pointer void_pointer;
-   static const typename SegmentManagerBase::
-      size_type PayloadPerAllocation = SegmentManagerBase::PayloadPerAllocation;
+   public:
+   //!Segment manager typedef
+   typedef SegmentManagerBase                                        segment_manager_base_type;
+   typedef typename SegmentManagerBase::multiallocation_chain        multiallocation_chain;
+   typedef typename SegmentManagerBase::size_type                    size_type;
    //Flags
    //align_only
    static const bool AlignOnly      = (Flags & adaptive_pool_flag::align_only) != 0;
    typedef bool_<AlignOnly>            IsAlignOnly;
    typedef true_                       AlignOnlyTrue;
    typedef false_                      AlignOnlyFalse;
-   //size_ordered
-   static const bool SizeOrdered    = (Flags & adaptive_pool_flag::size_ordered) != 0;
-   typedef bool_<SizeOrdered>          IsSizeOrdered;
-   typedef true_                       SizeOrderedTrue;
-   typedef false_                      SizeOrderedFalse;
-   //address_ordered
-   static const bool AddressOrdered = (Flags & adaptive_pool_flag::address_ordered) != 0;
-   typedef bool_<AddressOrdered>       IsAddressOrdered;
-   typedef true_                       AddressOrderedTrue;
-   typedef false_                      AddressOrderedFalse;
 
-   public:
-   typedef typename SegmentManagerBase::multiallocation_chain        multiallocation_chain;
-   typedef typename SegmentManagerBase::size_type                    size_type;
+   typedef typename SegmentManagerBase::void_pointer void_pointer;
+   static const typename SegmentManagerBase::
+      size_type PayloadPerAllocation = SegmentManagerBase::PayloadPerAllocation;
 
-   private:
+   typedef typename boost::intrusive::pointer_traits
+      <void_pointer>::template rebind_pointer<segment_manager_base_type>::type   segment_mngr_base_ptr_t;
+
+   protected:
    typedef adaptive_pool_types
       <multiallocation_chain, void_pointer, size_type, Flags>        adaptive_pool_types_t;
    typedef typename adaptive_pool_types_t::free_nodes_t              free_nodes_t;
@@ -320,70 +450,285 @@ class private_adaptive_node_pool_impl
    typedef typename block_container_t::iterator                      block_iterator;
    typedef typename block_container_t::const_iterator                const_block_iterator;
    typedef typename adaptive_pool_types_t::hdr_offset_holder         hdr_offset_holder;
+   typedef private_adaptive_node_pool_impl_common                    this_type;
 
    static const size_type MaxAlign = alignment_of<void_pointer>::value;
    static const size_type HdrSize  = ((sizeof(block_info_t)-1)/MaxAlign+1)*MaxAlign;
    static const size_type HdrOffsetSize = ((sizeof(hdr_offset_holder)-1)/MaxAlign+1)*MaxAlign;
 
-   public:
-   //!Segment manager typedef
-   typedef SegmentManagerBase                 segment_manager_base_type;
+   segment_mngr_base_ptr_t             mp_segment_mngr_base;   //Segment manager
+   block_container_t                   m_block_container;      //Intrusive block list
+   size_type                           m_totally_free_blocks;  //Free blocks
 
-   //!Constructor from a segment manager. Never throws
-   private_adaptive_node_pool_impl
-      ( segment_manager_base_type *segment_mngr_base
-      , size_type node_size
-      , size_type nodes_per_block
-      , size_type max_free_blocks
-      , unsigned char overhead_percent
-      )
-   :  m_max_free_blocks(max_free_blocks)
-   ,  m_real_node_size(lcm(node_size, size_type(alignment_of<void_pointer>::value)))
-      //Round the size to a power of two value.
-      //This is the total memory size (including payload) that we want to
-      //allocate from the general-purpose allocator
-   ,  m_real_block_alignment
-         (AlignOnly ?
-            upper_power_of_2(HdrSize + m_real_node_size*nodes_per_block) :
-            calculate_alignment( (size_type)overhead_percent, m_real_node_size
-                               , HdrSize, HdrOffsetSize, PayloadPerAllocation))
-      //This is the real number of nodes per block
-   ,  m_num_subblocks(0)
-   ,  m_real_num_node(AlignOnly ? (m_real_block_alignment - PayloadPerAllocation - HdrSize)/m_real_node_size : 0)
-      //General purpose allocator
-   ,  mp_segment_mngr_base(segment_mngr_base)
-   ,  m_block_container()
-   ,  m_totally_free_blocks(0)
+   class block_destroyer;
+   friend class block_destroyer;
+
+   class block_destroyer
+   {
+      public:
+      block_destroyer(const this_type *impl, multiallocation_chain &chain, const size_type num_subblocks, const size_type real_block_alignment, const size_type real_num_node)
+         :  mp_impl(impl), m_chain(chain), m_num_subblocks(num_subblocks), m_real_block_alignment(real_block_alignment), m_real_num_node(real_num_node)
+      {}
+
+      void operator()(typename block_container_t::pointer to_deallocate)
+      {  return this->do_destroy(to_deallocate, IsAlignOnly()); }
+
+      private:
+      void do_destroy(typename block_container_t::pointer to_deallocate, AlignOnlyTrue)
+      {
+         BOOST_ASSERT(to_deallocate->free_nodes.size() == m_real_num_node);
+         m_chain.push_back(to_deallocate);
+      }
+
+      void do_destroy(typename block_container_t::pointer to_deallocate, AlignOnlyFalse)
+      {
+         BOOST_ASSERT(to_deallocate->free_nodes.size() == m_real_num_node);
+         BOOST_ASSERT(0 == to_deallocate->hdr_offset);
+         hdr_offset_holder *hdr_off_holder =
+            mp_impl->priv_first_subblock_from_block(boost::movelib::to_raw_pointer(to_deallocate), m_num_subblocks, m_real_block_alignment);
+         m_chain.push_back(hdr_off_holder);
+      }
+
+      const this_type *mp_impl;
+      multiallocation_chain &m_chain;
+      const size_type m_num_subblocks;
+      const size_type m_real_block_alignment;
+      const size_type m_real_num_node;
+   };
+
+   //This macro will activate invariant checking. Slow, but helpful for debugging the code.
+   //#define BOOST_CONTAINER_ADAPTIVE_NODE_POOL_CHECK_INVARIANTS
+   void priv_invariants(const size_type real_num_node, const size_type num_subblocks, const size_type real_block_alignment) const
    {
-      if(!AlignOnly){
-         calculate_num_subblocks
-            ( m_real_block_alignment
-            , m_real_node_size
-            , nodes_per_block
-            , m_num_subblocks
-            , m_real_num_node
-            , (size_type)overhead_percent
-            , HdrSize
-            , HdrOffsetSize
-            , PayloadPerAllocation);
+      (void)real_num_node; (void)num_subblocks; (void)real_block_alignment;
+   #ifdef BOOST_CONTAINER_ADAPTIVE_NODE_POOL_CHECK_INVARIANTS
+      //Check that the total totally free blocks are correct
+      BOOST_ASSERT(m_block_container.size() >= m_totally_free_blocks);
+
+      const const_block_iterator itend(m_block_container.cend());
+      const const_block_iterator itbeg(m_block_container.cbegin());
+
+      {  //Try to do checks in a single iteration
+         const_block_iterator it(itbeg);
+         size_type total_free_nodes = 0;
+         size_type total_free_blocks = 0u;
+         for(; it != itend; ++it){
+            if(it != itbeg){
+               //Check order invariant
+               const_block_iterator prev(it);
+               --prev;
+               BOOST_ASSERT(!(m_block_container.key_comp()(*it, *prev)));
+               (void)prev;   (void)it;
+            }
+
+            //free_nodes invariant
+            const size_type free_nodes = it->free_nodes.size();
+            BOOST_ASSERT(free_nodes <= real_num_node);
+            BOOST_ASSERT(free_nodes != 0);
+
+            //Acummulate total_free_nodes and total_free_blocks
+            total_free_nodes += free_nodes;
+            total_free_blocks += it->free_nodes.size() == real_num_node;
+
+            if (!AlignOnly) {
+               //Check that header offsets are correct
+               hdr_offset_holder *hdr_off_holder = this->priv_first_subblock_from_block(const_cast<block_info_t *>(&*it), num_subblocks, real_block_alignment);
+               for (size_type i = 0, max = num_subblocks; i < max; ++i) {
+                  const size_type offset = reinterpret_cast<char*>(const_cast<block_info_t *>(&*it)) - reinterpret_cast<char*>(hdr_off_holder);
+                  (void)offset;
+                  BOOST_ASSERT(hdr_off_holder->hdr_offset == offset);
+                  BOOST_ASSERT(0 == (reinterpret_cast<std::size_t>(hdr_off_holder) & (real_block_alignment - 1)));
+                  BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (real_block_alignment - 1)));
+                  hdr_off_holder = reinterpret_cast<hdr_offset_holder *>(reinterpret_cast<char*>(hdr_off_holder) + real_block_alignment);
+               }
+            }
+         }
+         BOOST_ASSERT(total_free_blocks == m_totally_free_blocks);
+         BOOST_ASSERT(total_free_nodes >= m_totally_free_blocks*real_num_node);
       }
+   #endif
    }
 
-   //!Destructor. Deallocates all allocated blocks. Never throws
-   ~private_adaptive_node_pool_impl()
-   {  this->priv_clear();  }
+   void priv_deallocate_free_blocks( const size_type max_free_blocks, const size_type real_num_node
+                                   , const size_type num_subblocks, const size_type real_block_alignment)
+   {  //Trampoline function to ease inlining
+      if(m_totally_free_blocks > max_free_blocks){
+         this->priv_deallocate_free_blocks_impl(max_free_blocks, real_num_node, num_subblocks, real_block_alignment);
+      }
+   }
 
-   size_type get_real_num_node() const
-   {  return m_real_num_node; }
+   hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, const size_type num_subblocks, const size_type real_block_alignment) const
+   {  return this->priv_first_subblock_from_block(block, num_subblocks, real_block_alignment, IsAlignOnly());   }
 
-   //!Returns the segment manager. Never throws
-   segment_manager_base_type* get_segment_manager_base()const
-   {  return boost::movelib::to_raw_pointer(mp_segment_mngr_base);  }
+   hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, const size_type num_subblocks, const size_type real_block_alignment, AlignOnlyFalse) const
+   {
+      hdr_offset_holder *const hdr_off_holder = reinterpret_cast<hdr_offset_holder*>
+            (reinterpret_cast<char*>(block) - (num_subblocks-1)*real_block_alignment);
+      BOOST_ASSERT(hdr_off_holder->hdr_offset == size_type(reinterpret_cast<char*>(block) - reinterpret_cast<char*>(hdr_off_holder)));
+      BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (real_block_alignment - 1)));
+      BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (real_block_alignment - 1)));
+      return hdr_off_holder;
+   }
+
+   hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, const size_type num_subblocks, const size_type real_block_alignment, AlignOnlyTrue) const
+   {
+      (void)num_subblocks; (void)real_block_alignment;
+      return reinterpret_cast<hdr_offset_holder*>(block);
+   }
+
+   void priv_deallocate_free_blocks_impl( const size_type max_free_blocks, const size_type real_num_node
+                                        , const size_type num_subblocks, const size_type real_block_alignment)
+   {
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
+      //Now check if we've reached the free nodes limit
+      //and check if we have free blocks. If so, deallocate as much
+      //as we can to stay below the limit
+      multiallocation_chain chain;
+      {
+         if(Flags & adaptive_pool_flag::size_ordered){
+            const_block_iterator it = m_block_container.cend();
+            --it;
+            size_type totally_free_blocks = m_totally_free_blocks;
+
+            for( ; totally_free_blocks > max_free_blocks; --totally_free_blocks){
+               BOOST_ASSERT(it->free_nodes.size() == real_num_node);
+               void *addr = priv_first_subblock_from_block(const_cast<block_info_t*>(&*it), num_subblocks, real_block_alignment);
+               --it;
+               block_container_traits_t::erase_last(m_block_container);
+               chain.push_front(void_pointer(addr));
+            }
+         }
+         else{
+            const_block_iterator it = m_block_container.cend();
+            size_type totally_free_blocks = m_totally_free_blocks;
+
+            while(totally_free_blocks > max_free_blocks){
+               --it;
+               if(it->free_nodes.size() == real_num_node){
+                  void *addr = priv_first_subblock_from_block(const_cast<block_info_t*>(&*it), num_subblocks, real_block_alignment);
+                  it = m_block_container.erase(it);
+                  chain.push_front(void_pointer(addr));
+                  --totally_free_blocks;
+               }
+            }
+         }
+         BOOST_ASSERT((m_totally_free_blocks - max_free_blocks) == chain.size());
+         m_totally_free_blocks = max_free_blocks;
+      }
+      this->mp_segment_mngr_base->deallocate_many(chain);
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
+   }
+
+   void priv_fill_chain_remaining_to_block
+      ( multiallocation_chain &chain, size_type target_elem_in_chain, block_info_t &c_info
+      , char *mem_address, size_type max_node_in_mem
+      , const size_type real_node_size)
+   {
+      BOOST_ASSERT(chain.size() <= target_elem_in_chain);
+
+      //First add all possible nodes to the chain
+      const size_type left = target_elem_in_chain - chain.size();
+      const size_type add_to_chain = (max_node_in_mem < left) ? max_node_in_mem : left;
+      char *free_mem_address = static_cast<char *>(boost::movelib::to_raw_pointer
+         (chain.incorporate_after(chain.last(), void_pointer(mem_address), real_node_size, add_to_chain)));
+      //Now store remaining nodes in the free list
+      if(const size_type free = max_node_in_mem - add_to_chain){
+         free_nodes_t & free_nodes = c_info.free_nodes;
+         free_nodes.incorporate_after(free_nodes.last(), void_pointer(free_mem_address), real_node_size, free);
+      }
+   }
+
+   //!Allocates a several blocks of nodes. Can throw
+   void priv_append_from_new_blocks( size_type min_elements, multiallocation_chain &chain
+                                   , const size_type max_free_blocks
+                                   , const size_type real_block_alignment, const size_type real_node_size
+                                   , const size_type real_num_node, const size_type num_subblocks
+                                   , AlignOnlyTrue)
+   {
+      (void)num_subblocks;
+      BOOST_ASSERT(m_block_container.empty());
+      BOOST_ASSERT(min_elements > 0);
+      const size_type n = (min_elements - 1)/real_num_node + 1;
+      const size_type real_block_size = real_block_alignment - PayloadPerAllocation;
+      const size_type target_elem_in_chain = chain.size() + min_elements;
+      for(size_type i = 0; i != n; ++i){
+         //We allocate a new NodeBlock and put it the last
+         //element of the tree
+         char *mem_address = static_cast<char*>
+            (mp_segment_mngr_base->allocate_aligned(real_block_size, real_block_alignment));
+         if(!mem_address){
+            //In case of error, free memory deallocating all nodes (the new ones allocated
+            //in this function plus previously stored nodes in chain).
+            this->priv_deallocate_nodes(chain, max_free_blocks, real_num_node, num_subblocks, real_block_alignment);
+            throw_bad_alloc();
+         }
+         block_info_t &c_info = *new(mem_address)block_info_t();
+         mem_address += HdrSize;
+         this->priv_fill_chain_remaining_to_block(chain, target_elem_in_chain, c_info, mem_address, real_num_node, real_node_size);
+         const size_type free_nodes = c_info.free_nodes.size();
+         if(free_nodes){
+            const bool is_full = free_nodes == real_num_node;
+            BOOST_ASSERT(free_nodes < real_num_node);
+            m_totally_free_blocks += static_cast<size_type>(is_full);
+            block_container_traits_t::insert_was_empty(m_block_container, c_info, is_full);
+         }
+      }
+   }
+
+   void priv_append_from_new_blocks( size_type min_elements, multiallocation_chain &chain
+                                   , const size_type max_free_blocks
+                                   , const size_type real_block_alignment, const size_type real_node_size
+                                   , const size_type real_num_node, const size_type num_subblocks
+                                   , AlignOnlyFalse)
+   {
+      BOOST_ASSERT(m_block_container.empty());
+      BOOST_ASSERT(min_elements > 0);
+      const size_type n = (min_elements - 1)/real_num_node + 1;
+      const size_type real_block_size = real_block_alignment*num_subblocks - PayloadPerAllocation;
+      const size_type elements_per_subblock_mid = (real_block_alignment - HdrOffsetSize)/real_node_size;
+      const size_type elements_per_subblock_end = (real_block_alignment - HdrOffsetSize - PayloadPerAllocation) / real_node_size;
+      const size_type hdr_subblock_elements = (real_block_alignment - HdrSize - PayloadPerAllocation)/real_node_size;
+      const size_type target_elem_in_chain = chain.size() + min_elements;
+
+      for(size_type i = 0; i != n; ++i){
+         //We allocate a new NodeBlock and put it the last
+         //element of the tree
+         char *mem_address = static_cast<char*>
+            (mp_segment_mngr_base->allocate_aligned(real_block_size, real_block_alignment));
+         if(!mem_address){
+            //In case of error, free memory deallocating all nodes (the new ones allocated
+            //in this function plus previously stored nodes in chain).
+            this->priv_deallocate_nodes(chain, max_free_blocks, real_num_node, num_subblocks, real_block_alignment);
+            throw_bad_alloc();
+         }
+         //First initialize header information on the last subblock
+         char *hdr_addr = mem_address + real_block_alignment*(num_subblocks-1);
+         block_info_t &c_info = *new(hdr_addr)block_info_t();
+         //Some structural checks
+         BOOST_ASSERT(static_cast<void*>(&static_cast<hdr_offset_holder&>(c_info).hdr_offset) ==
+                      static_cast<void*>(&c_info));   (void)c_info;
+         for( size_type subblock = 0, maxsubblock = num_subblocks - 1
+            ; subblock < maxsubblock
+            ; ++subblock, mem_address += real_block_alignment){
+            //Initialize header offset mark
+            new(mem_address) hdr_offset_holder(size_type(hdr_addr - mem_address));
+            const size_type elements_per_subblock = (subblock != (maxsubblock - 1)) ? elements_per_subblock_mid : elements_per_subblock_end;
+            this->priv_fill_chain_remaining_to_block
+               (chain, target_elem_in_chain, c_info, mem_address + HdrOffsetSize, elements_per_subblock, real_node_size);
+         }
+         this->priv_fill_chain_remaining_to_block
+            (chain, target_elem_in_chain, c_info, hdr_addr + HdrSize, hdr_subblock_elements, real_node_size);
+         m_totally_free_blocks += static_cast<size_type>(c_info.free_nodes.size() == real_num_node);
+         if (c_info.free_nodes.size())
+            m_block_container.push_front(c_info);
+      }
+   }
 
    //!Allocates array of count elements. Can throw
-   void *allocate_node()
+   void *priv_allocate_node( const size_type max_free_blocks, const size_type real_block_alignment, const size_type real_node_size
+                           , const size_type real_num_node, const size_type num_subblocks)
    {
-      this->priv_invariants();
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
       //If there are no free nodes we allocate a new block
       if(!m_block_container.empty()){
          //We take the first free node the multiset can't be empty
@@ -394,51 +739,39 @@ class private_adaptive_node_pool_impl
          if(free_nodes.empty()){
             block_container_traits_t::erase_first(m_block_container);
          }
-         m_totally_free_blocks -= static_cast<size_type>(free_nodes_count == m_real_num_node);
-         this->priv_invariants();
+         m_totally_free_blocks -= static_cast<size_type>(free_nodes_count == real_num_node);
+         this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
          return first_node;
       }
       else{
          multiallocation_chain chain;
-         this->priv_append_from_new_blocks(1, chain, IsAlignOnly());
-         return boost::movelib::to_raw_pointer(chain.pop_front());
+         this->priv_append_from_new_blocks
+            (1, chain, max_free_blocks, real_block_alignment, real_node_size, real_num_node, num_subblocks, IsAlignOnly());
+         void *node = boost::movelib::to_raw_pointer(chain.pop_front());
+         this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
+         return node;
       }
    }
 
-   //!Deallocates an array pointed by ptr. Never throws
-   void deallocate_node(void *pElem)
-   {
-      this->priv_invariants();
-      block_info_t &block_info = *this->priv_block_from_node(pElem);
-      BOOST_ASSERT(block_info.free_nodes.size() < m_real_num_node);
-
-      //We put the node at the beginning of the free node list
-      block_info.free_nodes.push_back(void_pointer(pElem));
-
-      //The loop reinserts all blocks except the last one
-      this->priv_reinsert_block(block_info, block_info.free_nodes.size() == 1);
-      this->priv_deallocate_free_blocks(m_max_free_blocks);
-      this->priv_invariants();
-   }
-
-   //!Allocates n nodes.
-   //!Can throw
-   void allocate_nodes(const size_type n, multiallocation_chain &chain)
+   void priv_allocate_nodes( const size_type n, multiallocation_chain &chain
+                           , const size_type max_free_blocks, const size_type real_block_alignment, const size_type real_node_size
+                           , const size_type real_num_node, const size_type num_subblocks)
    {
       size_type i = 0;
       BOOST_TRY{
-         this->priv_invariants();
+         this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
          while(i != n){
             //If there are no free nodes we allocate all needed blocks
             if (m_block_container.empty()){
-               this->priv_append_from_new_blocks(n - i, chain, IsAlignOnly());
+               this->priv_append_from_new_blocks
+                  (n - i, chain, max_free_blocks, real_block_alignment, real_node_size, real_num_node, num_subblocks, IsAlignOnly());
                BOOST_ASSERT(m_block_container.empty() || (++m_block_container.cbegin() == m_block_container.cend()));
                BOOST_ASSERT(chain.size() == n);
                break;
             }
             free_nodes_t &free_nodes = m_block_container.begin()->free_nodes;
             const size_type free_nodes_count_before = free_nodes.size();
-            m_totally_free_blocks -= static_cast<size_type>(free_nodes_count_before == m_real_num_node);
+            m_totally_free_blocks -= static_cast<size_type>(free_nodes_count_before == real_num_node);
             const size_type num_left  = n-i;
             const size_type num_elems = (num_left < free_nodes_count_before) ? num_left : free_nodes_count_before;
             typedef typename free_nodes_t::iterator free_nodes_iterator;
@@ -466,17 +799,38 @@ class private_adaptive_node_pool_impl
          }
       }
       BOOST_CATCH(...){
-         this->deallocate_nodes(chain);
+         this->priv_deallocate_nodes(chain, max_free_blocks, real_num_node, num_subblocks, real_block_alignment);
+         this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
          BOOST_RETHROW
       }
       BOOST_CATCH_END
-      this->priv_invariants();
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
    }
 
-   //!Deallocates a linked list of nodes. Never throws
-   void deallocate_nodes(multiallocation_chain &nodes)
+   //!Deallocates an array pointed by ptr. Never throws
+   void priv_deallocate_node( void *pElem
+                            , const size_type max_free_blocks, const size_type real_num_node
+                            , const size_type num_subblocks, const size_type real_block_alignment)
+   {
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
+      block_info_t &block_info = *this->priv_block_from_node(pElem, real_block_alignment);
+      const size_type prev_free_nodes = block_info.free_nodes.size();
+      BOOST_ASSERT(block_info.free_nodes.size() < real_num_node);
+
+      //We put the node at the beginning of the free node list
+      block_info.free_nodes.push_back(void_pointer(pElem));
+
+      //The loop reinserts all blocks except the last one
+      this->priv_reinsert_block(block_info, prev_free_nodes == 0, real_num_node);
+      this->priv_deallocate_free_blocks(max_free_blocks, real_num_node, num_subblocks, real_block_alignment);
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
+   }
+
+   void priv_deallocate_nodes( multiallocation_chain &nodes
+                             , const size_type max_free_blocks, const size_type real_num_node
+                             , const size_type num_subblocks, const size_type real_block_alignment)
    {
-      this->priv_invariants();
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
       //To take advantage of node locality, wait until two
       //nodes belong to different blocks. Only then reinsert
       //the block of the first node in the block tree.
@@ -493,8 +847,8 @@ class private_adaptive_node_pool_impl
          size_type splice_node_count = size_type(-1);
          while(itf != ite){
             void *pElem = boost::movelib::to_raw_pointer(boost::movelib::iterator_to_raw_pointer(itf));
-            block_info_t &block_info = *this->priv_block_from_node(pElem);
-            BOOST_ASSERT(block_info.free_nodes.size() < m_real_num_node);
+            block_info_t &block_info = *this->priv_block_from_node(pElem, real_block_alignment);
+            BOOST_ASSERT(block_info.free_nodes.size() < real_num_node);
             ++splice_node_count;
 
             //If block change is detected calculate the cached block position in the tree
@@ -503,7 +857,7 @@ class private_adaptive_node_pool_impl
                   free_nodes_iterator it(itbb); ++it;
                   nodes.erase_after(itbb, itf, splice_node_count);
                   prev_block_info->free_nodes.incorporate_after(prev_block_info->free_nodes.last(), &*it, &*itbf, splice_node_count);
-                  this->priv_reinsert_block(*prev_block_info, prev_block_was_empty);
+                  this->priv_reinsert_block(*prev_block_info, prev_block_was_empty, real_num_node);
                   splice_node_count = 0;
                }
                //Update cache with new data
@@ -520,183 +874,50 @@ class private_adaptive_node_pool_impl
          const size_type splice_node_count = nodes.size();
          nodes.clear();
          prev_block_info->free_nodes.incorporate_after(prev_block_info->free_nodes.last(), &*itfirst, &*itlast, splice_node_count);
-         this->priv_reinsert_block(*prev_block_info, prev_block_was_empty);
-         this->priv_invariants();
-         this->priv_deallocate_free_blocks(m_max_free_blocks);
+         this->priv_reinsert_block(*prev_block_info, prev_block_was_empty, real_num_node);
+         this->priv_deallocate_free_blocks(max_free_blocks, real_num_node, num_subblocks, real_block_alignment);
       }
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
    }
 
-   void deallocate_free_blocks()
-   {  this->priv_deallocate_free_blocks(0);  }
-
-   size_type num_free_nodes()
+   void priv_reinsert_block(block_info_t &prev_block_info, const bool prev_block_was_empty, const size_type real_num_node)
    {
-      typedef typename block_container_t::const_iterator citerator;
-      size_type count = 0;
-      citerator it (m_block_container.begin()), itend(m_block_container.end());
-      for(; it != itend; ++it){
-         count += it->free_nodes.size();
+      //Cache the free nodes from the block
+      const size_type this_block_free_nodes = prev_block_info.free_nodes.size();
+      const bool is_full = this_block_free_nodes == real_num_node;
+
+      //Update free block count
+      m_totally_free_blocks += static_cast<size_type>(is_full);
+      if(prev_block_was_empty){
+         block_container_traits_t::insert_was_empty(m_block_container, prev_block_info, is_full);
+      }
+      else{
+         block_container_traits_t::reinsert_was_used(m_block_container, prev_block_info, is_full);
       }
-      return count;
    }
 
-   void swap(private_adaptive_node_pool_impl &other)
+   block_info_t *priv_block_from_node(void *node, const size_type real_block_alignment, AlignOnlyFalse) const
    {
-      BOOST_ASSERT(m_max_free_blocks == other.m_max_free_blocks);
-      BOOST_ASSERT(m_real_node_size == other.m_real_node_size);
-      BOOST_ASSERT(m_real_block_alignment == other.m_real_block_alignment);
-      BOOST_ASSERT(m_real_num_node == other.m_real_num_node);
-      std::swap(mp_segment_mngr_base, other.mp_segment_mngr_base);
-      std::swap(m_totally_free_blocks, other.m_totally_free_blocks);
-      m_block_container.swap(other.m_block_container);
+      hdr_offset_holder *hdr_off_holder =
+         reinterpret_cast<hdr_offset_holder*>((std::size_t)node & size_type(~(real_block_alignment - 1)));
+      BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (real_block_alignment - 1)));
+      BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (real_block_alignment - 1)));
+      block_info_t *block = reinterpret_cast<block_info_t *>
+         (reinterpret_cast<char*>(hdr_off_holder) + hdr_off_holder->hdr_offset);
+      BOOST_ASSERT(block->hdr_offset == 0);
+      return block;
    }
 
-   //Deprecated, use deallocate_free_blocks
-   void deallocate_free_chunks()
-   {  this->priv_deallocate_free_blocks(0);   }
+   block_info_t *priv_block_from_node(void *node, const size_type real_block_alignment, AlignOnlyTrue) const
+   {
+      return (block_info_t *)((std::size_t)node & std::size_t(~(real_block_alignment - 1)));
+   }
 
-   private:
-
-   void priv_deallocate_free_blocks(size_type max_free_blocks)
-   {  //Trampoline function to ease inlining
-      if(m_totally_free_blocks > max_free_blocks){
-         this->priv_deallocate_free_blocks_impl(max_free_blocks);
-      }
-   }
-
-   void priv_deallocate_free_blocks_impl(size_type max_free_blocks)
-   {
-      this->priv_invariants();
-      //Now check if we've reached the free nodes limit
-      //and check if we have free blocks. If so, deallocate as much
-      //as we can to stay below the limit
-      multiallocation_chain chain;
-      {
-         const const_block_iterator itend = m_block_container.cend();
-         const_block_iterator it = itend;
-         --it;
-         size_type totally_free_blocks = m_totally_free_blocks;
-
-         for( ; totally_free_blocks > max_free_blocks; --totally_free_blocks){
-            BOOST_ASSERT(it->free_nodes.size() == m_real_num_node);
-            void *addr = priv_first_subblock_from_block(const_cast<block_info_t*>(&*it));
-            --it;
-            block_container_traits_t::erase_last(m_block_container);
-            chain.push_front(void_pointer(addr));
-         }
-         BOOST_ASSERT((m_totally_free_blocks - max_free_blocks) == chain.size());
-         m_totally_free_blocks = max_free_blocks;
-      }
-      this->mp_segment_mngr_base->deallocate_many(chain);
-   }
-
-   void priv_reinsert_block(block_info_t &prev_block_info, const bool prev_block_was_empty)
-   {
-      //Cache the free nodes from the block
-      const size_type this_block_free_nodes = prev_block_info.free_nodes.size();
-      const bool is_full = this_block_free_nodes == m_real_num_node;
-
-      //Update free block count
-      m_totally_free_blocks += static_cast<size_type>(is_full);
-      if(prev_block_was_empty){
-         block_container_traits_t::insert_was_empty(m_block_container, prev_block_info, is_full);
-      }
-      else{
-         block_container_traits_t::reinsert_was_used(m_block_container, prev_block_info, is_full);
-      }
-   }
-
-   class block_destroyer;
-   friend class block_destroyer;
-
-   class block_destroyer
-   {
-      public:
-      block_destroyer(const this_type *impl, multiallocation_chain &chain)
-         :  mp_impl(impl), m_chain(chain)
-      {}
-
-      void operator()(typename block_container_t::pointer to_deallocate)
-      {  return this->do_destroy(to_deallocate, IsAlignOnly()); }
-
-      private:
-      void do_destroy(typename block_container_t::pointer to_deallocate, AlignOnlyTrue)
-      {
-         BOOST_ASSERT(to_deallocate->free_nodes.size() == mp_impl->m_real_num_node);
-         m_chain.push_back(to_deallocate);
-      }
-
-      void do_destroy(typename block_container_t::pointer to_deallocate, AlignOnlyFalse)
-      {
-         BOOST_ASSERT(to_deallocate->free_nodes.size() == mp_impl->m_real_num_node);
-         BOOST_ASSERT(0 == to_deallocate->hdr_offset);
-         hdr_offset_holder *hdr_off_holder =
-            mp_impl->priv_first_subblock_from_block(boost::movelib::to_raw_pointer(to_deallocate));
-         m_chain.push_back(hdr_off_holder);
-      }
-
-      const this_type *mp_impl;
-      multiallocation_chain &m_chain;
-   };
-
-   //This macro will activate invariant checking. Slow, but helpful for debugging the code.
-   //#define BOOST_CONTAINER_ADAPTIVE_NODE_POOL_CHECK_INVARIANTS
-   void priv_invariants()
-   #ifdef BOOST_CONTAINER_ADAPTIVE_NODE_POOL_CHECK_INVARIANTS
-   #undef BOOST_CONTAINER_ADAPTIVE_NODE_POOL_CHECK_INVARIANTS
-   {
-      const const_block_iterator itend(m_block_container.end());
-
-      {  //We iterate through the block tree to free the memory
-         const_block_iterator it(m_block_container.begin());
-
-         if(it != itend){
-            for(++it; it != itend; ++it){
-               const_block_iterator prev(it);
-               --prev;
-               BOOST_ASSERT(*prev < *it);
-               (void)prev;   (void)it;
-            }
-         }
-      }
-      {  //Check that the total free nodes are correct
-         const_block_iterator it(m_block_container.cbegin());
-         size_type total_free_nodes = 0;
-         for(; it != itend; ++it){
-            total_free_nodes += it->free_nodes.size();
-         }
-         BOOST_ASSERT(total_free_nodes >= m_totally_free_blocks*m_real_num_node);
-      }
-      {  //Check that the total totally free blocks are correct
-         BOOST_ASSERT(m_block_container.size() >= m_totally_free_blocks);
-         const_block_iterator it = m_block_container.cend();
-         size_type total_free_blocks = m_totally_free_blocks;
-         while(total_free_blocks--){
-            BOOST_ASSERT((--it)->free_nodes.size() == m_real_num_node);
-         }
-      }
-
-      if(!AlignOnly){
-         //Check that header offsets are correct
-         const_block_iterator it = m_block_container.begin();
-         for(; it != itend; ++it){
-            hdr_offset_holder *hdr_off_holder = this->priv_first_subblock_from_block(const_cast<block_info_t *>(&*it));
-            for(size_type i = 0, max = m_num_subblocks; i < max; ++i){
-               const size_type offset = reinterpret_cast<char*>(const_cast<block_info_t *>(&*it)) - reinterpret_cast<char*>(hdr_off_holder);
-               BOOST_ASSERT(hdr_off_holder->hdr_offset == offset);
-               BOOST_ASSERT(0 == ((size_type)hdr_off_holder & (m_real_block_alignment - 1)));
-               BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
-               hdr_off_holder = reinterpret_cast<hdr_offset_holder *>(reinterpret_cast<char*>(hdr_off_holder) + m_real_block_alignment);
-            }
-         }
-      }
-   }
-   #else
-   {} //empty
-   #endif
+   block_info_t *priv_block_from_node(void *node, const size_type real_block_alignment) const
+   {  return this->priv_block_from_node(node, real_block_alignment, IsAlignOnly());   }
 
    //!Deallocates all used memory. Never throws
-   void priv_clear()
+   void priv_clear(const size_type num_subblocks, const size_type real_block_alignment, const size_type real_num_node)
    {
       #ifndef NDEBUG
       block_iterator it    = m_block_container.begin();
@@ -704,176 +925,329 @@ class private_adaptive_node_pool_impl
       size_type n_free_nodes = 0;
       for(; it != itend; ++it){
          //Check for memory leak
-         BOOST_ASSERT(it->free_nodes.size() == m_real_num_node);
+         BOOST_ASSERT(it->free_nodes.size() == real_num_node);
          ++n_free_nodes;
       }
       BOOST_ASSERT(n_free_nodes == m_totally_free_blocks);
       #endif
       //Check for memory leaks
-      this->priv_invariants();
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
       multiallocation_chain chain;
-      m_block_container.clear_and_dispose(block_destroyer(this, chain));
+      m_block_container.clear_and_dispose(block_destroyer(this, chain, num_subblocks, real_block_alignment, real_num_node));
       this->mp_segment_mngr_base->deallocate_many(chain);
       m_totally_free_blocks = 0;
+      this->priv_invariants(real_num_node, num_subblocks, real_block_alignment);
    }
 
-   block_info_t *priv_block_from_node(void *node, AlignOnlyFalse) const
+   public:
+   private_adaptive_node_pool_impl_common(segment_manager_base_type *segment_mngr_base)
+      //General purpose allocator
+   :  mp_segment_mngr_base(segment_mngr_base)
+   ,  m_block_container()
+   ,  m_totally_free_blocks(0)
+   {}
+
+   size_type num_free_nodes()
    {
-      hdr_offset_holder *hdr_off_holder =
-         reinterpret_cast<hdr_offset_holder*>((std::size_t)node & size_type(~(m_real_block_alignment - 1)));
-      BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
-      BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
-      block_info_t *block = reinterpret_cast<block_info_t *>
-         (reinterpret_cast<char*>(hdr_off_holder) + hdr_off_holder->hdr_offset);
-      BOOST_ASSERT(block->hdr_offset == 0);
-      return block;
+      typedef typename block_container_t::const_iterator citerator;
+      size_type count = 0;
+      citerator it (m_block_container.begin()), itend(m_block_container.end());
+      for(; it != itend; ++it){
+         count += it->free_nodes.size();
+      }
+      return count;
    }
 
-   block_info_t *priv_block_from_node(void *node, AlignOnlyTrue) const
+   void swap(private_adaptive_node_pool_impl_common &other)
    {
-      return (block_info_t *)((std::size_t)node & std::size_t(~(m_real_block_alignment - 1)));
+      std::swap(mp_segment_mngr_base, other.mp_segment_mngr_base);
+      std::swap(m_totally_free_blocks, other.m_totally_free_blocks);
+      m_block_container.swap(other.m_block_container);
    }
 
-   block_info_t *priv_block_from_node(void *node) const
-   {  return this->priv_block_from_node(node, IsAlignOnly());   }
+   //!Returns the segment manager. Never throws
+   segment_manager_base_type* get_segment_manager_base()const
+   {  return boost::movelib::to_raw_pointer(mp_segment_mngr_base);  }
+};
+
+template< class SizeType
+        , std::size_t HdrSize
+        , std::size_t PayloadPerAllocation
+        , std::size_t RealNodeSize
+        , std::size_t NodesPerBlock
+        , std::size_t HdrOffsetSize
+        , std::size_t OverheadPercent
+        , bool AlignOnly>
+struct calculate_alignment_ct
+{
+   static const std::size_t alignment     = upper_power_of_2_ct<SizeType, HdrSize + RealNodeSize*NodesPerBlock>::value;
+   static const std::size_t num_subblocks = 0;
+   static const std::size_t real_num_node = (alignment - PayloadPerAllocation - HdrSize)/RealNodeSize;
+};
+
+template< class SizeType
+        , std::size_t HdrSize
+        , std::size_t PayloadPerAllocation
+        , std::size_t RealNodeSize
+        , std::size_t NodesPerBlock
+        , std::size_t HdrOffsetSize
+        , std::size_t OverheadPercent>
+struct calculate_alignment_ct
+   < SizeType
+   , HdrSize
+   , PayloadPerAllocation
+   , RealNodeSize
+   , NodesPerBlock
+   , HdrOffsetSize
+   , OverheadPercent
+   , false>
+{
+   typedef typename candidate_power_of_2_ct
+      < upper_power_of_2_ct<SizeType, HdrSize + PayloadPerAllocation + RealNodeSize>::value
+      , RealNodeSize
+      , PayloadPerAllocation
+      , NodesPerBlock
+      , HdrSize
+      , HdrOffsetSize
+      , OverheadPercent
+      >::type type;
+
+   static const std::size_t alignment     = type::alignment;
+   static const std::size_t num_subblocks = type::num_subblocks;
+   static const std::size_t real_num_node = type::real_num_node;
+};
+
+
+/////////////////////////////////////////////
+//
+//    private_adaptive_node_pool_impl_ct
+//
+/////////////////////////////////////////////
+template< class SegmentManagerBase
+        , std::size_t MaxFreeBlocks
+        , std::size_t NodeSize
+        , std::size_t NodesPerBlock
+        , std::size_t OverheadPercent
+        , unsigned int Flags>
+class private_adaptive_node_pool_impl_ct
+   : public private_adaptive_node_pool_impl_common<SegmentManagerBase, Flags>
+{
+   typedef private_adaptive_node_pool_impl_common<SegmentManagerBase, Flags> base_t;
+
+   //Non-copyable
+   private_adaptive_node_pool_impl_ct();
+   private_adaptive_node_pool_impl_ct(const private_adaptive_node_pool_impl_ct &);
+   private_adaptive_node_pool_impl_ct &operator=(const private_adaptive_node_pool_impl_ct &);
+
+   public:
+   typedef typename base_t::void_pointer              void_pointer;
+   typedef typename base_t::size_type                 size_type;
+   typedef typename base_t::multiallocation_chain     multiallocation_chain;
+   typedef typename base_t::segment_manager_base_type segment_manager_base_type;
+
+   static const typename base_t::size_type PayloadPerAllocation = base_t::PayloadPerAllocation;
+
+   //align_only
+   static const bool AlignOnly      = base_t::AlignOnly;
+
+   private:
+   static const size_type MaxAlign = base_t::MaxAlign;
+   static const size_type HdrSize  = base_t::HdrSize;
+   static const size_type HdrOffsetSize = base_t::HdrOffsetSize;
+
+   static const size_type RealNodeSize = lcm_ct<NodeSize, alignment_of<void_pointer>::value>::value;
+
+   typedef calculate_alignment_ct
+      < size_type, HdrSize, PayloadPerAllocation
+      , RealNodeSize, NodesPerBlock, HdrOffsetSize, OverheadPercent, AlignOnly> data_t;
+
+   //Round the size to a power of two value.
+   //This is the total memory size (including payload) that we want to
+   //allocate from the general-purpose allocator
+   static const size_type NumSubBlocks       = data_t::num_subblocks;
+   static const size_type RealNumNode        = data_t::real_num_node;
+   static const size_type RealBlockAlignment = data_t::alignment;
 
-   hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block) const
-   {  return this->priv_first_subblock_from_block(block, IsAlignOnly());   }
+   public:
 
-   hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, AlignOnlyFalse) const
+   //!Constructor from a segment manager. Never throws
+   private_adaptive_node_pool_impl_ct(typename base_t::segment_manager_base_type *segment_mngr_base)
+      //General purpose allocator
+   :  base_t(segment_mngr_base)
+   {}
+
+   //!Destructor. Deallocates all allocated blocks. Never throws
+   ~private_adaptive_node_pool_impl_ct()
+   {  this->priv_clear(NumSubBlocks, data_t::alignment, RealNumNode);  }
+
+   size_type get_real_num_node() const
+   {  return RealNumNode; }
+
+   //!Allocates array of count elements. Can throw
+   void *allocate_node()
    {
-      hdr_offset_holder *const hdr_off_holder = reinterpret_cast<hdr_offset_holder*>
-            (reinterpret_cast<char*>(block) - (m_num_subblocks-1)*m_real_block_alignment);
-      BOOST_ASSERT(hdr_off_holder->hdr_offset == size_type(reinterpret_cast<char*>(block) - reinterpret_cast<char*>(hdr_off_holder)));
-      BOOST_ASSERT(0 == ((std::size_t)hdr_off_holder & (m_real_block_alignment - 1)));
-      BOOST_ASSERT(0 == (hdr_off_holder->hdr_offset & (m_real_block_alignment - 1)));
-      return hdr_off_holder;
+      return this->priv_allocate_node
+         (MaxFreeBlocks, data_t::alignment, RealNodeSize, RealNumNode, NumSubBlocks);
    }
 
-   hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, AlignOnlyTrue) const
+   //!Allocates n nodes.
+   //!Can throw
+   void allocate_nodes(const size_type n, multiallocation_chain &chain)
    {
-      return reinterpret_cast<hdr_offset_holder*>(block);
+      this->priv_allocate_nodes
+         (n, chain, MaxFreeBlocks, data_t::alignment, RealNodeSize, RealNumNode, NumSubBlocks);
    }
 
-   void priv_dispatch_block_chain_or_free
-      ( multiallocation_chain &chain, block_info_t &c_info, size_type num_node
-      , char *mem_address, size_type total_elements, bool insert_block_if_free)
+   //!Deallocates an array pointed by ptr. Never throws
+   void deallocate_node(void *pElem)
    {
-      BOOST_ASSERT(chain.size() <= total_elements);
-      //First add all possible nodes to the chain
-      const size_type left = total_elements - chain.size();
-      const size_type max_chain = (num_node < left) ? num_node : left;
-      mem_address = static_cast<char *>(boost::movelib::to_raw_pointer
-         (chain.incorporate_after(chain.last(), void_pointer(mem_address), m_real_node_size, max_chain)));
-      //Now store remaining nodes in the free list
-      if(const size_type max_free = num_node - max_chain){
-         free_nodes_t & free_nodes = c_info.free_nodes;
-         free_nodes.incorporate_after(free_nodes.last(), void_pointer(mem_address), m_real_node_size, max_free);
-         if(insert_block_if_free){
-            m_block_container.push_front(c_info);
-         }
-      }
+      this->priv_deallocate_node(pElem, MaxFreeBlocks, RealNumNode, NumSubBlocks, RealBlockAlignment);
    }
 
-   //!Allocates a several blocks of nodes. Can throw
-   void priv_append_from_new_blocks(size_type min_elements, multiallocation_chain &chain, AlignOnlyTrue)
+   //!Deallocates a linked list of nodes. Never throws
+   void deallocate_nodes(multiallocation_chain &nodes)
    {
-      BOOST_ASSERT(m_block_container.empty());
-      BOOST_ASSERT(min_elements > 0);
-      const size_type n = (min_elements - 1)/m_real_num_node + 1;
-      const size_type real_block_size = m_real_block_alignment - PayloadPerAllocation;
-      const size_type total_elements = chain.size() + min_elements;
-      for(size_type i = 0; i != n; ++i){
-         //We allocate a new NodeBlock and put it the last
-         //element of the tree
-         char *mem_address = static_cast<char*>
-            (mp_segment_mngr_base->allocate_aligned(real_block_size, m_real_block_alignment));
-         if(!mem_address){
-            //In case of error, free memory deallocating all nodes (the new ones allocated
-            //in this function plus previously stored nodes in chain).
-            this->deallocate_nodes(chain);
-            throw_bad_alloc();
-         }
-         block_info_t &c_info = *new(mem_address)block_info_t();
-         mem_address += HdrSize;
-         if(i != (n-1)){
-            chain.incorporate_after(chain.last(), void_pointer(mem_address), m_real_node_size, m_real_num_node);
-         }
-         else{
-            this->priv_dispatch_block_chain_or_free(chain, c_info, m_real_num_node, mem_address, total_elements, true);
-         }
-      }
+      this->priv_deallocate_nodes(nodes, MaxFreeBlocks, RealNumNode, NumSubBlocks, data_t::alignment);
    }
 
-   void priv_append_from_new_blocks(size_type min_elements, multiallocation_chain &chain, AlignOnlyFalse)
-   {
-      BOOST_ASSERT(m_block_container.empty());
-      BOOST_ASSERT(min_elements > 0);
-      const size_type n = (min_elements - 1)/m_real_num_node + 1;
-      const size_type real_block_size = m_real_block_alignment*m_num_subblocks - PayloadPerAllocation;
-      const size_type elements_per_subblock = (m_real_block_alignment - HdrOffsetSize)/m_real_node_size;
-      const size_type hdr_subblock_elements = (m_real_block_alignment - HdrSize - PayloadPerAllocation)/m_real_node_size;
-      const size_type total_elements = chain.size() + min_elements;
+   void deallocate_free_blocks()
+   {  this->priv_deallocate_free_blocks(0, RealNumNode, NumSubBlocks, data_t::alignment);  }
 
-      for(size_type i = 0; i != n; ++i){
-         //We allocate a new NodeBlock and put it the last
-         //element of the tree
-         char *mem_address = static_cast<char*>
-            (mp_segment_mngr_base->allocate_aligned(real_block_size, m_real_block_alignment));
-         if(!mem_address){
-            //In case of error, free memory deallocating all nodes (the new ones allocated
-            //in this function plus previously stored nodes in chain).
-            this->deallocate_nodes(chain);
-            throw_bad_alloc();
-         }
-         //First initialize header information on the last subblock
-         char *hdr_addr = mem_address + m_real_block_alignment*(m_num_subblocks-1);
-         block_info_t &c_info = *new(hdr_addr)block_info_t();
-         //Some structural checks
-         BOOST_ASSERT(static_cast<void*>(&static_cast<hdr_offset_holder&>(c_info).hdr_offset) ==
-                      static_cast<void*>(&c_info));   (void)c_info;
-         if(i != (n-1)){
-            for( size_type subblock = 0, maxsubblock = m_num_subblocks - 1
-               ; subblock < maxsubblock
-               ; ++subblock, mem_address += m_real_block_alignment){
-               //Initialize header offset mark
-               new(mem_address) hdr_offset_holder(size_type(hdr_addr - mem_address));
-               chain.incorporate_after
-                  (chain.last(), void_pointer(mem_address + HdrOffsetSize), m_real_node_size, elements_per_subblock);
-            }
-            chain.incorporate_after(chain.last(), void_pointer(hdr_addr + HdrSize), m_real_node_size, hdr_subblock_elements);
-         }
-         else{
-            for( size_type subblock = 0, maxsubblock = m_num_subblocks - 1
-               ; subblock < maxsubblock
-               ; ++subblock, mem_address += m_real_block_alignment){
-               //Initialize header offset mark
-               new(mem_address) hdr_offset_holder(size_type(hdr_addr - mem_address));
-               this->priv_dispatch_block_chain_or_free
-                  (chain, c_info, elements_per_subblock, mem_address + HdrOffsetSize, total_elements, false);
-            }
-            this->priv_dispatch_block_chain_or_free
-               (chain, c_info, hdr_subblock_elements, hdr_addr + HdrSize, total_elements, true);
-         }
-      }
-   }
+   //Deprecated, use deallocate_free_blocks
+   void deallocate_free_chunks()
+   {  this->priv_deallocate_free_blocks(0, RealNumNode, NumSubBlocks, data_t::alignment);   }
+};
+
+/////////////////////////////////////////////
+//
+//    private_adaptive_node_pool_impl_rt
+//
+/////////////////////////////////////////////
+template<class SizeType>
+struct private_adaptive_node_pool_impl_rt_data
+{
+   typedef SizeType size_type;
+
+   private_adaptive_node_pool_impl_rt_data(size_type max_free_blocks, size_type real_node_size)
+      : m_max_free_blocks(max_free_blocks), m_real_node_size(real_node_size)
+      , m_real_block_alignment(), m_num_subblocks(), m_real_num_node()
+   {}
 
-   private:
-   typedef typename boost::intrusive::pointer_traits
-      <void_pointer>::template rebind_pointer<segment_manager_base_type>::type   segment_mngr_base_ptr_t;
    const size_type m_max_free_blocks;
    const size_type m_real_node_size;
    //Round the size to a power of two value.
    //This is the total memory size (including payload) that we want to
    //allocate from the general-purpose allocator
-   const size_type m_real_block_alignment;
+   size_type m_real_block_alignment;
    size_type m_num_subblocks;
    //This is the real number of nodes per block
-   //const
    size_type m_real_num_node;
-   segment_mngr_base_ptr_t             mp_segment_mngr_base;   //Segment manager
-   block_container_t                    m_block_container;       //Intrusive block list
-   size_type                           m_totally_free_blocks;  //Free blocks
+};
+
+
+template<class SegmentManagerBase, unsigned int Flags>
+class private_adaptive_node_pool_impl_rt
+   : private private_adaptive_node_pool_impl_rt_data<typename SegmentManagerBase::size_type>
+   , public  private_adaptive_node_pool_impl_common<SegmentManagerBase, Flags> 
+{
+   typedef private_adaptive_node_pool_impl_common<SegmentManagerBase, Flags> impl_t;
+   typedef private_adaptive_node_pool_impl_rt_data<typename SegmentManagerBase::size_type> data_t;
+
+   //Non-copyable
+   private_adaptive_node_pool_impl_rt();
+   private_adaptive_node_pool_impl_rt(const private_adaptive_node_pool_impl_rt &);
+   private_adaptive_node_pool_impl_rt &operator=(const private_adaptive_node_pool_impl_rt &);
+
+   protected:
+
+   typedef typename impl_t::void_pointer           void_pointer;
+   typedef typename impl_t::size_type              size_type;
+   typedef typename impl_t::multiallocation_chain  multiallocation_chain;
+
+   static const typename impl_t::size_type PayloadPerAllocation = impl_t::PayloadPerAllocation;
+
+   //Flags
+   //align_only
+   static const bool AlignOnly      = impl_t::AlignOnly;
+
+   static const size_type HdrSize  = impl_t::HdrSize;
+   static const size_type HdrOffsetSize = impl_t::HdrOffsetSize;
+
+   public:
+
+   //!Segment manager typedef
+   typedef SegmentManagerBase                 segment_manager_base_type;
+
+   //!Constructor from a segment manager. Never throws
+   private_adaptive_node_pool_impl_rt
+      ( segment_manager_base_type *segment_mngr_base
+      , size_type node_size
+      , size_type nodes_per_block
+      , size_type max_free_blocks
+      , unsigned char overhead_percent
+      )
+   :  data_t(max_free_blocks, lcm(node_size, size_type(alignment_of<void_pointer>::value)))
+   ,  impl_t(segment_mngr_base)
+   {
+      if(AlignOnly){
+         this->m_real_block_alignment = upper_power_of_2(HdrSize + this->m_real_node_size*nodes_per_block);
+         this->m_real_num_node = (this->m_real_block_alignment - PayloadPerAllocation - HdrSize)/this->m_real_node_size;
+      }
+      else{
+         candidate_power_of_2_rt ( upper_power_of_2(HdrSize + PayloadPerAllocation + this->m_real_node_size)
+                                 , this->m_real_node_size
+                                 , PayloadPerAllocation
+                                 , nodes_per_block
+                                 , HdrSize
+                                 , HdrOffsetSize
+                                 , overhead_percent
+                                 , this->m_real_block_alignment
+                                 , this->m_num_subblocks
+                                 , this->m_real_num_node);
+      }
+   }
+
+   //!Destructor. Deallocates all allocated blocks. Never throws
+   ~private_adaptive_node_pool_impl_rt()
+   {  this->priv_clear(this->m_num_subblocks, this->m_real_block_alignment, this->m_real_num_node);  }
+
+   size_type get_real_num_node() const
+   {  return this->m_real_num_node; }
+
+   //!Allocates array of count elements. Can throw
+   void *allocate_node()
+   {
+      return this->priv_allocate_node
+         (this->m_max_free_blocks, this->m_real_block_alignment, this->m_real_node_size, this->m_real_num_node, this->m_num_subblocks);
+   }
+
+   //!Allocates n nodes.
+   //!Can throw
+   void allocate_nodes(const size_type n, multiallocation_chain &chain)
+   {
+
+      this->priv_allocate_nodes
+         (n, chain, this->m_max_free_blocks, this->m_real_block_alignment, this->m_real_node_size, this->m_real_num_node, this->m_num_subblocks);
+   }
+
+   //!Deallocates an array pointed by ptr. Never throws
+   void deallocate_node(void *pElem)
+   {
+      this->priv_deallocate_node(pElem, this->m_max_free_blocks, this->m_real_num_node, this->m_num_subblocks, this->m_real_block_alignment);
+   }
+
+   //!Deallocates a linked list of nodes. Never throws
+   void deallocate_nodes(multiallocation_chain &nodes)
+   {
+      this->priv_deallocate_nodes(nodes, this->m_max_free_blocks, this->m_real_num_node, this->m_num_subblocks, this->m_real_block_alignment);
+   }
+
+   void deallocate_free_blocks()
+   {  this->priv_deallocate_free_blocks(0, this->m_real_num_node, this->m_num_subblocks, this->m_real_block_alignment);  }
+
+   //Deprecated, use deallocate_free_blocks
+   void deallocate_free_chunks()
+   {  this->priv_deallocate_free_blocks(0, this->m_real_num_node, this->m_num_subblocks, this->m_real_block_alignment);   }
 };
 
 }  //namespace dtl {