#ifndef _POOL_ALLOCATOR_H
#define _POOL_ALLOCATOR_H 1
#include <bits/c++config.h>
#include <new>
#include <bits/functexcept.h>
#include <bits/stl_threads.h>
#include <bits/atomicity.h>
namespace __gnu_cxx
{
using std::__throw_bad_alloc;
template<typename _Tp>
class __pool_alloc
{
public:
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef _Tp value_type;
template<typename _Tp1>
struct rebind
{ typedef __pool_alloc<_Tp1> other; };
__pool_alloc() throw() { }
__pool_alloc(const __pool_alloc&) throw() { }
template<typename _Tp1>
__pool_alloc(const __pool_alloc<_Tp1>&) throw() { }
~__pool_alloc() throw() { }
pointer
address(reference __x) const { return &__x; }
const_pointer
address(const_reference __x) const { return &__x; }
size_type
max_size() const throw()
{ return size_t(-1) / sizeof(_Tp); }
void
construct(pointer __p, const _Tp& __val)
{ ::new(__p) _Tp(__val); }
void
destroy(pointer __p) { __p->~_Tp(); }
pointer
allocate(size_type __n, const void* = 0);
void
deallocate(pointer __p, size_type __n);
private:
enum {_S_align = 8};
enum {_S_max_bytes = 128};
enum {_S_freelists = _S_max_bytes / _S_align};
union _Obj
{
union _Obj* _M_free_list_link;
char _M_client_data[1]; };
static _Obj* volatile _S_free_list[_S_freelists];
static char* _S_start_free;
static char* _S_end_free;
static size_t _S_heap_size;
static _STL_mutex_lock _S_lock;
static _Atomic_word _S_force_new;
static size_t
_S_round_up(size_t __bytes)
{ return ((__bytes + (size_t)_S_align - 1) & ~((size_t)_S_align - 1)); }
static size_t
_S_freelist_index(size_t __bytes)
{ return ((__bytes + (size_t)_S_align - 1)/(size_t)_S_align - 1); }
static void*
_S_refill(size_t __n);
static char*
_S_chunk_alloc(size_t __n, int& __nobjs);
struct _Lock
{
_Lock() { _S_lock._M_acquire_lock(); }
~_Lock() { _S_lock._M_release_lock(); }
} __attribute__ ((__unused__));
friend struct _Lock;
};
template<typename _Tp>
inline bool
operator==(const __pool_alloc<_Tp>&, const __pool_alloc<_Tp>&)
{ return true; }
template<typename _Tp>
inline bool
operator!=(const __pool_alloc<_Tp>&, const __pool_alloc<_Tp>&)
{ return false; }
template<typename _Tp>
char*
__pool_alloc<_Tp>::_S_chunk_alloc(size_t __n, int& __nobjs)
{
char* __result;
size_t __total_bytes = __n * __nobjs;
size_t __bytes_left = _S_end_free - _S_start_free;
if (__bytes_left >= __total_bytes)
{
__result = _S_start_free;
_S_start_free += __total_bytes;
return __result ;
}
else if (__bytes_left >= __n)
{
__nobjs = (int)(__bytes_left/__n);
__total_bytes = __n * __nobjs;
__result = _S_start_free;
_S_start_free += __total_bytes;
return __result;
}
else
{
size_t __bytes_to_get =
2 * __total_bytes + _S_round_up(_S_heap_size >> 4);
if (__bytes_left > 0)
{
_Obj* volatile* __free_list =
_S_free_list + _S_freelist_index(__bytes_left);
((_Obj*)(void*)_S_start_free)->_M_free_list_link = *__free_list;
*__free_list = (_Obj*)(void*)_S_start_free;
}
_S_start_free = static_cast<char*>(::operator new(__bytes_to_get));
if (_S_start_free == 0)
{
size_t __i;
_Obj* volatile* __free_list;
_Obj* __p;
__i = __n;
for (; __i <= (size_t) _S_max_bytes; __i += (size_t) _S_align)
{
__free_list = _S_free_list + _S_freelist_index(__i);
__p = *__free_list;
if (__p != 0)
{
*__free_list = __p -> _M_free_list_link;
_S_start_free = (char*)__p;
_S_end_free = _S_start_free + __i;
return _S_chunk_alloc(__n, __nobjs);
}
}
_S_end_free = 0; _S_start_free = static_cast<char*>(::operator new(__bytes_to_get));
}
_S_heap_size += __bytes_to_get;
_S_end_free = _S_start_free + __bytes_to_get;
return _S_chunk_alloc(__n, __nobjs);
}
}
template<typename _Tp>
void*
__pool_alloc<_Tp>::_S_refill(size_t __n)
{
int __nobjs = 20;
char* __chunk = _S_chunk_alloc(__n, __nobjs);
_Obj* volatile* __free_list;
_Obj* __result;
_Obj* __current_obj;
_Obj* __next_obj;
int __i;
if (1 == __nobjs)
return __chunk;
__free_list = _S_free_list + _S_freelist_index(__n);
__result = (_Obj*)(void*)__chunk;
*__free_list = __next_obj = (_Obj*)(void*)(__chunk + __n);
for (__i = 1; ; __i++)
{
__current_obj = __next_obj;
__next_obj = (_Obj*)(void*)((char*)__next_obj + __n);
if (__nobjs - 1 == __i)
{
__current_obj -> _M_free_list_link = 0;
break;
}
else
__current_obj -> _M_free_list_link = __next_obj;
}
return __result;
}
template<typename _Tp>
_Tp*
__pool_alloc<_Tp>::allocate(size_type __n, const void*)
{
pointer __ret = 0;
if (__n)
{
if (__n <= max_size())
{
const size_t __bytes = __n * sizeof(_Tp);
if (_S_force_new == 0)
{
if (getenv("GLIBCXX_FORCE_NEW"))
__atomic_add(&_S_force_new, 1);
else
__atomic_add(&_S_force_new, -1);
}
if ((__bytes > (size_t) _S_max_bytes) || (_S_force_new > 0))
__ret = static_cast<_Tp*>(::operator new(__bytes));
else
{
_Obj* volatile* __free_list = (_S_free_list
+ _S_freelist_index(__bytes));
_Lock __lock_instance;
_Obj* __restrict__ __result = *__free_list;
if (__builtin_expect(__result == 0, 0))
__ret = static_cast<_Tp*>(_S_refill(_S_round_up(__bytes)));
else
{
*__free_list = __result -> _M_free_list_link;
__ret = reinterpret_cast<_Tp*>(__result);
}
if (__builtin_expect(__ret == 0, 0))
__throw_bad_alloc();
}
}
else
__throw_bad_alloc();
}
return __ret;
}
template<typename _Tp>
void
__pool_alloc<_Tp>::deallocate(pointer __p, size_type __n)
{
if (__n)
{
const size_t __bytes = __n * sizeof(_Tp);
if ((__bytes > (size_t) _S_max_bytes) || (_S_force_new > 0))
::operator delete(__p);
else
{
_Obj* volatile* __free_list = (_S_free_list
+ _S_freelist_index(__bytes));
_Obj* __q = (_Obj*)__p;
_Lock __lock_instance;
__q -> _M_free_list_link = *__free_list;
*__free_list = __q;
}
}
}
template<typename _Tp>
typename __pool_alloc<_Tp>::_Obj* volatile
__pool_alloc<_Tp>::_S_free_list[_S_freelists];
template<typename _Tp>
char* __pool_alloc<_Tp>::_S_start_free = 0;
template<typename _Tp>
char* __pool_alloc<_Tp>::_S_end_free = 0;
template<typename _Tp>
size_t __pool_alloc<_Tp>::_S_heap_size = 0;
template<typename _Tp>
_STL_mutex_lock
__pool_alloc<_Tp>::_S_lock __STL_MUTEX_INITIALIZER;
template<typename _Tp> _Atomic_word
__pool_alloc<_Tp>::_S_force_new = 0;
}
#endif