369 lines
14 KiB
C++
369 lines
14 KiB
C++
|
//////////////////////////////////////////////////////////////////////////////
|
||
|
|
//
|
||
|
|
// (C) Copyright Ion Gaztanaga 2007-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_ALLOCATOR_HPP
|
||
|
|
#define BOOST_CONTAINER_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/detail/version_type.hpp>
|
||
|
|
#include <boost/container/throw_exception.hpp>
|
||
|
|
#include <boost/container/detail/dlmalloc.hpp>
|
||
|
|
#include <boost/container/detail/multiallocation_chain.hpp>
|
||
|
|
#include <boost/static_assert.hpp>
|
||
|
|
#include <cstddef>
|
||
|
|
#include <cassert>
|
||
|
|
|
||
|
|
//!\file
|
||
|
|
|
||
|
|
namespace boost {
|
||
|
|
namespace container {
|
||
|
|
|
||
|
|
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
|
||
|
|
|
||
|
|
template<unsigned Version, unsigned int AllocationDisableMask>
|
||
|
|
class allocator<void, Version, AllocationDisableMask>
|
||
|
|
{
|
||
|
|
typedef allocator<void, Version, AllocationDisableMask> self_t;
|
||
|
|
public:
|
||
|
|
typedef void value_type;
|
||
|
|
typedef void * pointer;
|
||
|
|
typedef const void* const_pointer;
|
||
|
|
typedef int & reference;
|
||
|
|
typedef const int & 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;
|
||
|
|
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
|
||
|
|
|
||
|
|
//!Obtains an allocator that allocates
|
||
|
|
//!objects of type T2
|
||
|
|
template<class T2>
|
||
|
|
struct rebind
|
||
|
|
{
|
||
|
|
typedef allocator< T2
|
||
|
|
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
|
||
|
|
, Version, AllocationDisableMask
|
||
|
|
#endif
|
||
|
|
> other;
|
||
|
|
};
|
||
|
|
|
||
|
|
//!Default constructor
|
||
|
|
//!Never throws
|
||
|
|
allocator()
|
||
|
|
{}
|
||
|
|
|
||
|
|
//!Constructor from other allocator.
|
||
|
|
//!Never throws
|
||
|
|
allocator(const allocator &)
|
||
|
|
{}
|
||
|
|
|
||
|
|
//!Constructor from related allocator.
|
||
|
|
//!Never throws
|
||
|
|
template<class T2>
|
||
|
|
allocator(const allocator<T2, Version, AllocationDisableMask> &)
|
||
|
|
{}
|
||
|
|
};
|
||
|
|
|
||
|
|
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
|
||
|
|
|
||
|
|
//! This class is an extended STL-compatible that offers advanced allocation mechanism
|
||
|
|
//!(in-place expansion, shrinking, burst-allocation...)
|
||
|
|
//!
|
||
|
|
//! This allocator is a wrapper around a modified DLmalloc.
|
||
|
|
//! 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.
|
||
|
|
//!
|
||
|
|
//! AllocationDisableMask works only if Version is 2 and it can be an inclusive OR
|
||
|
|
//! of allocation types the user wants to disable.
|
||
|
|
template< class T
|
||
|
|
, unsigned Version BOOST_CONTAINER_DOCONLY(=2)
|
||
|
|
, unsigned int AllocationDisableMask BOOST_CONTAINER_DOCONLY(=0)>
|
||
|
|
class allocator
|
||
|
|
{
|
||
|
|
typedef unsigned int allocation_type;
|
||
|
|
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
|
||
|
|
private:
|
||
|
|
|
||
|
|
//Self type
|
||
|
|
typedef allocator<T, Version, AllocationDisableMask> self_t;
|
||
|
|
|
||
|
|
//Not assignable from related allocator
|
||
|
|
template<class T2, unsigned int Version2, unsigned int AllocationDisableMask2>
|
||
|
|
allocator& operator=(const allocator<T2, Version2, AllocationDisableMask2>&);
|
||
|
|
|
||
|
|
static const unsigned int ForbiddenMask =
|
||
|
|
BOOST_CONTAINER_ALLOCATE_NEW | BOOST_CONTAINER_EXPAND_BWD | BOOST_CONTAINER_EXPAND_FWD ;
|
||
|
|
|
||
|
|
//The mask can't disable all the allocation types
|
||
|
|
BOOST_STATIC_ASSERT(( (AllocationDisableMask & ForbiddenMask) != ForbiddenMask ));
|
||
|
|
|
||
|
|
//The mask is only valid for version 2 allocators
|
||
|
|
BOOST_STATIC_ASSERT(( Version != 1 || (AllocationDisableMask == 0) ));
|
||
|
|
|
||
|
|
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
|
||
|
|
|
||
|
|
public:
|
||
|
|
typedef T value_type;
|
||
|
|
typedef T * pointer;
|
||
|
|
typedef const T * const_pointer;
|
||
|
|
typedef T & reference;
|
||
|
|
typedef const T & 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*> void_multiallocation_chain;
|
||
|
|
|
||
|
|
typedef boost::container::container_detail::
|
||
|
|
transform_multiallocation_chain
|
||
|
|
<void_multiallocation_chain, T> multiallocation_chain;
|
||
|
|
#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
|
||
|
|
|
||
|
|
//!Obtains an allocator that allocates
|
||
|
|
//!objects of type T2
|
||
|
|
template<class T2>
|
||
|
|
struct rebind
|
||
|
|
{
|
||
|
|
typedef allocator<T2, Version, AllocationDisableMask> other;
|
||
|
|
};
|
||
|
|
|
||
|
|
//!Default constructor
|
||
|
|
//!Never throws
|
||
|
|
allocator() BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{}
|
||
|
|
|
||
|
|
//!Constructor from other allocator.
|
||
|
|
//!Never throws
|
||
|
|
allocator(const allocator &) BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{}
|
||
|
|
|
||
|
|
//!Constructor from related allocator.
|
||
|
|
//!Never throws
|
||
|
|
template<class T2>
|
||
|
|
allocator(const allocator<T2
|
||
|
|
#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
|
||
|
|
, Version, AllocationDisableMask
|
||
|
|
#endif
|
||
|
|
> &) BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{}
|
||
|
|
|
||
|
|
//!Allocates memory for an array of count elements.
|
||
|
|
//!Throws std::bad_alloc if there is no enough memory
|
||
|
|
//!If Version is 2, this allocated memory can only be deallocated
|
||
|
|
//!with deallocate() or (for Version == 2) deallocate_many()
|
||
|
|
pointer allocate(size_type count, const void * hint= 0)
|
||
|
|
{
|
||
|
|
(void)hint;
|
||
|
|
if(count > this->max_size())
|
||
|
|
boost::container::throw_bad_alloc();
|
||
|
|
void *ret = dlmalloc_malloc(count*sizeof(T));
|
||
|
|
if(!ret)
|
||
|
|
boost::container::throw_bad_alloc();
|
||
|
|
return static_cast<pointer>(ret);
|
||
|
|
}
|
||
|
|
|
||
|
|
//!Deallocates previously allocated memory.
|
||
|
|
//!Never throws
|
||
|
|
void deallocate(pointer ptr, size_type) BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{ dlmalloc_free(ptr); }
|
||
|
|
|
||
|
|
//!Returns the maximum number of elements that could be allocated.
|
||
|
|
//!Never throws
|
||
|
|
size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{ return size_type(-1)/sizeof(T); }
|
||
|
|
|
||
|
|
//!Swaps two allocators, does nothing
|
||
|
|
//!because this allocator is stateless
|
||
|
|
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 allocator &, const 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 allocator &, const allocator &) BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{ return false; }
|
||
|
|
|
||
|
|
//!An advanced function that offers in-place expansion shrink to fit and new allocation
|
||
|
|
//!capabilities. Memory allocated with this function can only be deallocated with deallocate()
|
||
|
|
//!or deallocate_many().
|
||
|
|
//!This function is available only with Version == 2
|
||
|
|
pointer allocation_command(allocation_type command,
|
||
|
|
size_type limit_size,
|
||
|
|
size_type &prefer_in_recvd_out_size,
|
||
|
|
pointer &reuse)
|
||
|
|
{
|
||
|
|
BOOST_STATIC_ASSERT(( Version > 1 ));
|
||
|
|
const allocation_type mask(AllocationDisableMask);
|
||
|
|
command &= ~mask;
|
||
|
|
pointer ret = this->priv_allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse);
|
||
|
|
if(!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.
|
||
|
|
//!Memory must not have been allocated with
|
||
|
|
//!allocate_one or allocate_individual.
|
||
|
|
//!This function is available only with Version == 2
|
||
|
|
size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{
|
||
|
|
BOOST_STATIC_ASSERT(( Version > 1 ));
|
||
|
|
return dlmalloc_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
|
||
|
|
//!This function is available only with Version == 2
|
||
|
|
pointer allocate_one()
|
||
|
|
{
|
||
|
|
BOOST_STATIC_ASSERT(( Version > 1 ));
|
||
|
|
return this->allocate(1);
|
||
|
|
}
|
||
|
|
|
||
|
|
//!Allocates many elements of size == 1.
|
||
|
|
//!Elements must be individually deallocated with deallocate_one()
|
||
|
|
//!This function is available only with Version == 2
|
||
|
|
void allocate_individual(std::size_t num_elements, multiallocation_chain &chain)
|
||
|
|
{
|
||
|
|
BOOST_STATIC_ASSERT(( Version > 1 ));
|
||
|
|
this->allocate_many(1, num_elements, chain);
|
||
|
|
}
|
||
|
|
|
||
|
|
//!Deallocates memory previously allocated with allocate_one().
|
||
|
|
//!You should never use deallocate_one to deallocate memory allocated
|
||
|
|
//!with other functions different from allocate_one() or allocate_individual.
|
||
|
|
//Never throws
|
||
|
|
void deallocate_one(pointer p) BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{
|
||
|
|
BOOST_STATIC_ASSERT(( Version > 1 ));
|
||
|
|
return this->deallocate(p, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
//!Deallocates memory allocated with allocate_one() or allocate_individual().
|
||
|
|
//!This function is available only with Version == 2
|
||
|
|
void deallocate_individual(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{
|
||
|
|
BOOST_STATIC_ASSERT(( Version > 1 ));
|
||
|
|
return this->deallocate_many(chain);
|
||
|
|
}
|
||
|
|
|
||
|
|
//!Allocates many elements of size elem_size.
|
||
|
|
//!Elements must be individually deallocated with deallocate()
|
||
|
|
//!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 ));/*
|
||
|
|
dlmalloc_memchain ch;
|
||
|
|
BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
|
||
|
|
if(!dlmalloc_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_FIRSTMEM(&ch)
|
||
|
|
,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&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]
|
||
|
|
//!Elements must be individually deallocated with deallocate()
|
||
|
|
//!This function is available only with Version == 2
|
||
|
|
void allocate_many(const size_type *elem_sizes, size_type n_elements, multiallocation_chain &chain)
|
||
|
|
{
|
||
|
|
BOOST_STATIC_ASSERT(( Version > 1 ));
|
||
|
|
dlmalloc_memchain ch;
|
||
|
|
BOOST_CONTAINER_MEMCHAIN_INIT(&ch);
|
||
|
|
if(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &ch)){
|
||
|
|
boost::container::throw_bad_alloc();
|
||
|
|
}
|
||
|
|
chain.incorporate_after(chain.before_begin()
|
||
|
|
,(T*)BOOST_CONTAINER_MEMCHAIN_FIRSTMEM(&ch)
|
||
|
|
,(T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
|
||
|
|
,BOOST_CONTAINER_MEMCHAIN_SIZE(&ch) );
|
||
|
|
/*
|
||
|
|
if(!dlmalloc_multialloc_arrays(n_elements, elem_sizes, sizeof(T), DL_MULTIALLOC_DEFAULT_CONTIGUOUS, reinterpret_cast<dlmalloc_memchain *>(&chain))){
|
||
|
|
boost::container::throw_bad_alloc();
|
||
|
|
}*/
|
||
|
|
}
|
||
|
|
|
||
|
|
//!Deallocates several elements allocated by
|
||
|
|
//!allocate_many(), allocate(), or allocation_command().
|
||
|
|
//!This function is available only with Version == 2
|
||
|
|
void deallocate_many(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW
|
||
|
|
{
|
||
|
|
BOOST_STATIC_ASSERT(( Version > 1 ));
|
||
|
|
dlmalloc_memchain ch;
|
||
|
|
void *beg(&*chain.begin()), *last(&*chain.last());
|
||
|
|
size_t size(chain.size());
|
||
|
|
BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, beg, last, size);
|
||
|
|
dlmalloc_multidealloc(&ch);
|
||
|
|
//dlmalloc_multidealloc(reinterpret_cast<dlmalloc_memchain *>(&chain));
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
pointer priv_allocation_command
|
||
|
|
(allocation_type command, std::size_t limit_size
|
||
|
|
,size_type &prefer_in_recvd_out_size
|
||
|
|
,pointer &reuse_ptr)
|
||
|
|
{
|
||
|
|
std::size_t const preferred_size = prefer_in_recvd_out_size;
|
||
|
|
dlmalloc_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_ptr;
|
||
|
|
ret = dlmalloc_allocation_command(command, sizeof(T), l_size, p_size, &r_size, reuse_ptr_void);
|
||
|
|
reuse_ptr = ret.second ? static_cast<T*>(reuse_ptr_void) : 0;
|
||
|
|
}
|
||
|
|
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 //BOOST_CONTAINER_ALLOCATOR_HPP
|
||
|
|
|