#ifndef BOOST_SMART_PTR_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED | |
#define BOOST_SMART_PTR_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED | |
// MS compatible compilers support #pragma once | |
#if defined(_MSC_VER) && (_MSC_VER >= 1020) | |
# pragma once | |
#endif | |
// | |
// detail/quick_allocator.hpp | |
// | |
// Copyright (c) 2003 David Abrahams | |
// Copyright (c) 2003 Peter Dimov | |
// | |
// 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) | |
// | |
#include <boost/config.hpp> | |
#include <boost/smart_ptr/detail/lightweight_mutex.hpp> | |
#include <boost/type_traits/type_with_alignment.hpp> | |
#include <boost/type_traits/alignment_of.hpp> | |
#include <new> // ::operator new, ::operator delete | |
#include <cstddef> // std::size_t | |
namespace boost | |
{ | |
namespace detail | |
{ | |
template<unsigned size, unsigned align_> union freeblock | |
{ | |
typedef typename boost::type_with_alignment<align_>::type aligner_type; | |
aligner_type aligner; | |
char bytes[size]; | |
freeblock * next; | |
}; | |
template<unsigned size, unsigned align_> struct allocator_impl | |
{ | |
typedef freeblock<size, align_> block; | |
// It may seem odd to use such small pages. | |
// | |
// However, on a typical Windows implementation that uses | |
// the OS allocator, "normal size" pages interact with the | |
// "ordinary" operator new, slowing it down dramatically. | |
// | |
// 512 byte pages are handled by the small object allocator, | |
// and don't interfere with ::new. | |
// | |
// The other alternative is to use much bigger pages (1M.) | |
// | |
// It is surprisingly easy to hit pathological behavior by | |
// varying the page size. g++ 2.96 on Red Hat Linux 7.2, | |
// for example, passionately dislikes 496. 512 seems OK. | |
#if defined(BOOST_QA_PAGE_SIZE) | |
enum { items_per_page = BOOST_QA_PAGE_SIZE / size }; | |
#else | |
enum { items_per_page = 512 / size }; // 1048560 / size | |
#endif | |
#ifdef BOOST_HAS_THREADS | |
static lightweight_mutex & mutex() | |
{ | |
static freeblock< sizeof( lightweight_mutex ), boost::alignment_of< lightweight_mutex >::value > fbm; | |
static lightweight_mutex * pm = new( &fbm ) lightweight_mutex; | |
return *pm; | |
} | |
static lightweight_mutex * mutex_init; | |
#endif | |
static block * free; | |
static block * page; | |
static unsigned last; | |
static inline void * alloc() | |
{ | |
#ifdef BOOST_HAS_THREADS | |
lightweight_mutex::scoped_lock lock( mutex() ); | |
#endif | |
if(block * x = free) | |
{ | |
free = x->next; | |
return x; | |
} | |
else | |
{ | |
if(last == items_per_page) | |
{ | |
// "Listen to me carefully: there is no memory leak" | |
// -- Scott Meyers, Eff C++ 2nd Ed Item 10 | |
page = ::new block[items_per_page]; | |
last = 0; | |
} | |
return &page[last++]; | |
} | |
} | |
static inline void * alloc(std::size_t n) | |
{ | |
if(n != size) // class-specific new called for a derived object | |
{ | |
return ::operator new(n); | |
} | |
else | |
{ | |
#ifdef BOOST_HAS_THREADS | |
lightweight_mutex::scoped_lock lock( mutex() ); | |
#endif | |
if(block * x = free) | |
{ | |
free = x->next; | |
return x; | |
} | |
else | |
{ | |
if(last == items_per_page) | |
{ | |
page = ::new block[items_per_page]; | |
last = 0; | |
} | |
return &page[last++]; | |
} | |
} | |
} | |
static inline void dealloc(void * pv) | |
{ | |
if(pv != 0) // 18.4.1.1/13 | |
{ | |
#ifdef BOOST_HAS_THREADS | |
lightweight_mutex::scoped_lock lock( mutex() ); | |
#endif | |
block * pb = static_cast<block *>(pv); | |
pb->next = free; | |
free = pb; | |
} | |
} | |
static inline void dealloc(void * pv, std::size_t n) | |
{ | |
if(n != size) // class-specific delete called for a derived object | |
{ | |
::operator delete(pv); | |
} | |
else if(pv != 0) // 18.4.1.1/13 | |
{ | |
#ifdef BOOST_HAS_THREADS | |
lightweight_mutex::scoped_lock lock( mutex() ); | |
#endif | |
block * pb = static_cast<block *>(pv); | |
pb->next = free; | |
free = pb; | |
} | |
} | |
}; | |
#ifdef BOOST_HAS_THREADS | |
template<unsigned size, unsigned align_> | |
lightweight_mutex * allocator_impl<size, align_>::mutex_init = &allocator_impl<size, align_>::mutex(); | |
#endif | |
template<unsigned size, unsigned align_> | |
freeblock<size, align_> * allocator_impl<size, align_>::free = 0; | |
template<unsigned size, unsigned align_> | |
freeblock<size, align_> * allocator_impl<size, align_>::page = 0; | |
template<unsigned size, unsigned align_> | |
unsigned allocator_impl<size, align_>::last = allocator_impl<size, align_>::items_per_page; | |
template<class T> | |
struct quick_allocator: public allocator_impl< sizeof(T), boost::alignment_of<T>::value > | |
{ | |
}; | |
} // namespace detail | |
} // namespace boost | |
#endif // #ifndef BOOST_SMART_PTR_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED |