| ////////////////////////////////////////////////////////////////////////////// |
| // |
| // (C) Copyright Ion Gaztanaga 2008-2013. 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_POOLED_NODE_ALLOCATOR_HPP |
| #define BOOST_CONTAINER_POOLED_NODE_ALLOCATOR_HPP |
| |
| #ifndef BOOST_CONFIG_HPP |
| # include <boost/config.hpp> |
| #endif |
| |
| #if defined(BOOST_HAS_PRAGMA_ONCE) |
| # pragma once |
| #endif |
| |
| #include <boost/container/detail/config_begin.hpp> |
| #include <boost/container/detail/workaround.hpp> |
| #include <boost/container/container_fwd.hpp> |
| #include <boost/container/throw_exception.hpp> |
| #include <boost/container/detail/node_pool.hpp> |
| #include <boost/container/detail/mpl.hpp> |
| #include <boost/container/detail/multiallocation_chain.hpp> |
| #include <boost/container/detail/alloc_lib_auto_link.hpp> |
| #include <boost/container/detail/singleton.hpp> |
| |
| #include <boost/assert.hpp> |
| #include <boost/static_assert.hpp> |
| #include <cstddef> |
| |
| namespace boost { |
| namespace container { |
| |
| //!An STL node allocator that uses a modified DlMalloc as memory |
| //!source. |
| //! |
| //!This node allocator shares a segregated storage between all instances |
| //!of node_allocator with equal sizeof(T). |
| //! |
| //!NodesPerBlock is the number of nodes allocated at once when the allocator |
| //!runs out of nodes |
| #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED |
| template |
| < class T |
| , std::size_t NodesPerBlock = NodeAlloc_nodes_per_block> |
| #else |
| template |
| < class T |
| , std::size_t NodesPerBlock |
| , std::size_t Version> |
| #endif |
| class node_allocator |
| { |
| #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED |
| //! If Version is 1, the allocator is a STL conforming allocator. If Version is 2, |
| //! the allocator offers advanced expand in place and burst allocation capabilities. |
| public: |
| typedef unsigned int allocation_type; |
| typedef node_allocator<T, NodesPerBlock, Version> self_t; |
| |
| static const std::size_t nodes_per_block = NodesPerBlock; |
| |
| BOOST_STATIC_ASSERT((Version <=2)); |
| #endif |
| |
| public: |
| //------- |
| typedef T value_type; |
| typedef T * pointer; |
| typedef const T * const_pointer; |
| typedef typename ::boost::container:: |
| container_detail::unvoid<T>::type & reference; |
| typedef const typename ::boost::container:: |
| container_detail::unvoid<T>::type & const_reference; |
| typedef std::size_t size_type; |
| typedef std::ptrdiff_t difference_type; |
| |
| typedef boost::container::container_detail:: |
| version_type<self_t, Version> version; |
| |
| #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED |
| typedef boost::container::container_detail:: |
| basic_multiallocation_chain<void*> multiallocation_chain_void; |
| typedef boost::container::container_detail:: |
| transform_multiallocation_chain |
| <multiallocation_chain_void, T> multiallocation_chain; |
| #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED |
| |
| //!Obtains node_allocator from |
| //!node_allocator |
| template<class T2> |
| struct rebind |
| { |
| typedef node_allocator< T2, NodesPerBlock |
| #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED |
| , Version |
| #endif |
| > other; |
| }; |
| |
| #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED |
| private: |
| //!Not assignable from related node_allocator |
| template<class T2, std::size_t N2> |
| node_allocator& operator= |
| (const node_allocator<T2, N2>&); |
| |
| //!Not assignable from other node_allocator |
| node_allocator& operator=(const node_allocator&); |
| #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED |
| |
| public: |
| |
| //!Default constructor |
| node_allocator() BOOST_NOEXCEPT_OR_NOTHROW |
| {} |
| |
| //!Copy constructor from other node_allocator. |
| node_allocator(const node_allocator &) BOOST_NOEXCEPT_OR_NOTHROW |
| {} |
| |
| //!Copy constructor from related node_allocator. |
| template<class T2> |
| node_allocator |
| (const node_allocator<T2, NodesPerBlock |
| #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED |
| , Version |
| #endif |
| > &) BOOST_NOEXCEPT_OR_NOTHROW |
| {} |
| |
| //!Destructor |
| ~node_allocator() BOOST_NOEXCEPT_OR_NOTHROW |
| {} |
| |
| //!Returns the number of elements that could be allocated. |
| //!Never throws |
| size_type max_size() const |
| { return size_type(-1)/sizeof(T); } |
| |
| //!Allocate memory for an array of count elements. |
| //!Throws std::bad_alloc if there is no enough memory |
| pointer allocate(size_type count, const void * = 0) |
| { |
| if(BOOST_UNLIKELY(count > this->max_size())) |
| boost::container::throw_bad_alloc(); |
| |
| if(Version == 1 && count == 1){ |
| typedef container_detail::shared_node_pool |
| <sizeof(T), NodesPerBlock> shared_pool_t; |
| typedef container_detail::singleton_default<shared_pool_t> singleton_t; |
| return pointer(static_cast<T*>(singleton_t::instance().allocate_node())); |
| } |
| else{ |
| void *ret = boost_cont_malloc(count*sizeof(T)); |
| if(BOOST_UNLIKELY(!ret)) |
| boost::container::throw_bad_alloc(); |
| return static_cast<pointer>(ret); |
| } |
| } |
| |
| //!Deallocate allocated memory. |
| //!Never throws |
| void deallocate(const pointer &ptr, size_type count) BOOST_NOEXCEPT_OR_NOTHROW |
| { |
| (void)count; |
| if(Version == 1 && count == 1){ |
| typedef container_detail::shared_node_pool |
| <sizeof(T), NodesPerBlock> shared_pool_t; |
| typedef container_detail::singleton_default<shared_pool_t> singleton_t; |
| singleton_t::instance().deallocate_node(ptr); |
| } |
| else{ |
| boost_cont_free(ptr); |
| } |
| } |
| |
| //!Deallocates all free blocks of the pool |
| static void deallocate_free_blocks() BOOST_NOEXCEPT_OR_NOTHROW |
| { |
| typedef container_detail::shared_node_pool |
| <sizeof(T), NodesPerBlock> shared_pool_t; |
| typedef container_detail::singleton_default<shared_pool_t> singleton_t; |
| singleton_t::instance().deallocate_free_blocks(); |
| } |
| |
| pointer allocation_command |
| (allocation_type command, size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse) |
| { |
| BOOST_STATIC_ASSERT(( Version > 1 )); |
| pointer ret = this->priv_allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse); |
| if(BOOST_UNLIKELY(!ret && !(command & BOOST_CONTAINER_NOTHROW_ALLOCATION))) |
| boost::container::throw_bad_alloc(); |
| return ret; |
| } |
| |
| //!Returns maximum the number of objects the previously allocated memory |
| //!pointed by p can hold. |
| size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW |
| { |
| BOOST_STATIC_ASSERT(( Version > 1 )); |
| return boost_cont_size(p); |
| } |
| |
| //!Allocates just one object. Memory allocated with this function |
| //!must be deallocated only with deallocate_one(). |
| //!Throws bad_alloc if there is no enough memory |
| pointer allocate_one() |
| { |
| BOOST_STATIC_ASSERT(( Version > 1 )); |
| typedef container_detail::shared_node_pool |
| <sizeof(T), NodesPerBlock> shared_pool_t; |
| typedef container_detail::singleton_default<shared_pool_t> singleton_t; |
| return (pointer)singleton_t::instance().allocate_node(); |
| } |
| |
| //!Allocates many elements of size == 1. |
| //!Elements must be individually deallocated with deallocate_one() |
| void allocate_individual(std::size_t num_elements, multiallocation_chain &chain) |
| { |
| BOOST_STATIC_ASSERT(( Version > 1 )); |
| typedef container_detail::shared_node_pool |
| <sizeof(T), NodesPerBlock> shared_pool_t; |
| typedef container_detail::singleton_default<shared_pool_t> singleton_t; |
| typename shared_pool_t::multiallocation_chain ch; |
| singleton_t::instance().allocate_nodes(num_elements, ch); |
| chain.incorporate_after(chain.before_begin(), (T*)&*ch.begin(), (T*)&*ch.last(), ch.size()); |
| } |
| |
| //!Deallocates memory previously allocated with allocate_one(). |
| //!You should never use deallocate_one to deallocate memory allocated |
| //!with other functions different from allocate_one(). Never throws |
| void deallocate_one(pointer p) BOOST_NOEXCEPT_OR_NOTHROW |
| { |
| BOOST_STATIC_ASSERT(( Version > 1 )); |
| typedef container_detail::shared_node_pool |
| <sizeof(T), NodesPerBlock> shared_pool_t; |
| typedef container_detail::singleton_default<shared_pool_t> singleton_t; |
| singleton_t::instance().deallocate_node(p); |
| } |
| |
| void deallocate_individual(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW |
| { |
| BOOST_STATIC_ASSERT(( Version > 1 )); |
| typedef container_detail::shared_node_pool |
| <sizeof(T), NodesPerBlock> shared_pool_t; |
| typedef container_detail::singleton_default<shared_pool_t> singleton_t; |
| typename shared_pool_t::multiallocation_chain ch(&*chain.begin(), &*chain.last(), chain.size()); |
| singleton_t::instance().deallocate_nodes(ch); |
| } |
| |
| //!Allocates many elements of size elem_size. |
| //!Elements must be individually deallocated with deallocate() |
| void allocate_many(size_type elem_size, std::size_t n_elements, multiallocation_chain &chain) |
| { |
| BOOST_STATIC_ASSERT(( Version > 1 )); |
| boost_cont_memchain ch; |
| BOOST_CONTAINER_MEMCHAIN_INIT(&ch); |
| if(BOOST_UNLIKELY(!boost_cont_multialloc_nodes(n_elements, elem_size*sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch))){ |
| boost::container::throw_bad_alloc(); |
| } |
| chain.incorporate_after( chain.before_begin() |
| , (T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) |
| , (T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) |
| , BOOST_CONTAINER_MEMCHAIN_SIZE(&ch)); |
| } |
| |
| //!Allocates n_elements elements, each one of size elem_sizes[i] |
| //!Elements must be individually deallocated with deallocate() |
| void allocate_many(const size_type *elem_sizes, size_type n_elements, multiallocation_chain &chain) |
| { |
| BOOST_STATIC_ASSERT(( Version > 1 )); |
| boost_cont_memchain ch; |
| boost_cont_multialloc_arrays(n_elements, elem_sizes, sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch); |
| if(BOOST_UNLIKELY(BOOST_CONTAINER_MEMCHAIN_EMPTY(&ch))){ |
| boost::container::throw_bad_alloc(); |
| } |
| chain.incorporate_after( chain.before_begin() |
| , (T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) |
| , (T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch) |
| , BOOST_CONTAINER_MEMCHAIN_SIZE(&ch)); |
| } |
| |
| void deallocate_many(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW |
| { |
| BOOST_STATIC_ASSERT(( Version > 1 )); |
| void *first = &*chain.begin(); |
| void *last = &*chain.last(); |
| size_t num = chain.size(); |
| boost_cont_memchain ch; |
| BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, first, last, num); |
| boost_cont_multidealloc(&ch); |
| } |
| |
| //!Swaps allocators. Does not throw. If each allocator is placed in a |
| //!different memory segment, the result is undefined. |
| friend void swap(self_t &, self_t &) BOOST_NOEXCEPT_OR_NOTHROW |
| {} |
| |
| //!An allocator always compares to true, as memory allocated with one |
| //!instance can be deallocated by another instance |
| friend bool operator==(const node_allocator &, const node_allocator &) BOOST_NOEXCEPT_OR_NOTHROW |
| { return true; } |
| |
| //!An allocator always compares to false, as memory allocated with one |
| //!instance can be deallocated by another instance |
| friend bool operator!=(const node_allocator &, const node_allocator &) BOOST_NOEXCEPT_OR_NOTHROW |
| { return false; } |
| |
| private: |
| pointer priv_allocation_command |
| (allocation_type command, std::size_t limit_size |
| ,size_type &prefer_in_recvd_out_size |
| ,pointer &reuse) |
| { |
| std::size_t const preferred_size = prefer_in_recvd_out_size; |
| boost_cont_command_ret_t ret = {0 , 0}; |
| if((limit_size > this->max_size()) | (preferred_size > this->max_size())){ |
| return pointer(); |
| } |
| std::size_t l_size = limit_size*sizeof(T); |
| std::size_t p_size = preferred_size*sizeof(T); |
| std::size_t r_size; |
| { |
| void* reuse_ptr_void = reuse; |
| ret = boost_cont_allocation_command(command, sizeof(T), l_size, p_size, &r_size, reuse_ptr_void); |
| reuse = static_cast<T*>(reuse_ptr_void); |
| } |
| prefer_in_recvd_out_size = r_size/sizeof(T); |
| return (pointer)ret.first; |
| } |
| }; |
| |
| } //namespace container { |
| } //namespace boost { |
| |
| #include <boost/container/detail/config_end.hpp> |
| |
| #endif //#ifndef BOOST_CONTAINER_POOLED_NODE_ALLOCATOR_HPP |