Skip to content

R
riscv-gcc-1
Commit f263b26e by Benjamin Kosnik Committed by Benjamin Kosnik
Options

malloc_allocator.h: Add operators ==, !=. 


2004-02-20  Benjamin Kosnik  <bkoz@redhat.com>

	* include/ext/malloc_allocator.h: Add operators ==, !=.
	* include/ext/new_allocator.h: Add operators ==, !=.
	* include/ext/mt_allocator.h (__mt_alloc::tune): New.
	(__mt_alloc::_S_get_options): New.
	(__mt_alloc::_S_set_options): New.
	(__mt_alloc::_S_thread_key_destr): To _S_destroy_thread_key.
	(__mt_alloc::_S_no_of_bins): To _S_bin_size.
	Move functions out of line, simplify, format.
	* src/allocator.cc: Simplify explicit instantiations.
	* include/bits/allocator.h: Tweak.

From-SVN: r78314
parent 2b0c1c56
Showing with 521 additions and 622 deletions
libstdc++-v3/ChangeLog
2004-02-20 Benjamin Kosnik <bkoz@redhat.com>
* include/ext/malloc_allocator.h: Add operators ==, !=.
* include/ext/new_allocator.h: Add operators ==, !=.
* include/ext/mt_allocator.h (__mt_alloc::tune): New.
(__mt_alloc::_S_get_options): New.
(__mt_alloc::_S_set_options): New.
(__mt_alloc::_S_thread_key_destr): To _S_destroy_thread_key.
(__mt_alloc::_S_no_of_bins): To _S_bin_size.
Move functions out of line, simplify, format.
* src/allocator.cc: Simplify explicit instantiations.
* include/bits/allocator.h: Tweak.
2004-02-22 Paolo Carlini <pcarlini@suse.de> 2004-02-22 Paolo Carlini <pcarlini@suse.de>
* include/bits/locale_facets.tcc (money_put<>::_M_insert): * include/bits/locale_facets.tcc (money_put<>::_M_insert):
......
libstdc++-v3/include/bits/allocator.h
...@@ -48,15 +48,13 @@ ...@@ -48,15 +48,13 @@
#ifndef _ALLOCATOR_H #ifndef _ALLOCATOR_H
#define _ALLOCATOR_H 1 #define _ALLOCATOR_H 1
#if 1 // Define the base class to std::allocator.
# include <ext/new_allocator.h>
# define __glibcxx_default_allocator __gnu_cxx::new_allocator
#endif
#if 0 #include <ext/new_allocator.h>
# include <ext/pool_allocator.h> #define __glibcxx_default_allocator __gnu_cxx::new_allocator
# define __glibcxx_default_allocator __gnu_cxx::__pool_alloc
#endif //#include <ext/mt_allocator.h>
//#define __glibcxx_default_allocator __gnu_cxx::__mt_alloc
namespace std namespace std
{ {
......
libstdc++-v3/include/ext/malloc_allocator.h
...@@ -98,6 +98,16 @@ namespace __gnu_cxx ...@@ -98,6 +98,16 @@ namespace __gnu_cxx
void void
destroy(pointer __p) { __p->~_Tp(); } destroy(pointer __p) { __p->~_Tp(); }
}; };
template<typename _Tp>
inline bool
operator==(const malloc_allocator<_Tp>&, const malloc_allocator<_Tp>&)
{ return true; }
template<typename _Tp>
inline bool
operator!=(const malloc_allocator<_Tp>&, const malloc_allocator<_Tp>&)
{ return false; }
} // namespace __gnu_cxx } // namespace __gnu_cxx
#endif #endif
libstdc++-v3/include/ext/mt_allocator.h
...@@ -50,13 +50,8 @@ namespace __gnu_cxx ...@@ -50,13 +50,8 @@ namespace __gnu_cxx
* the per thread freelist sizes (by returning excess back to * the per thread freelist sizes (by returning excess back to
* "global"). * "global").
* *
* Usage examples: * Further details:
* @code * http://gcc.gnu.org/onlinedocs/libstdc++/ext/mt_allocator.html
* vector<int, __gnu_cxx::__mt_alloc<int> > v1;
*
* typedef __gnu_cxx::__mt_alloc<char> > string_allocator;
* std::basic_string<char, std::char_traits<char>, string_allocator> s1;
* @endcode
*/ */
template<typename _Tp> template<typename _Tp>
class __mt_alloc class __mt_alloc
...@@ -79,13 +74,13 @@ namespace __gnu_cxx ...@@ -79,13 +74,13 @@ namespace __gnu_cxx
// XXX // XXX
} }
__mt_alloc(const __mt_alloc&) throw() __mt_alloc(const __mt_alloc&) throw()
{ {
// XXX // XXX
} }
template<typename _Tp1> template<typename _Tp1>
__mt_alloc(const __mt_alloc<_Tp1>&) throw() __mt_alloc(const __mt_alloc<_Tp1>& obj) throw()
{ {
// XXX // XXX
} }
...@@ -111,84 +106,127 @@ namespace __gnu_cxx ...@@ -111,84 +106,127 @@ namespace __gnu_cxx
void void
destroy(pointer __p) { __p->~_Tp(); } destroy(pointer __p) { __p->~_Tp(); }
pointer
allocate(size_t __n, const void* = 0);
void
deallocate(pointer __p, size_type __n);
// Variables used to configure the behavior of the allocator,
// assigned and explained in detail below.
struct tune
{
// Allocation requests (after round-up to power of 2) below
// this value will be handled by the allocator. A raw new/
// call will be used for requests larger than this value.
size_t _M_max_bytes;
// In order to avoid fragmenting and minimize the number of
// new() calls we always request new memory using this
// value. Based on previous discussions on the libstdc++
// mailing list we have choosen the value below.
// See http://gcc.gnu.org/ml/libstdc++/2001-07/msg00077.html
size_t _M_chunk_size;
// The maximum number of supported threads. Our Linux 2.4.18
// reports 4070 in /proc/sys/kernel/threads-max
size_t _M_max_threads;
// Each time a deallocation occurs in a threaded application
// we make sure that there are no more than
// _M_freelist_headroom % of used memory on the freelist. If
// the number of additional records is more than
// _M_freelist_headroom % of the freelist, we move these
// records back to the global pool.
size_t _M_freelist_headroom;
// Set to true forces all allocations to use new().
bool _M_force_new;
explicit tune()
: _M_max_bytes(128), _M_chunk_size(4096 - 4 * sizeof(void*)),
#ifdef __GTHREADS
_M_max_threads(4096),
#else
_M_max_threads(0),
#endif
_M_freelist_headroom(10),
_M_force_new(getenv("GLIBCXX_FORCE_NEW") ? true : false)
{ }
explicit tune(size_t __maxb, size_t __chunk, size_t __maxthreads,
size_t __headroom, bool __force)
: _M_max_bytes(__maxb), _M_chunk_size(__chunk),
_M_max_threads(__maxthreads), _M_freelist_headroom(__headroom),
_M_force_new(__force)
{ }
};
private: private:
/* // We need to create the initial lists and set up some variables
* We need to create the initial lists and set up some variables // before we can answer to the first request for memory.
* before we can answer to the first request for memory.
* The initialization of these variables is done at file scope
* below class declaration.
*/
#ifdef __GTHREADS #ifdef __GTHREADS
static __gthread_once_t _S_once_mt; static __gthread_once_t _S_once;
#endif #endif
static bool volatile _S_initialized; static bool _S_init;
/* static void
* If the env var GLIBCXX_FORCE_NEW is set during _S_init() _S_initialize();
* we set this var to true which causes all allocations to use new()
*/ // Configuration options.
static bool _S_force_new; static tune _S_options;
/* static const tune
* Using short int as type for the binmap implies we are never caching _S_get_options() { return _S_options; }
* blocks larger than 65535 with this allocator
*/ static void
_S_set_options(tune __t)
{
if (!_S_init)
_S_options = __t;
}
// Using short int as type for the binmap implies we are never
// caching blocks larger than 65535 with this allocator
typedef unsigned short int binmap_type; typedef unsigned short int binmap_type;
static binmap_type* _S_binmap; static binmap_type* _S_binmap;
static void _S_init(); // Each requesting thread is assigned an id ranging from 1 to
// _S_max_threads. Thread id 0 is used as a global memory pool.
/* // In order to get constant performance on the thread assignment
* Variables used to "tune" the behavior of the allocator, assigned // routine, we keep a list of free ids. When a thread first
* and explained in detail below. // requests memory we remove the first record in this list and
*/ // stores the address in a __gthread_key. When initializing the
static size_t _S_max_bytes; // __gthread_key we specify a destructor. When this destructor
static size_t _S_chunk_size; // (i.e. the thread dies) is called, we return the thread id to
static size_t _S_max_threads; // the front of this list.
static size_t _S_no_of_bins;
static size_t _S_freelist_headroom;
/*
* Each requesting thread is assigned an id ranging from 1 to
* _S_max_threads. Thread id 0 is used as a global memory pool.
* In order to get constant performance on the thread assignment
* routine, we keep a list of free ids. When a thread first requests
* memory we remove the first record in this list and stores the address
* in a __gthread_key. When initializing the __gthread_key
* we specify a destructor. When this destructor (i.e. the thread dies)
* is called, we return the thread id to the front of this list.
*/
#ifdef __GTHREADS #ifdef __GTHREADS
struct thread_record struct thread_record
{ {
/* // Points to next free thread id record. NULL if last record in list.
* Points to next free thread id record. NULL if last record in list.
*/
thread_record* volatile next; thread_record* volatile next;
/* // Thread id ranging from 1 to _S_max_threads.
* Thread id ranging from 1 to _S_max_threads.
*/
size_t id; size_t id;
}; };
static thread_record* volatile _S_thread_freelist_first; static thread_record* volatile _S_thread_freelist_first;
static __gthread_mutex_t _S_thread_freelist_mutex; static __gthread_mutex_t _S_thread_freelist_mutex;
static void _S_thread_key_destr(void* freelist_pos); static __gthread_key_t _S_thread_key;
static __gthread_key_t _S_thread_key;
static size_t _S_get_thread_id(); static void
_S_destroy_thread_key(void* freelist_pos);
static size_t
_S_get_thread_id();
#endif #endif
struct block_record struct block_record
{ {
/* // Points to the next block_record for its thread_id.
* Points to the next block_record for its thread_id.
*/
block_record* volatile next; block_record* volatile next;
/* // The thread id of the thread which has requested this block.
* The thread id of the thread which has requested this block.
*/
#ifdef __GTHREADS #ifdef __GTHREADS
size_t thread_id; size_t thread_id;
#endif #endif
...@@ -196,414 +234,338 @@ namespace __gnu_cxx ...@@ -196,414 +234,338 @@ namespace __gnu_cxx
struct bin_record struct bin_record
{ {
/* // An "array" of pointers to the first free block for each
* An "array" of pointers to the first free block for each // thread id. Memory to this "array" is allocated in _S_initialize()
* thread id. Memory to this "array" is allocated in _S_init() // for _S_max_threads + global pool 0.
* for _S_max_threads + global pool 0.
*/
block_record** volatile first; block_record** volatile first;
/* // An "array" of counters used to keep track of the amount of
* An "array" of counters used to keep track of the amount of blocks // blocks that are on the freelist/used for each thread id.
* that are on the freelist/used for each thread id. // Memory to these "arrays" is allocated in _S_initialize() for
* Memory to these "arrays" is allocated in _S_init() // _S_max_threads + global pool 0.
* for _S_max_threads + global pool 0.
*/
size_t* volatile free; size_t* volatile free;
size_t* volatile used; size_t* volatile used;
/* // Each bin has its own mutex which is used to ensure data
* Each bin has its own mutex which is used to ensure data integrity // integrity while changing "ownership" on a block. The mutex
* while changing "ownership" on a block. // is initialized in _S_initialize().
* The mutex is initialized in _S_init().
*/
#ifdef __GTHREADS #ifdef __GTHREADS
__gthread_mutex_t* mutex; __gthread_mutex_t* mutex;
#endif #endif
}; };
/* // An "array" of bin_records each of which represents a specific
* An "array" of bin_records each of which represents a specific // power of 2 size. Memory to this "array" is allocated in
* power of 2 size. Memory to this "array" is allocated in _S_init(). // _S_initialize().
*/ static bin_record* volatile _S_bin;
static bin_record* volatile _S_bin;
public: // Actual value calculated in _S_initialize().
pointer static size_t _S_bin_size;
allocate(size_t __n, const void* = 0) };
{
/* template<typename _Tp>
* Although the test in __gthread_once() would suffice, we typename __mt_alloc<_Tp>::pointer
* wrap test of the once condition in our own unlocked __mt_alloc<_Tp>::
* check. This saves one function call to pthread_once() allocate(size_t __n, const void*)
* (which itself only tests for the once value unlocked anyway {
* and immediately returns if set) // Although the test in __gthread_once() would suffice, we wrap
*/ // test of the once condition in our own unlocked check. This
if (!_S_initialized) // saves one function call to pthread_once() (which itself only
{ // tests for the once value unlocked anyway and immediately
// returns if set)
if (!_S_init)
{
#ifdef __GTHREADS #ifdef __GTHREADS
if (__gthread_active_p()) if (__gthread_active_p())
__gthread_once(&_S_once_mt, _S_init); __gthread_once(&_S_once, _S_initialize);
else
#endif #endif
{ if (!_S_init)
_S_max_threads = 0; _S_initialize();
_S_init(); }
}
} // Requests larger than _M_max_bytes are handled by new/delete
// directly.
/* const size_t __bytes = __n * sizeof(_Tp);
* Requests larger than _S_max_bytes are handled by if (__bytes > _S_options._M_max_bytes || _S_options._M_force_new)
* new/delete directly {
*/ void* __ret = ::operator new(__bytes);
if (__n * sizeof(_Tp) > _S_max_bytes || _S_force_new) return static_cast<_Tp*>(__ret);
{ }
void* __ret = ::operator new(__n * sizeof(_Tp));
if (!__ret) // Round up to power of 2 and figure out which bin to use.
std::__throw_bad_alloc(); size_t bin = _S_binmap[__bytes];
return static_cast<_Tp*>(__ret);
}
/*
* Round up to power of 2 and figure out which bin to use
*/
size_t bin = _S_binmap[__n * sizeof(_Tp)];
#ifdef __GTHREADS #ifdef __GTHREADS
size_t thread_id = _S_get_thread_id(); size_t thread_id = _S_get_thread_id();
#else #else
size_t thread_id = 0; size_t thread_id = 0;
#endif #endif
block_record* block = NULL; // Find out if we have blocks on our freelist. If so, go ahead
// and use them directly without having to lock anything.
/* block_record* block = NULL;
* Find out if we have blocks on our freelist. if (_S_bin[bin].first[thread_id] == NULL)
* If so, go ahead and use them directly without {
* having to lock anything. // Are we using threads?
*/ // - Yes, check if there are free blocks on the global
if (_S_bin[bin].first[thread_id] == NULL) // list. If so, grab up to block_count blocks in one
{ // lock and change ownership. If the global list is
/* // empty, we allocate a new chunk and add those blocks
* Are we using threads? // directly to our own freelist (with us as owner).
* - Yes, check if there are free blocks on the global // - No, all operations are made directly to global pool 0
* list. If so, grab up to block_count blocks in one // no need to lock or change ownership but check for free
* lock and change ownership. If the global list is // blocks on global list (and if not add new ones) and
* empty, we allocate a new chunk and add those blocks // get the first one.
* directly to our own freelist (with us as owner).
* - No, all operations are made directly to global pool 0
* no need to lock or change ownership but check for free
* blocks on global list (and if not add new ones) and
* get the first one.
*/
#ifdef __GTHREADS #ifdef __GTHREADS
if (__gthread_active_p()) if (__gthread_active_p())
{ {
size_t bin_t = 1 << bin; size_t bin_t = 1 << bin;
size_t block_count = size_t block_count =
_S_chunk_size /(bin_t + sizeof(block_record)); _S_options._M_chunk_size /(bin_t + sizeof(block_record));
__gthread_mutex_lock(_S_bin[bin].mutex); __gthread_mutex_lock(_S_bin[bin].mutex);
if (_S_bin[bin].first[0] == NULL) if (_S_bin[bin].first[0] == NULL)
{ {
/* // No need to hold the lock when we are adding a
* No need to hold the lock when we are adding a // whole chunk to our own list.
* whole chunk to our own list __gthread_mutex_unlock(_S_bin[bin].mutex);
*/
__gthread_mutex_unlock(_S_bin[bin].mutex); _S_bin[bin].first[thread_id] =
static_cast<block_record*>(::operator new(_S_options._M_chunk_size));
_S_bin[bin].first[thread_id] =
static_cast<block_record*>(::operator new(_S_chunk_size)); if (!_S_bin[bin].first[thread_id])
std::__throw_bad_alloc();
if (!_S_bin[bin].first[thread_id])
std::__throw_bad_alloc(); _S_bin[bin].free[thread_id] = block_count;
_S_bin[bin].free[thread_id] = block_count; block_count--;
block = _S_bin[bin].first[thread_id];
block_count--;
block = _S_bin[bin].first[thread_id]; while (block_count > 0)
{
while (block_count > 0) block->next = (block_record*)((char*)block +
{ (bin_t + sizeof(block_record)));
block->next = (block_record*)((char*)block + block->thread_id = thread_id;
(bin_t + sizeof(block_record))); block = block->next;
block->thread_id = thread_id; block_count--;
block = block->next; }
block_count--;
} block->next = NULL;
block->thread_id = thread_id;
block->next = NULL; }
block->thread_id = thread_id; else
} {
else size_t global_count = 0;
{ block_record* tmp;
size_t global_count = 0; while (_S_bin[bin].first[0] != NULL
&& global_count < block_count)
block_record* tmp; {
tmp = _S_bin[bin].first[0]->next;
while( _S_bin[bin].first[0] != NULL && block = _S_bin[bin].first[0];
global_count < block_count )
{ if (_S_bin[bin].first[thread_id] == NULL)
tmp = _S_bin[bin].first[0]->next; {
_S_bin[bin].first[thread_id] = block;
block = _S_bin[bin].first[0]; block->next = NULL;
}
if (_S_bin[bin].first[thread_id] == NULL) else
{ {
_S_bin[bin].first[thread_id] = block; block->next = _S_bin[bin].first[thread_id];
block->next = NULL; _S_bin[bin].first[thread_id] = block;
} }
else
{ block->thread_id = thread_id;
block->next = _S_bin[bin].first[thread_id]; _S_bin[bin].free[thread_id]++;
_S_bin[bin].first[thread_id] = block; _S_bin[bin].first[0] = tmp;
} global_count++;
}
block->thread_id = thread_id; __gthread_mutex_unlock(_S_bin[bin].mutex);
}
_S_bin[bin].free[thread_id]++;
// Return the first newly added block in our list and
_S_bin[bin].first[0] = tmp; // update the counters
block = _S_bin[bin].first[thread_id];
global_count++; _S_bin[bin].first[thread_id] =
} _S_bin[bin].first[thread_id]->next;
_S_bin[bin].free[thread_id]--;
__gthread_mutex_unlock(_S_bin[bin].mutex); _S_bin[bin].used[thread_id]++;
} }
else
/*
* Return the first newly added block in our list and
* update the counters
*/
block = _S_bin[bin].first[thread_id];
_S_bin[bin].first[thread_id] =
_S_bin[bin].first[thread_id]->next;
_S_bin[bin].free[thread_id]--;
_S_bin[bin].used[thread_id]++;
}
else
#endif #endif
{ {
_S_bin[bin].first[0] = _S_bin[bin].first[0] =
static_cast<block_record*>(::operator new(_S_chunk_size)); static_cast<block_record*>(::operator new(_S_options._M_chunk_size));
if (!_S_bin[bin].first[0]) size_t bin_t = 1 << bin;
std::__throw_bad_alloc(); size_t block_count =
_S_options._M_chunk_size / (bin_t + sizeof(block_record));
size_t bin_t = 1 << bin;
size_t block_count = block_count--;
_S_chunk_size / (bin_t + sizeof(block_record)); block = _S_bin[bin].first[0];
while (block_count > 0)
block_count--; {
block = _S_bin[bin].first[0]; block->next = (block_record*)((char*)block +
(bin_t + sizeof(block_record)));
while (block_count > 0) block = block->next;
{ block_count--;
block->next = (block_record*)((char*)block + }
(bin_t + sizeof(block_record))); block->next = NULL;
block = block->next; block = _S_bin[bin].first[0];
block_count--;
} // Remove from list.
_S_bin[bin].first[0] = _S_bin[bin].first[0]->next;
block->next = NULL; }
}
block = _S_bin[bin].first[0]; else
{
/* // "Default" operation - we have blocks on our own
* Remove from list // freelist grab the first record and update the counters.
*/ block = _S_bin[bin].first[thread_id];
_S_bin[bin].first[0] = _S_bin[bin].first[0]->next;
} _S_bin[bin].first[thread_id] = _S_bin[bin].first[thread_id]->next;
}
else
{
/*
* "Default" operation - we have blocks on our own freelist
* grab the first record and update the counters.
*/
block = _S_bin[bin].first[thread_id];
_S_bin[bin].first[thread_id] = _S_bin[bin].first[thread_id]->next;
#ifdef __GTHREADS #ifdef __GTHREADS
if (__gthread_active_p()) if (__gthread_active_p())
{ {
_S_bin[bin].free[thread_id]--; _S_bin[bin].free[thread_id]--;
_S_bin[bin].used[thread_id]++; _S_bin[bin].used[thread_id]++;
} }
#endif #endif
} }
return static_cast<_Tp*>(static_cast<void*>((char*)block +
return static_cast<_Tp*>(static_cast<void*>((char*)block + sizeof(block_record)));
sizeof(block_record))); }
}
template<typename _Tp>
void void
deallocate(pointer __p, size_type __n) __mt_alloc<_Tp>::
{ deallocate(pointer __p, size_type __n)
/* {
* Requests larger than _S_max_bytes are handled by // Requests larger than _M_max_bytes are handled by operators
* operators new/delete directly // new/delete directly.
*/ if (__n * sizeof(_Tp) > _S_options._M_max_bytes
if (__n * sizeof(_Tp) > _S_max_bytes || _S_force_new) || _S_options._M_force_new)
{ {
::operator delete(__p); ::operator delete(__p);
return; return;
} }
/* // Round up to power of 2 and figure out which bin to use.
* Round up to power of 2 and figure out which bin to use size_t bin = _S_binmap[__n * sizeof(_Tp)];
*/
size_t bin = _S_binmap[__n * sizeof(_Tp)];
#ifdef __GTHREADS #ifdef __GTHREADS
size_t thread_id = _S_get_thread_id(); size_t thread_id = _S_get_thread_id();
#else #else
size_t thread_id = 0; size_t thread_id = 0;
#endif #endif
block_record* block = (block_record*)((char*)__p block_record* block = (block_record*)((char*)__p
- sizeof(block_record)); - sizeof(block_record));
#ifdef __GTHREADS #ifdef __GTHREADS
if (__gthread_active_p()) if (__gthread_active_p())
{ {
/* // Calculate the number of records to remove from our freelist.
* Calculate the number of records to remove from our freelist int remove = _S_bin[bin].free[thread_id] -
*/ (_S_bin[bin].used[thread_id] / _S_options._M_freelist_headroom);
int remove = _S_bin[bin].free[thread_id] -
(_S_bin[bin].used[thread_id] / _S_freelist_headroom); // The calculation above will almost always tell us to
// remove one or two records at a time, but this creates too
/* // much contention when locking and therefore we wait until
* The calculation above will almost always tell us to // the number of records is "high enough".
* remove one or two records at a time, but this creates if (remove > (int)(100 * (_S_bin_size - bin)) &&
* too much contention when locking and therefore we remove > (int)(_S_bin[bin].free[thread_id] /
* wait until the number of records is "high enough". _S_options._M_freelist_headroom))
*/ {
if (remove > (int)(100 * (_S_no_of_bins - bin)) && __gthread_mutex_lock(_S_bin[bin].mutex);
remove > (int)(_S_bin[bin].free[thread_id] / block_record* tmp;
_S_freelist_headroom)) while (remove > 0)
{ {
__gthread_mutex_lock(_S_bin[bin].mutex); tmp = _S_bin[bin].first[thread_id]->next;
if (_S_bin[bin].first[0] == NULL)
block_record* tmp; {
_S_bin[bin].first[0] = _S_bin[bin].first[thread_id];
while (remove > 0) _S_bin[bin].first[0]->next = NULL;
{ }
tmp = _S_bin[bin].first[thread_id]->next; else
{
if (_S_bin[bin].first[0] == NULL) _S_bin[bin].first[thread_id]->next = _S_bin[bin].first[0];
{ _S_bin[bin].first[0] = _S_bin[bin].first[thread_id];
_S_bin[bin].first[0] = _S_bin[bin].first[thread_id]; }
_S_bin[bin].first[0]->next = NULL;
} _S_bin[bin].first[thread_id] = tmp;
else _S_bin[bin].free[thread_id]--;
{ remove--;
_S_bin[bin].first[thread_id]->next = _S_bin[bin].first[0]; }
_S_bin[bin].first[0] = _S_bin[bin].first[thread_id]; __gthread_mutex_unlock(_S_bin[bin].mutex);
} }
_S_bin[bin].first[thread_id] = tmp; // Return this block to our list and update counters and
// owner id as needed.
_S_bin[bin].free[thread_id]--; if (_S_bin[bin].first[thread_id] == NULL)
{
remove--; _S_bin[bin].first[thread_id] = block;
} block->next = NULL;
}
__gthread_mutex_unlock(_S_bin[bin].mutex); else
} {
block->next = _S_bin[bin].first[thread_id];
/* _S_bin[bin].first[thread_id] = block;
* Return this block to our list and update }
* counters and owner id as needed
*/ _S_bin[bin].free[thread_id]++;
if (_S_bin[bin].first[thread_id] == NULL)
{ if (thread_id == block->thread_id)
_S_bin[bin].first[thread_id] = block; _S_bin[bin].used[thread_id]--;
block->next = NULL; else
} {
else _S_bin[bin].used[block->thread_id]--;
{ block->thread_id = thread_id;
block->next = _S_bin[bin].first[thread_id]; }
_S_bin[bin].first[thread_id] = block; }
} else
_S_bin[bin].free[thread_id]++;
if (thread_id == block->thread_id)
_S_bin[bin].used[thread_id]--;
else
{
_S_bin[bin].used[block->thread_id]--;
block->thread_id = thread_id;
}
}
else
#endif #endif
{ {
/* // Single threaded application - return to global pool.
* Single threaded application - return to global pool if (_S_bin[bin].first[0] == NULL)
*/ {
if (_S_bin[bin].first[0] == NULL) _S_bin[bin].first[0] = block;
{ block->next = NULL;
_S_bin[bin].first[0] = block; }
block->next = NULL; else
} {
else block->next = _S_bin[bin].first[0];
{ _S_bin[bin].first[0] = block;
block->next = _S_bin[bin].first[0]; }
_S_bin[bin].first[0] = block; }
} }
}
}
};
template<typename _Tp> template<typename _Tp>
void void
__mt_alloc<_Tp>:: __mt_alloc<_Tp>::
_S_init() _S_initialize()
{ {
if (getenv("GLIBCXX_FORCE_NEW")) if (_S_options._M_force_new)
{ return;
_S_force_new = true;
_S_initialized = true; // Calculate the number of bins required based on _M_max_bytes.
// _S_bin_size is statically-initialized to one.
/* size_t bin_size = 1;
* Since none of the code in allocate/deallocate ever will be while (_S_options._M_max_bytes > bin_size)
* executed due to that the GLIBCXX_FORCE_NEW flag is set {
* there is no need to create the internal structures either. bin_size = bin_size << 1;
*/ _S_bin_size++;
return; }
}
/*
* Calculate the number of bins required based on _S_max_bytes,
* _S_no_of_bins is initialized to 1 below.
*/
{
size_t bin_t = 1;
while (_S_max_bytes > bin_t)
{
bin_t = bin_t << 1;
_S_no_of_bins++;
}
}
/* // Setup the bin map for quick lookup of the relevant bin.
* Setup the bin map for quick lookup of the relevant bin
*/
_S_binmap = (binmap_type*) _S_binmap = (binmap_type*)
::operator new ((_S_max_bytes + 1) * sizeof(binmap_type)); ::operator new ((_S_options._M_max_bytes + 1) * sizeof(binmap_type));
if (!_S_binmap)
std::__throw_bad_alloc();
binmap_type* bp_t = _S_binmap; binmap_type* bp_t = _S_binmap;
binmap_type bin_max_t = 1; binmap_type bin_max_t = 1;
binmap_type bin_t = 0; binmap_type bin_t = 0;
for (binmap_type ct = 0; ct <= _S_max_bytes; ct++) for (binmap_type ct = 0; ct <= _S_options._M_max_bytes; ct++)
{ {
if (ct > bin_max_t) if (ct > bin_max_t)
{ {
...@@ -613,127 +575,95 @@ namespace __gnu_cxx ...@@ -613,127 +575,95 @@ namespace __gnu_cxx
*bp_t++ = bin_t; *bp_t++ = bin_t;
} }
/* // If __gthread_active_p() create and initialize the list of
* If __gthread_active_p() create and initialize the list of // free thread ids. Single threaded applications use thread id 0
* free thread ids. Single threaded applications use thread id 0 // directly and have no need for this.
* directly and have no need for this.
*/
#ifdef __GTHREADS #ifdef __GTHREADS
if (__gthread_active_p()) if (__gthread_active_p())
{ {
_S_thread_freelist_first = _S_thread_freelist_first =
static_cast<thread_record*>(::operator static_cast<thread_record*>(::operator
new(sizeof(thread_record) * _S_max_threads)); new(sizeof(thread_record) * _S_options._M_max_threads));
if (!_S_thread_freelist_first) // NOTE! The first assignable thread id is 1 since the
std::__throw_bad_alloc(); // global pool uses id 0
/*
* NOTE! The first assignable thread id is 1 since the global
* pool uses id 0
*/
size_t i; size_t i;
for (i = 1; i < _S_max_threads; i++) for (i = 1; i < _S_options._M_max_threads; i++)
{ {
_S_thread_freelist_first[i - 1].next = thread_record& tr = _S_thread_freelist_first[i - 1];
&_S_thread_freelist_first[i]; tr.next = &_S_thread_freelist_first[i];
tr.id = i;
_S_thread_freelist_first[i - 1].id = i;
} }
/* // Set last record.
* Set last record
*/
_S_thread_freelist_first[i - 1].next = NULL; _S_thread_freelist_first[i - 1].next = NULL;
_S_thread_freelist_first[i - 1].id = i; _S_thread_freelist_first[i - 1].id = i;
/* // Initialize per thread key to hold pointer to
* Initialize per thread key to hold pointer to // _S_thread_freelist.
* _S_thread_freelist __gthread_key_create(&_S_thread_key, _S_destroy_thread_key);
*/
__gthread_key_create(&_S_thread_key, _S_thread_key_destr);
} }
#endif #endif
/* // Initialize _S_bin and its members.
* Initialize _S_bin and its members
*/
_S_bin = static_cast<bin_record*>(::operator _S_bin = static_cast<bin_record*>(::operator
new(sizeof(bin_record) * _S_no_of_bins)); new(sizeof(bin_record) * _S_bin_size));
if (!_S_bin)
std::__throw_bad_alloc();
std::size_t __n = 1;
// Maximum number of threads.
size_t __n = 1;
#ifdef __GTHREADS #ifdef __GTHREADS
if (__gthread_active_p()) if (__gthread_active_p())
__n = _S_max_threads + 1; __n = _S_options._M_max_threads + 1;
#endif #endif
for (size_t bin = 0; bin < _S_no_of_bins; bin++) for (size_t bin = 0; bin < _S_bin_size; bin++)
{ {
_S_bin[bin].first = static_cast<block_record**>(::operator bin_record& br = _S_bin[bin];
new(sizeof(block_record*) * __n)); br.first = static_cast<block_record**>(::operator new(sizeof(block_record*) * __n));
if (!_S_bin[bin].first)
std::__throw_bad_alloc();
#ifdef __GTHREADS #ifdef __GTHREADS
if (__gthread_active_p()) if (__gthread_active_p())
{ {
_S_bin[bin].free = static_cast<size_t*>(::operator br.free = static_cast<size_t*>(::operator new(sizeof(size_t)
new(sizeof(size_t) * __n)); * __n));
br.used = static_cast<size_t*>(::operator new(sizeof(size_t)
if (!_S_bin[bin].free) * __n));
std::__throw_bad_alloc(); br.mutex = static_cast<__gthread_mutex_t*>(::operator new(sizeof(__gthread_mutex_t)));
_S_bin[bin].used = static_cast<size_t*>(::operator
new(sizeof(size_t) * __n));
if (!_S_bin[bin].used)
std::__throw_bad_alloc();
_S_bin[bin].mutex = static_cast<__gthread_mutex_t*>(::operator
new(sizeof(__gthread_mutex_t)));
#ifdef __GTHREAD_MUTEX_INIT #ifdef __GTHREAD_MUTEX_INIT
{ {
// Do not copy a POSIX/gthr mutex once in use. // Do not copy a POSIX/gthr mutex once in use.
__gthread_mutex_t __tmp = __GTHREAD_MUTEX_INIT; __gthread_mutex_t __tmp = __GTHREAD_MUTEX_INIT;
*_S_bin[bin].mutex = __tmp; *br.mutex = __tmp;
} }
#else #else
{ __GTHREAD_MUTEX_INIT_FUNCTION (_S_bin[bin].mutex); } { __GTHREAD_MUTEX_INIT_FUNCTION (br.mutex); }
#endif #endif
} }
#endif #endif
for (size_t thread = 0; thread < __n; thread++) for (size_t thread = 0; thread < __n; thread++)
{ {
_S_bin[bin].first[thread] = NULL; br.first[thread] = NULL;
#ifdef __GTHREADS #ifdef __GTHREADS
if (__gthread_active_p()) if (__gthread_active_p())
{ {
_S_bin[bin].free[thread] = 0; br.free[thread] = 0;
_S_bin[bin].used[thread] = 0; br.used[thread] = 0;
} }
#endif #endif
} }
} }
_S_init = true;
_S_initialized = true;
} }
#ifdef __GTHREADS #ifdef __GTHREADS
template<typename _Tp> template<typename _Tp>
void void
__mt_alloc<_Tp>:: __mt_alloc<_Tp>::
_S_thread_key_destr(void* freelist_pos) _S_destroy_thread_key(void* freelist_pos)
{ {
/* // Return this thread id record to front of thread_freelist.
* Return this thread id record to front of thread_freelist
*/
__gthread_mutex_lock(&_S_thread_freelist_mutex); __gthread_mutex_lock(&_S_thread_freelist_mutex);
((thread_record*)freelist_pos)->next = _S_thread_freelist_first; ((thread_record*)freelist_pos)->next = _S_thread_freelist_first;
_S_thread_freelist_first = (thread_record*)freelist_pos; _S_thread_freelist_first = (thread_record*)freelist_pos;
...@@ -745,102 +675,71 @@ namespace __gnu_cxx ...@@ -745,102 +675,71 @@ namespace __gnu_cxx
__mt_alloc<_Tp>:: __mt_alloc<_Tp>::
_S_get_thread_id() _S_get_thread_id()
{ {
/* // If we have thread support and it's active we check the thread
* If we have thread support and it's active we check the thread // key value and return it's id or if it's not set we take the
* key value and return it's id or if it's not set we take the // first record from _S_thread_freelist and sets the key and
* first record from _S_thread_freelist and sets the key and // returns it's id.
* returns it's id.
*/
if (__gthread_active_p()) if (__gthread_active_p())
{ {
thread_record* freelist_pos; thread_record* freelist_pos = static_cast<thread_record*>(__gthread_getspecific(_S_thread_key));
if (freelist_pos == NULL)
if ((freelist_pos =
(thread_record*)__gthread_getspecific(_S_thread_key)) == NULL)
{ {
/* // Since _S_options._M_max_threads must be larger than
* Since _S_max_threads must be larger than the // the theoretical max number of threads of the OS the
* theoretical max number of threads of the OS the list // list can never be empty.
* can never be empty.
*/
__gthread_mutex_lock(&_S_thread_freelist_mutex); __gthread_mutex_lock(&_S_thread_freelist_mutex);
freelist_pos = _S_thread_freelist_first; freelist_pos = _S_thread_freelist_first;
_S_thread_freelist_first = _S_thread_freelist_first->next; _S_thread_freelist_first = _S_thread_freelist_first->next;
__gthread_mutex_unlock(&_S_thread_freelist_mutex); __gthread_mutex_unlock(&_S_thread_freelist_mutex);
__gthread_setspecific(_S_thread_key, (void*)freelist_pos); __gthread_setspecific(_S_thread_key,
static_cast<void*>(freelist_pos));
} }
return freelist_pos->id; return freelist_pos->id;
} }
/* // Otherwise (no thread support or inactive) all requests are
* Otherwise (no thread support or inactive) all requests are // served from the global pool 0.
* served from the global pool 0.
*/
return 0; return 0;
} }
template<typename _Tp> __gthread_once_t
__mt_alloc<_Tp>::_S_once_mt = __GTHREAD_ONCE_INIT;
#endif #endif
template<typename _Tp> template<typename _Tp>
bool volatile __mt_alloc<_Tp>::_S_initialized = false; inline bool
operator==(const __mt_alloc<_Tp>&, const __mt_alloc<_Tp>&)
{ return true; }
template<typename _Tp>
inline bool
operator!=(const __mt_alloc<_Tp>&, const __mt_alloc<_Tp>&)
{ return false; }
template<typename _Tp> bool template<typename _Tp>
__mt_alloc<_Tp>::_S_force_new = false; bool __mt_alloc<_Tp>::_S_init = false;
template<typename _Tp> typename __mt_alloc<_Tp>::binmap_type* template<typename _Tp>
__mt_alloc<_Tp>::_S_binmap = NULL; typename __mt_alloc<_Tp>::tune __mt_alloc<_Tp>::_S_options;
/* template<typename _Tp>
* Allocation requests (after round-up to power of 2) below this typename __mt_alloc<_Tp>::binmap_type* __mt_alloc<_Tp>::_S_binmap;
* value will be handled by the allocator. A raw new/ call
* will be used for requests larger than this value.
*/
template<typename _Tp> size_t
__mt_alloc<_Tp>::_S_max_bytes = 128;
/*
* In order to avoid fragmenting and minimize the number of new()
* calls we always request new memory using this value. Based on
* previous discussions on the libstdc++ mailing list we have
* choosen the value below. See
* http://gcc.gnu.org/ml/libstdc++/2001-07/msg00077.html
*/
template<typename _Tp> size_t
__mt_alloc<_Tp>::_S_chunk_size = 4096 - 4 * sizeof(void*);
/* template<typename _Tp>
* The maximum number of supported threads. Our Linux 2.4.18 reports typename __mt_alloc<_Tp>::bin_record* volatile __mt_alloc<_Tp>::_S_bin;
* 4070 in /proc/sys/kernel/threads-max
*/
template<typename _Tp> size_t
__mt_alloc<_Tp>::_S_max_threads = 4096;
/* template<typename _Tp>
* Actual value calculated in _S_init() size_t __mt_alloc<_Tp>::_S_bin_size = 1;
*/
template<typename _Tp> size_t
__mt_alloc<_Tp>::_S_no_of_bins = 1;
/*
* Each time a deallocation occurs in a threaded application we make
* sure that there are no more than _S_freelist_headroom % of used
* memory on the freelist. If the number of additional records is
* more than _S_freelist_headroom % of the freelist, we move these
* records back to the global pool.
*/
template<typename _Tp> size_t
__mt_alloc<_Tp>::_S_freelist_headroom = 10;
/* // Actual initialization in _S_initialize().
* Actual initialization in _S_init()
*/
#ifdef __GTHREADS #ifdef __GTHREADS
template<typename _Tp> typename __mt_alloc<_Tp>::thread_record* template<typename _Tp>
volatile __mt_alloc<_Tp>::_S_thread_freelist_first = NULL; __gthread_once_t __mt_alloc<_Tp>::_S_once = __GTHREAD_ONCE_INIT;
template<typename _Tp>
typename __mt_alloc<_Tp>::thread_record*
volatile __mt_alloc<_Tp>::_S_thread_freelist_first = NULL;
template<typename _Tp>
__gthread_key_t __mt_alloc<_Tp>::_S_thread_key;
template<typename _Tp> __gthread_mutex_t template<typename _Tp> __gthread_mutex_t
#ifdef __GTHREAD_MUTEX_INIT #ifdef __GTHREAD_MUTEX_INIT
...@@ -849,26 +748,7 @@ namespace __gnu_cxx ...@@ -849,26 +748,7 @@ namespace __gnu_cxx
// XXX // XXX
__mt_alloc<_Tp>::_S_thread_freelist_mutex; __mt_alloc<_Tp>::_S_thread_freelist_mutex;
#endif #endif
/*
* Actual initialization in _S_init()
*/
template<typename _Tp> __gthread_key_t
__mt_alloc<_Tp>::_S_thread_key;
#endif #endif
template<typename _Tp> typename __mt_alloc<_Tp>::bin_record*
volatile __mt_alloc<_Tp>::_S_bin = NULL;
template<typename _Tp>
inline bool
operator==(const __mt_alloc<_Tp>&, const __mt_alloc<_Tp>&)
{ return true; }
template<typename _Tp>
inline bool
operator!=(const __mt_alloc<_Tp>&, const __mt_alloc<_Tp>&)
{ return false; }
} // namespace __gnu_cxx } // namespace __gnu_cxx
#endif #endif
libstdc++-v3/include/ext/new_allocator.h
...@@ -98,6 +98,16 @@ namespace __gnu_cxx ...@@ -98,6 +98,16 @@ namespace __gnu_cxx
void void
destroy(pointer __p) { __p->~_Tp(); } destroy(pointer __p) { __p->~_Tp(); }
}; };
template<typename _Tp>
inline bool
operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return true; }
template<typename _Tp>
inline bool
operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
{ return false; }
} // namespace __gnu_cxx } // namespace __gnu_cxx
#endif #endif
libstdc++-v3/src/allocator.cc
...@@ -40,19 +40,7 @@ ...@@ -40,19 +40,7 @@
// allocator. // allocator.
namespace __gnu_cxx namespace __gnu_cxx
{ {
// Static data members and member functions of __mt_alloc. template class __mt_alloc<char>;
static template class __mt_alloc<char>;
template
void __mt_alloc<char>::_S_init();
#ifdef __GTHREADS
template
size_t __mt_alloc<char>::_S_get_thread_id();
template
void __mt_alloc<char>::_S_thread_key_destr(void*);
#endif
// Static members of __pool_alloc. // Static members of __pool_alloc.
template class __pool_alloc<true, 0>; template class __pool_alloc<true, 0>;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment