// Variables used to configure the behavior of the allocator,
// assigned and explained in detail below.
struct _Tune
- {
+ {
// Compile time constants for the default _Tune values.
enum { _S_align = 8 };
enum { _S_max_bytes = 128 };
_M_chunk_size(__chunk), _M_max_threads(__maxthreads),
_M_freelist_headroom(__headroom), _M_force_new(__force)
{ }
-
- bool
- is_default() const
- {
- bool __ret = true;
- __ret &= _M_align == _S_align;
- __ret &= _M_max_bytes == _S_max_bytes;
- __ret &= _M_min_bin == _S_min_bin;
- __ret &= _M_chunk_size == _S_chunk_size;
- __ret &= _M_max_threads == _S_max_threads;
- __ret &= _M_freelist_headroom == _S_freelist_headroom;
- return __ret;
- }
};
struct _Block_address
_M_get_align()
{ return _M_options._M_align; }
- explicit __pool_base()
+ explicit
+ __pool_base()
: _M_options(_Tune()), _M_binmap(NULL), _M_init(false) { }
- explicit __pool_base(const _Tune& __tune)
- : _M_options(__tune), _M_binmap(NULL), _M_init(false) { }
+ explicit
+ __pool_base(const _Tune& __options)
+ : _M_options(__options), _M_binmap(NULL), _M_init(false) { }
+
+ private:
+ explicit
+ __pool_base(const __pool_base&);
+
+ __pool_base&
+ operator=(const __pool_base&);
protected:
// Configuration options.
_Binmap_type* _M_binmap;
- // We need to create the initial lists and set up some variables
- // before we can answer to the first request for memory.
+ // Configuration of the pool object via _M_options can happen
+ // after construction but before initialization. After
+ // initialization is complete, this variable is set to true.
bool _M_init;
};
template<>
class __pool<false>;
+ // Specialization for single thread.
+ template<>
+ class __pool<false> : public __pool_base
+ {
+ public:
+ union _Block_record
+ {
+ // Points to the block_record of the next free block.
+ _Block_record* volatile _M_next;
+ };
+
+ struct _Bin_record
+ {
+ // An "array" of pointers to the first free block.
+ _Block_record** volatile _M_first;
+ // A list of the initial addresses of all allocated blocks.
+ _Block_address* _M_address;
+ };
+
+ void
+ _M_initialize_once()
+ {
+ if (__builtin_expect(_M_init == false, false))
+ _M_initialize();
+ }
+
+ void
+ _M_destroy() throw();
+
+ char*
+ _M_reserve_block(size_t __bytes, const size_t __thread_id);
+
+ void
+ _M_reclaim_block(char* __p, size_t __bytes);
+
+ size_t
+ _M_get_thread_id() { return 0; }
+
+ const _Bin_record&
+ _M_get_bin(size_t __which)
+ { return _M_bin[__which]; }
+
+ void
+ _M_adjust_freelist(const _Bin_record&, _Block_record*, size_t)
+ { }
+
+ explicit __pool()
+ : _M_bin(NULL), _M_bin_size(1) { }
+
+ explicit __pool(const __pool_base::_Tune& __tune)
+ : __pool_base(__tune), _M_bin(NULL), _M_bin_size(1) { }
+
+ private:
+ // An "array" of bin_records each of which represents a specific
+ // power of 2 size. Memory to this "array" is allocated in
+ // _M_initialize().
+ _Bin_record* volatile _M_bin;
+
+ // Actual value calculated in _M_initialize().
+ size_t _M_bin_size;
+
+ void
+ _M_initialize();
+ };
+
#ifdef __GTHREADS
- // Specialization for thread enabled, via gthreads.h.
+ // Specialization for thread enabled, via gthreads.h.
template<>
class __pool<true> : public __pool_base
{
_M_once = __tmp;
}
- ~__pool() { }
-
private:
// An "array" of bin_records each of which represents a specific
// power of 2 size. Memory to this "array" is allocated in
};
#endif
- // Specialization for single thread.
- template<>
- class __pool<false> : public __pool_base
- {
- public:
- union _Block_record
- {
- // Points to the block_record of the next free block.
- _Block_record* volatile _M_next;
- };
-
- struct _Bin_record
- {
- // An "array" of pointers to the first free block.
- _Block_record** volatile _M_first;
- // A list of the initial addresses of all allocated blocks.
- _Block_address* _M_address;
- };
-
- void
- _M_initialize_once()
- {
- if (__builtin_expect(_M_init == false, false))
- _M_initialize();
- }
+ template<template <bool> class _PoolTp, bool _Thread>
+ struct __common_pool_policy;
- void
- _M_destroy() throw();
-
- char*
- _M_reserve_block(size_t __bytes, const size_t __thread_id);
-
- void
- _M_reclaim_block(char* __p, size_t __bytes);
-
- size_t
- _M_get_thread_id() { return 0; }
-
- const _Bin_record&
- _M_get_bin(size_t __which)
- { return _M_bin[__which]; }
-
- void
- _M_adjust_freelist(const _Bin_record&, _Block_record*, size_t)
- { }
-
- explicit __pool()
- : _M_bin(NULL), _M_bin_size(1) { }
-
- explicit __pool(const __pool_base::_Tune& __tune)
- : __pool_base(__tune), _M_bin(NULL), _M_bin_size(1) { }
-
- ~__pool() { }
-
- private:
- // An "array" of bin_records each of which represents a specific
- // power of 2 size. Memory to this "array" is allocated in
- // _M_initialize().
- _Bin_record* volatile _M_bin;
-
- // Actual value calculated in _M_initialize().
- size_t _M_bin_size;
-
- void
- _M_initialize();
- };
-
- template<bool _Thread>
- struct __common_pool_policy
+ template<template <bool> class _PoolTp>
+ struct __common_pool_policy<_PoolTp, false>
{
- typedef __pool<_Thread> __pool_type;
-
- template<typename _Tp1, bool _Thread1 = _Thread>
- struct _M_rebind;
-
- template<typename _Tp1>
- struct _M_rebind<_Tp1, true>
- { typedef __common_pool_policy<true> other; };
-
- template<typename _Tp1>
- struct _M_rebind<_Tp1, false>
- { typedef __common_pool_policy<false> other; };
+ typedef _PoolTp<false> pool_type;
+
+ template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
+ bool _Thread1 = false>
+ struct _M_rebind
+ { typedef __common_pool_policy<_PoolTp1, _Thread1> other; };
- static __pool_type&
+ static pool_type&
_S_get_pool()
{
- static __pool_type _S_pool;
+ static pool_type _S_pool;
return _S_pool;
}
}
};
- template<>
- struct __common_pool_policy<true>;
-
#ifdef __GTHREADS
- template<>
- struct __common_pool_policy<true>
+ template<template <bool> class _PoolTp>
+ struct __common_pool_policy<_PoolTp, true>
{
- typedef __pool<true> __pool_type;
-
- template<typename _Tp1, bool _Thread1 = true>
- struct _M_rebind;
-
- template<typename _Tp1>
- struct _M_rebind<_Tp1, true>
- { typedef __common_pool_policy<true> other; };
-
- template<typename _Tp1>
- struct _M_rebind<_Tp1, false>
- { typedef __common_pool_policy<false> other; };
+ typedef _PoolTp<true> pool_type;
+
+ template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
+ bool _Thread1 = true>
+ struct _M_rebind
+ { typedef __common_pool_policy<_PoolTp1, _Thread1> other; };
- static __pool_type&
+ static pool_type&
_S_get_pool()
{
- static __pool_type _S_pool;
+ static pool_type _S_pool;
return _S_pool;
}
- static void
- _S_destroy_thread_key(void* __freelist_pos)
- { _S_get_pool()._M_destroy_thread_key(__freelist_pos); }
-
- static void
- _S_initialize()
- { _S_get_pool()._M_initialize(_S_destroy_thread_key); }
-
static void
_S_initialize_once()
{
__init = true;
}
}
+
+ private:
+ static void
+ _S_destroy_thread_key(void* __freelist_pos)
+ { _S_get_pool()._M_destroy_thread_key(__freelist_pos); }
+
+ static void
+ _S_initialize()
+ { _S_get_pool()._M_initialize(_S_destroy_thread_key); }
};
#endif
+
+ template<typename _Tp, template <bool> class _PoolTp, bool _Thread>
+ struct __per_type_pool_policy;
- template<typename _Tp, bool _Thread>
- struct __per_type_pool_policy
+ template<typename _Tp, template <bool> class _PoolTp>
+ struct __per_type_pool_policy<_Tp, _PoolTp, false>
{
- typedef __pool<_Thread> __pool_type;
-
- template<typename _Tp1, bool _Thread1 = _Thread>
- struct _M_rebind;
+ typedef _Tp value_type;
+ typedef _PoolTp<false> pool_type;
- template<typename _Tp1>
- struct _M_rebind<_Tp1, false>
- { typedef __per_type_pool_policy<_Tp1, false> other; };
+ template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
+ bool _Thread1 = false>
+ struct _M_rebind
+ { typedef __per_type_pool_policy<_Tp1, _PoolTp1, _Thread1> other; };
- template<typename _Tp1>
- struct _M_rebind<_Tp1, true>
- { typedef __per_type_pool_policy<_Tp1, true> other; };
-
- // Avoid static initialization ordering issues.
- static __pool_type&
- _S_get_pool()
+ static pool_type&
+ _S_get_pool()
{
- // Sane defaults for the __pool_type.
- const static size_t __align = __alignof__(_Tp) >= sizeof(typename __pool_type::_Block_record) ? __alignof__(_Tp) : sizeof(typename __pool_type::_Block_record);
- static __pool_base::_Tune _S_tune(__align, sizeof(_Tp) * 128, (sizeof(_Tp) * 2) >= __align ? sizeof(_Tp) * 2 : __align, __pool_type::_Tune::_S_chunk_size, __pool_type::_Tune::_S_max_threads, __pool_type::_Tune::_S_freelist_headroom, getenv("GLIBCXX_FORCE_NEW") ? true : false);
- static __pool_type _S_pool(_S_tune);
+ // Sane defaults for the _PoolTp.
+ const static size_t __align = __alignof__(_Tp) >= sizeof(typename pool_type::_Block_record) ? __alignof__(_Tp) : sizeof(typename pool_type::_Block_record);
+ static __pool_base::_Tune _S_tune(__align, sizeof(_Tp) * 128, (sizeof(_Tp) * 2) >= __align ? sizeof(_Tp) * 2 : __align, __pool_base::_Tune::_S_chunk_size, __pool_base::_Tune::_S_max_threads, __pool_base::_Tune::_S_freelist_headroom, getenv("GLIBCXX_FORCE_NEW") ? true : false);
+ static pool_type _S_pool(_S_tune);
return _S_pool;
}
}
};
- template<typename _Tp>
- struct __per_type_pool_policy<_Tp, true>;
-
#ifdef __GTHREADS
- template<typename _Tp>
- struct __per_type_pool_policy<_Tp, true>
+ template<typename _Tp, template <bool> class _PoolTp>
+ struct __per_type_pool_policy<_Tp, _PoolTp, true>
{
- typedef __pool<true> __pool_type;
-
- template<typename _Tp1, bool _Thread1 = true>
- struct _M_rebind;
+ typedef _Tp value_type;
+ typedef _PoolTp<true> pool_type;
- template<typename _Tp1>
- struct _M_rebind<_Tp1, false>
- { typedef __per_type_pool_policy<_Tp1, false> other; };
+ template<typename _Tp1, template <bool> class _PoolTp1 = _PoolTp,
+ bool _Thread1 = true>
+ struct _M_rebind
+ { typedef __per_type_pool_policy<_Tp1, _PoolTp1, _Thread1> other; };
- template<typename _Tp1>
- struct _M_rebind<_Tp1, true>
- { typedef __per_type_pool_policy<_Tp1, true> other; };
-
- // Avoid static initialization ordering issues.
- static __pool_type&
- _S_get_pool( )
+ static pool_type&
+ _S_get_pool()
{
- // Sane defaults for the __pool_type.
- const static size_t __align = __alignof__(_Tp) >= sizeof(typename __pool_type::_Block_record) ? __alignof__(_Tp) : sizeof(typename __pool_type::_Block_record);
- static __pool_base::_Tune _S_tune(__align, sizeof(_Tp) * 128, (sizeof(_Tp) * 2) >= __align ? sizeof(_Tp) * 2 : __align, __pool_type::_Tune::_S_chunk_size, __pool_type::_Tune::_S_max_threads, __pool_type::_Tune::_S_freelist_headroom, getenv("GLIBCXX_FORCE_NEW") ? true : false);
- static __pool_type _S_pool(_S_tune);
+ // Sane defaults for the _PoolTp.
+ const static size_t __align = __alignof__(_Tp) >= sizeof(typename pool_type::_Block_record) ? __alignof__(_Tp) : sizeof(typename pool_type::_Block_record);
+ static __pool_base::_Tune _S_tune(__align, sizeof(_Tp) * 128, (sizeof(_Tp) * 2) >= __align ? sizeof(_Tp) * 2 : __align, __pool_base::_Tune::_S_chunk_size, __pool_base::_Tune::_S_max_threads, __pool_base::_Tune::_S_freelist_headroom, getenv("GLIBCXX_FORCE_NEW") ? true : false);
+ static pool_type _S_pool(_S_tune);
return _S_pool;
}
- static void
- _S_destroy_thread_key(void* __freelist_pos)
- { _S_get_pool()._M_destroy_thread_key(__freelist_pos); }
-
- static void
- _S_initialize()
- { _S_get_pool()._M_initialize(_S_destroy_thread_key); }
-
static void
_S_initialize_once()
{
__init = true;
}
}
+
+ private:
+ static void
+ _S_destroy_thread_key(void* __freelist_pos)
+ { _S_get_pool()._M_destroy_thread_key(__freelist_pos); }
+
+ static void
+ _S_initialize()
+ { _S_get_pool()._M_initialize(_S_destroy_thread_key); }
};
#endif
};
#ifdef __GTHREADS
-#define __default_policy __common_pool_policy<true>
+#define __thread_default true
#else
-#define __default_policy __common_pool_policy<false>
+#define __thread_default false
#endif
- template<typename _Tp, typename _Poolp = __default_policy>
- class __mt_alloc : public __mt_alloc_base<_Tp>, _Poolp
+ template<typename _Tp,
+ typename _Poolp = __common_pool_policy<__pool, __thread_default> >
+ class __mt_alloc : public __mt_alloc_base<_Tp>
{
public:
typedef size_t size_type;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
- typedef _Poolp __policy_type;
- typedef typename _Poolp::__pool_type __pool_type;
+ typedef _Poolp __policy_type;
+ typedef typename _Poolp::pool_type __pool_type;
template<typename _Tp1, typename _Poolp1 = _Poolp>
struct rebind
_M_get_options()
{
// Return a copy, not a reference, for external consumption.
- return __pool_base::_Tune(this->_S_get_pool()._M_get_options());
+ return __policy_type::_S_get_pool()._M_get_options();
}
void
_M_set_options(__pool_base::_Tune __t)
- { this->_S_get_pool()._M_set_options(__t); }
+ { __policy_type::_S_get_pool()._M_set_options(__t); }
};
template<typename _Tp, typename _Poolp>
__mt_alloc<_Tp, _Poolp>::
allocate(size_type __n, const void*)
{
- this->_S_initialize_once();
-
if (__builtin_expect(__n > this->max_size(), false))
std::__throw_bad_alloc();
+ __policy_type::_S_initialize_once();
+
// Requests larger than _M_max_bytes are handled by operator
// new/delete directly.
- __pool_type& __pool = this->_S_get_pool();
+ __pool_type& __pool = __policy_type::_S_get_pool();
const size_t __bytes = __n * sizeof(_Tp);
if (__pool._M_check_threshold(__bytes))
{
{
// Requests larger than _M_max_bytes are handled by
// operators new/delete directly.
- __pool_type& __pool = this->_S_get_pool();
+ __pool_type& __pool = __policy_type::_S_get_pool();
const size_t __bytes = __n * sizeof(_Tp);
if (__pool._M_check_threshold(__bytes))
::operator delete(__p);
operator!=(const __mt_alloc<_Tp, _Poolp>&, const __mt_alloc<_Tp, _Poolp>&)
{ return false; }
-#undef __default_policy
+#undef __thread_default
} // namespace __gnu_cxx
#endif
projects / thirdparty / gcc.git / commitdiff
