boost/container/detail/adaptive_node_pool_impl.hpp
////////////////////////////////////////////////////////////////////////////// // // (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/container for documentation. // ////////////////////////////////////////////////////////////////////////////// #ifndef BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP #define BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP #if defined(_MSC_VER) # pragma once #endif #include "config_begin.hpp" #include <boost/container/container_fwd.hpp> #include <boost/container/detail/workaround.hpp> #include <boost/container/detail/utilities.hpp> #include <boost/intrusive/pointer_traits.hpp> #include <boost/intrusive/set.hpp> #include <boost/intrusive/list.hpp> #include <boost/intrusive/slist.hpp> #include <boost/container/detail/type_traits.hpp> #include <boost/container/detail/math_functions.hpp> #include <boost/container/detail/mpl.hpp> #include <boost/container/detail/pool_common.hpp> #include <boost/container/throw_exception.hpp> #include <boost/assert.hpp> #include <boost/detail/no_exceptions_support.hpp> #include <cstddef> namespace boost { namespace container { namespace adaptive_pool_flag { static const unsigned int none = 0u; static const unsigned int align_only = 1u << 0u; static const unsigned int size_ordered = 1u << 1u; static const unsigned int address_ordered = 1u << 2u; } //namespace adaptive_pool_flag{ namespace container_detail { template<class size_type> struct hdr_offset_holder_t { hdr_offset_holder_t(size_type offset = 0) : hdr_offset(offset) {} size_type hdr_offset; }; template<class SizeType, unsigned int Flags> struct less_func; template<class SizeType> struct less_func<SizeType, adaptive_pool_flag::none> { static bool less(SizeType, SizeType, const void *, const void *) { return true; } }; template<class SizeType> struct less_func<SizeType, adaptive_pool_flag::size_ordered> { static bool less(SizeType ls, SizeType rs, const void *, const void *) { return ls < rs; } }; 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; } }; template<class SizeType> struct less_func<SizeType, adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered> { static bool less(SizeType ls, SizeType rs, const void *la, const void *ra) { return (ls < rs) || ((ls == rs) && (la < ra)); } }; template<class VoidPointer, class SizeType, bool ordered> struct block_container_traits { typedef typename bi::make_set_base_hook < bi::void_pointer<VoidPointer> , bi::optimize_size<true> , bi::link_mode<bi::normal_link> >::type hook_t; template<class T> struct container { typedef typename bi::make_multiset <T, bi::base_hook<hook_t>, bi::size_type<SizeType> >::type type; }; template<class Container> 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()){ container.erase(this_block); container.insert(v); } } } template<class Container> static void insert_was_empty(Container &container, typename Container::value_type &v, bool) { container.insert(v); } template<class Container> static void erase_first(Container &container) { container.erase(container.cbegin()); } template<class Container> static void erase_last(Container &container) { container.erase(--container.cend()); } }; template<class VoidPointer, class SizeType> struct block_container_traits<VoidPointer, SizeType, false> { typedef typename bi::make_list_base_hook < bi::void_pointer<VoidPointer> , bi::link_mode<bi::normal_link> >::type hook_t; template<class T> struct container { typedef typename bi::make_list <T, bi::base_hook<hook_t>, bi::size_type<SizeType>, bi::constant_time_size<false> >::type type; }; template<class Container> static void reinsert_was_used(Container &container, typename Container::value_type &v, bool is_full) { if(is_full){ container.erase(Container::s_iterator_to(v)); container.push_back(v); } } template<class Container> static void insert_was_empty(Container &container, typename Container::value_type &v, bool is_full) { if(is_full){ container.push_back(v); } else{ container.push_front(v); } } template<class Container> static void erase_first(Container &container) { container.pop_front(); } template<class Container> static void erase_last(Container &container) { container.pop_back(); } }; 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; 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; static const unsigned int order_flags = Flags & (adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered); typedef MultiallocationChain free_nodes_t; struct block_info_t : public hdr_offset_holder, public hook_t { //An intrusive list of free node from this block free_nodes_t free_nodes; friend bool operator <(const block_info_t &l, const block_info_t &r) { return less_func<SizeType, order_flags>:: less(l.free_nodes.size(), r.free_nodes.size(), &l , &r); } friend bool operator ==(const block_info_t &l, const block_info_t &r) { return &l == &r; } }; 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) { //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; } 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) { 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; } } num_subblocks = possible_num_subblock; real_num_node = (possible_num_subblock-1)*elements_per_subblock + hdr_subblock_elements; } template<class SegmentManagerBase, unsigned int Flags> class private_adaptive_node_pool_impl { //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; //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; private: 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; typedef typename adaptive_pool_types_t::block_info_t block_info_t; typedef typename adaptive_pool_types_t::block_container_t block_container_t; typedef typename adaptive_pool_types_t::block_container_traits_t block_container_traits_t; 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; 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; //!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) { 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); } } //!Destructor. Deallocates all allocated blocks. Never throws ~private_adaptive_node_pool_impl() { this->priv_clear(); } size_type get_real_num_node() const { return m_real_num_node; } //!Returns the segment manager. Never throws segment_manager_base_type* get_segment_manager_base()const { return container_detail::to_raw_pointer(mp_segment_mngr_base); } //!Allocates array of count elements. Can throw void *allocate_node() { this->priv_invariants(); //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 free_nodes_t &free_nodes = m_block_container.begin()->free_nodes; BOOST_ASSERT(!free_nodes.empty()); const size_type free_nodes_count = free_nodes.size(); void *first_node = container_detail::to_raw_pointer(free_nodes.pop_front()); 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(); return first_node; } else{ multiallocation_chain chain; this->priv_append_from_new_blocks(1, chain, IsAlignOnly()); return container_detail::to_raw_pointer(chain.pop_front()); } } //!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) { size_type i = 0; BOOST_TRY{ this->priv_invariants(); 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()); 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); 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; if(num_left < free_nodes_count_before){ const free_nodes_iterator it_bbeg(free_nodes.before_begin()); free_nodes_iterator it_bend(it_bbeg); for(size_type j = 0; j != num_elems; ++j){ ++it_bend; } free_nodes_iterator it_end = it_bend; ++it_end; free_nodes_iterator it_beg = it_bbeg; ++it_beg; free_nodes.erase_after(it_bbeg, it_end, num_elems); chain.incorporate_after(chain.last(), &*it_beg, &*it_bend, num_elems); //chain.splice_after(chain.last(), free_nodes, it_bbeg, it_bend, num_elems); BOOST_ASSERT(!free_nodes.empty()); } else{ const free_nodes_iterator it_beg(free_nodes.begin()), it_bend(free_nodes.last()); free_nodes.clear(); chain.incorporate_after(chain.last(), &*it_beg, &*it_bend, num_elems); block_container_traits_t::erase_first(m_block_container); } i += num_elems; } } BOOST_CATCH(...){ this->deallocate_nodes(chain); BOOST_RETHROW } BOOST_CATCH_END this->priv_invariants(); } //!Deallocates a linked list of nodes. Never throws void deallocate_nodes(multiallocation_chain &nodes) { this->priv_invariants(); //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. //Cache of the previous block block_info_t *prev_block_info = 0; //If block was empty before this call, it's not already //inserted in the block tree. bool prev_block_was_empty = false; typedef typename free_nodes_t::iterator free_nodes_iterator; { const free_nodes_iterator itbb(nodes.before_begin()), ite(nodes.end()); free_nodes_iterator itf(nodes.begin()), itbf(itbb); size_type splice_node_count = size_type(-1); while(itf != ite){ void *pElem = container_detail::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); ++splice_node_count; //If block change is detected calculate the cached block position in the tree if(&block_info != prev_block_info){ if(prev_block_info){ //Make sure we skip the initial "dummy" cache 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); splice_node_count = 0; } //Update cache with new data prev_block_was_empty = block_info.free_nodes.empty(); prev_block_info = &block_info; } itbf = itf; ++itf; } } if(prev_block_info){ //The loop reinserts all blocks except the last one const free_nodes_iterator itfirst(nodes.begin()), itlast(nodes.last()); 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); } } void deallocate_free_blocks() { this->priv_deallocate_free_blocks(0); } size_type num_free_nodes() { 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; } void swap(private_adaptive_node_pool_impl &other) { 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); } //Deprecated, use deallocate_free_blocks void deallocate_free_chunks() { this->priv_deallocate_free_blocks(0); } 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(container_detail::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 //!Deallocates all used memory. Never throws void priv_clear() { #ifndef NDEBUG block_iterator it = m_block_container.begin(); block_iterator itend = m_block_container.end(); size_type n_free_nodes = 0; for(; it != itend; ++it){ //Check for memory leak BOOST_ASSERT(it->free_nodes.size() == m_real_num_node); ++n_free_nodes; } BOOST_ASSERT(n_free_nodes == m_totally_free_blocks); #endif //Check for memory leaks this->priv_invariants(); multiallocation_chain chain; m_block_container.clear_and_dispose(block_destroyer(this, chain)); this->mp_segment_mngr_base->deallocate_many(chain); m_totally_free_blocks = 0; } block_info_t *priv_block_from_node(void *node, AlignOnlyFalse) const { 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; } block_info_t *priv_block_from_node(void *node, AlignOnlyTrue) const { return (block_info_t *)((std::size_t)node & std::size_t(~(m_real_block_alignment - 1))); } block_info_t *priv_block_from_node(void *node) const { return this->priv_block_from_node(node, IsAlignOnly()); } hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block) const { return this->priv_first_subblock_from_block(block, IsAlignOnly()); } hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, AlignOnlyFalse) const { 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; } hdr_offset_holder *priv_first_subblock_from_block(block_info_t *block, AlignOnlyTrue) const { return reinterpret_cast<hdr_offset_holder*>(block); } 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) { 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 *>(container_detail::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); } } } //!Allocates a several blocks of nodes. Can throw void priv_append_from_new_blocks(size_type min_elements, multiallocation_chain &chain, AlignOnlyTrue) { 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); } } } 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; 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); } } } 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_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 }; } //namespace container_detail { } //namespace container { } //namespace boost { #include <boost/container/detail/config_end.hpp> #endif //#ifndef BOOST_CONTAINER_DETAIL_ADAPTIVE_NODE_POOL_IMPL_HPP