Skip to content

R
riscv-gcc-1
Commit 29d4adf4 by Paolo Carlini Committed by Paolo Carlini
Options

acinclude.m4 (GLIBCXX_ENABLE_ALLOCATOR): Add pool_allocator. 

2004-03-22  Paolo Carlini  <pcarlini@suse.de>

	* acinclude.m4 (GLIBCXX_ENABLE_ALLOCATOR): Add pool_allocator.
	* configure: Regenerate.
	* config/allocator/pool_allocator_base.h: New.
	* include/ext/pool_allocator.h: Convert to a standard-conforming
	allocator.
	* src/allocator.cc: Tweak instantiations.
	* testsuite/performance/20_util/allocator/insert.cc: Add __pool_alloc.
	* testsuite/performance/20_util/allocator/insert_insert.cc: Ditto.
	* testsuite/performance/20_util/allocator/list_sort_search.cc: Ditto.
	* testsuite/performance/20_util/allocator/map_mt_find.cc: Ditto.
	* testsuite/performance/20_util/allocator/map_thread.cc: Ditto.
	* testsuite/performance/20_util/allocator/producer_consumer.cc: Ditto.

From-SVN: r79824
parent 1bbd65cd
Showing with 323 additions and 173 deletions
libstdc++-v3/ChangeLog
2004-03-22 Paolo Carlini <pcarlini@suse.de>
* acinclude.m4 (GLIBCXX_ENABLE_ALLOCATOR): Add pool_allocator.
* configure: Regenerate.
* config/allocator/pool_allocator_base.h: New.
* include/ext/pool_allocator.h: Convert to a standard-conforming
allocator.
* src/allocator.cc: Tweak instantiations.
* testsuite/performance/20_util/allocator/insert.cc: Add __pool_alloc.
* testsuite/performance/20_util/allocator/insert_insert.cc: Ditto.
* testsuite/performance/20_util/allocator/list_sort_search.cc: Ditto.
* testsuite/performance/20_util/allocator/map_mt_find.cc: Ditto.
* testsuite/performance/20_util/allocator/map_thread.cc: Ditto.
* testsuite/performance/20_util/allocator/producer_consumer.cc: Ditto.
2004-03-22 Hans-Peter Nilsson <hp@axis.com> 2004-03-22 Hans-Peter Nilsson <hp@axis.com>
* config/cpu/cris/atomicity.h (__atomic_add): Remove "static * config/cpu/cris/atomicity.h (__atomic_add): Remove "static
......
libstdc++-v3/acinclude.m4
...@@ -1183,7 +1183,7 @@ AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [ ...@@ -1183,7 +1183,7 @@ AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
AC_MSG_CHECKING([for std::allocator base class to use]) AC_MSG_CHECKING([for std::allocator base class to use])
GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND], GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
[use KIND for target std::allocator base], [use KIND for target std::allocator base],
[permit new|malloc|mt|bitmap|yes|no|auto]) [permit new|malloc|mt|bitmap|pool|yes|no|auto])
# If they didn't use this option switch, or if they specified --enable # If they didn't use this option switch, or if they specified --enable
# with no specific model, we'll have to look for one. If they # with no specific model, we'll have to look for one. If they
# specified --disable (???), do likewise. # specified --disable (???), do likewise.
...@@ -1224,6 +1224,10 @@ AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [ ...@@ -1224,6 +1224,10 @@ AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
ALLOCATOR_H=config/allocator/new_allocator_base.h ALLOCATOR_H=config/allocator/new_allocator_base.h
ALLOCATOR_NAME=__gnu_cxx::new_allocator ALLOCATOR_NAME=__gnu_cxx::new_allocator
;; ;;
pool)
ALLOCATOR_H=config/allocator/pool_allocator_base.h
ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
;;
esac esac
AC_SUBST(ALLOCATOR_H) AC_SUBST(ALLOCATOR_H)
......
libstdc++-v3/config/allocator/pool_allocator_base.h 0 → 100644
// Base to std::allocator -*- C++ -*-
// Copyright (C) 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
#ifndef _CXX_ALLOCATOR_H
#define _CXX_ALLOCATOR_H 1
// Define new_allocator as the base class to std::allocator.
#include <ext/pool_allocator.h>
#define ___glibcxx_base_allocator __gnu_cxx::__pool_alloc
#endif
libstdc++-v3/configure
This source diff could not be displayed because it is too large. You can view the blob instead.
libstdc++-v3/include/ext/pool_allocator.h
...@@ -59,9 +59,8 @@ namespace __gnu_cxx ...@@ -59,9 +59,8 @@ namespace __gnu_cxx
/** /**
* @if maint * @if maint
* Default node allocator. "SGI" style. Uses various allocators to * Uses various allocators to fulfill underlying requests (and makes as
* fulfill underlying requests (and makes as few requests as possible * few requests as possible when in default high-speed pool mode).
* when in default high-speed pool mode).
* *
* Important implementation properties: * Important implementation properties:
* 0. If globally mandated, then allocate objects from new * 0. If globally mandated, then allocate objects from new
...@@ -72,25 +71,59 @@ namespace __gnu_cxx ...@@ -72,25 +71,59 @@ namespace __gnu_cxx
* information that we can return the object to the proper free list * information that we can return the object to the proper free list
* without permanently losing part of the object. * without permanently losing part of the object.
* *
* The first template parameter specifies whether more than one thread may
* use this allocator. It is safe to allocate an object from one instance
* of a default_alloc and deallocate it with another one. This effectively
* transfers its ownership to the second one. This may have undesirable
* effects on reference locality.
*
* The second parameter is unused and serves only to allow the
* creation of multiple default_alloc instances. Note that
* containers built on different allocator instances have different
* types, limiting the utility of this approach. If you do not
* wish to share the free lists with the main default_alloc
* instance, instantiate this with a non-zero __inst.
*
* @endif * @endif
* (See @link Allocators allocators info @endlink for more.) * (See @link Allocators allocators info @endlink for more.)
*/ */
template<bool __threads, int __inst> template<typename _Tp>
class __pool_alloc 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); }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 402. wrong new expression in [some_] allocator::construct
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: private:
enum {_S_align = 8}; enum {_S_align = 8};
enum {_S_max_bytes = 128}; enum {_S_max_bytes = 128};
...@@ -134,40 +167,28 @@ namespace __gnu_cxx ...@@ -134,40 +167,28 @@ namespace __gnu_cxx
// test whether threads are in use. // test whether threads are in use.
struct _Lock struct _Lock
{ {
_Lock() { if (__threads) _S_lock._M_acquire_lock(); } _Lock() { _S_lock._M_acquire_lock(); }
~_Lock() { if (__threads) _S_lock._M_release_lock(); } ~_Lock() { _S_lock._M_release_lock(); }
} __attribute__ ((__unused__)); } __attribute__ ((__unused__));
friend struct _Lock; friend struct _Lock;
public:
// __n must be > 0
static void*
allocate(size_t __n);
// __p may not be 0
static void
deallocate(void* __p, size_t __n);
}; };
template<bool __threads, int __inst> template<typename _Tp>
inline bool inline bool
operator==(const __pool_alloc<__threads,__inst>&, operator==(const __pool_alloc<_Tp>&, const __pool_alloc<_Tp>&)
const __pool_alloc<__threads,__inst>&)
{ return true; } { return true; }
template<bool __threads, int __inst> template<typename _Tp>
inline bool inline bool
operator!=(const __pool_alloc<__threads,__inst>&, operator!=(const __pool_alloc<_Tp>&, const __pool_alloc<_Tp>&)
const __pool_alloc<__threads,__inst>&)
{ return false; } { return false; }
// Allocate memory in large chunks in order to avoid fragmenting the // Allocate memory in large chunks in order to avoid fragmenting the
// heap too much. Assume that __n is properly aligned. We hold // heap too much. Assume that __n is properly aligned. We hold
// the allocation lock. // the allocation lock.
template<bool __threads, int __inst> template<typename _Tp>
char* char*
__pool_alloc<__threads, __inst>::_S_chunk_alloc(size_t __n, int& __nobjs) __pool_alloc<_Tp>::_S_chunk_alloc(size_t __n, int& __nobjs)
{ {
char* __result; char* __result;
size_t __total_bytes = __n * __nobjs; size_t __total_bytes = __n * __nobjs;
...@@ -238,9 +259,9 @@ namespace __gnu_cxx ...@@ -238,9 +259,9 @@ namespace __gnu_cxx
// Returns an object of size __n, and optionally adds to "size // Returns an object of size __n, and optionally adds to "size
// __n"'s free list. We assume that __n is properly aligned. We // __n"'s free list. We assume that __n is properly aligned. We
// hold the allocation lock. // hold the allocation lock.
template<bool __threads, int __inst> template<typename _Tp>
void* void*
__pool_alloc<__threads, __inst>::_S_refill(size_t __n) __pool_alloc<_Tp>::_S_refill(size_t __n)
{ {
int __nobjs = 20; int __nobjs = 20;
char* __chunk = _S_chunk_alloc(__n, __nobjs); char* __chunk = _S_chunk_alloc(__n, __nobjs);
...@@ -272,92 +293,99 @@ namespace __gnu_cxx ...@@ -272,92 +293,99 @@ namespace __gnu_cxx
return __result; return __result;
} }
template<bool __threads, int __inst> template<typename _Tp>
void* _Tp*
__pool_alloc<__threads, __inst>::allocate(size_t __n) __pool_alloc<_Tp>::allocate(size_type __n, const void*)
{ {
void* __ret = 0; pointer __ret = 0;
if (__n)
// If there is a race through here, assume answer from getenv
// will resolve in same direction. Inspired by techniques
// to efficiently support threading found in basic_string.h.
if (_S_force_new == 0)
{
if (getenv("GLIBCXX_FORCE_NEW"))
__atomic_add(&_S_force_new, 1);
else
__atomic_add(&_S_force_new, -1);
}
if ((__n > (size_t) _S_max_bytes) || (_S_force_new > 0))
__ret = ::operator new(__n);
else
{ {
_Obj* volatile* __free_list = _S_free_list + _S_freelist_index(__n); if (__n <= max_size())
// Acquire the lock here with a constructor call. This
// ensures that it is released in exit or during stack
// unwinding.
_Lock __lock_instance;
_Obj* __restrict__ __result = *__free_list;
if (__builtin_expect(__result == 0, 0))
__ret = _S_refill(_S_round_up(__n));
else
{ {
*__free_list = __result -> _M_free_list_link; const size_t __bytes = __n * sizeof(_Tp);
__ret = __result; // If there is a race through here, assume answer from getenv
// will resolve in same direction. Inspired by techniques
// to efficiently support threading found in basic_string.h.
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));
// Acquire the lock here with a constructor call. This
// ensures that it is released in exit or during stack
// unwinding.
_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();
}
} }
if (__builtin_expect(__ret == 0, 0)) else
__throw_bad_alloc(); __throw_bad_alloc();
} }
return __ret; return __ret;
} }
template<bool __threads, int __inst> template<typename _Tp>
void void
__pool_alloc<__threads, __inst>::deallocate(void* __p, size_t __n) __pool_alloc<_Tp>::deallocate(pointer __p, size_type __n)
{ {
if ((__n > (size_t) _S_max_bytes) || (_S_force_new > 0)) if (__n)
::operator delete(__p);
else
{ {
_Obj* volatile* __free_list = _S_free_list + _S_freelist_index(__n); const size_t __bytes = __n * sizeof(_Tp);
_Obj* __q = (_Obj*)__p; if ((__bytes > (size_t) _S_max_bytes) || (_S_force_new > 0))
::operator delete(__p);
// Acquire the lock here with a constructor call. This else
// ensures that it is released in exit or during stack {
// unwinding. _Obj* volatile* __free_list = (_S_free_list
_Lock __lock_instance; + _S_freelist_index(__bytes));
__q -> _M_free_list_link = *__free_list; _Obj* __q = (_Obj*)__p;
*__free_list = __q;
// Acquire the lock here with a constructor call. This
// ensures that it is released in exit or during stack
// unwinding.
_Lock __lock_instance;
__q -> _M_free_list_link = *__free_list;
*__free_list = __q;
}
} }
} }
template<bool __threads, int __inst> template<typename _Tp>
typename __pool_alloc<__threads, __inst>::_Obj* volatile typename __pool_alloc<_Tp>::_Obj* volatile
__pool_alloc<__threads, __inst>::_S_free_list[_S_freelists]; __pool_alloc<_Tp>::_S_free_list[_S_freelists];
template<bool __threads, int __inst> template<typename _Tp>
char* __pool_alloc<__threads, __inst>::_S_start_free = 0; char* __pool_alloc<_Tp>::_S_start_free = 0;
template<bool __threads, int __inst> template<typename _Tp>
char* __pool_alloc<__threads, __inst>::_S_end_free = 0; char* __pool_alloc<_Tp>::_S_end_free = 0;
template<bool __threads, int __inst> template<typename _Tp>
size_t __pool_alloc<__threads, __inst>::_S_heap_size = 0; size_t __pool_alloc<_Tp>::_S_heap_size = 0;
template<bool __threads, int __inst> template<typename _Tp>
_STL_mutex_lock _STL_mutex_lock
__pool_alloc<__threads, __inst>::_S_lock __STL_MUTEX_INITIALIZER; __pool_alloc<_Tp>::_S_lock __STL_MUTEX_INITIALIZER;
template<bool __threads, int __inst> _Atomic_word template<typename _Tp> _Atomic_word
__pool_alloc<__threads, __inst>::_S_force_new = 0; __pool_alloc<_Tp>::_S_force_new = 0;
// Inhibit implicit instantiations for required instantiations,
// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#if _GLIBCXX_EXTERN_TEMPLATE
extern template class __pool_alloc<true, 0>;
#endif
} // namespace __gnu_cxx } // namespace __gnu_cxx
#endif #endif
libstdc++-v3/src/allocator.cc
...@@ -44,5 +44,6 @@ namespace __gnu_cxx ...@@ -44,5 +44,6 @@ namespace __gnu_cxx
template class __mt_alloc<wchar_t>; template class __mt_alloc<wchar_t>;
// Static members of __pool_alloc. // Static members of __pool_alloc.
template class __pool_alloc<true, 0>; template class __pool_alloc<char>;
template class __pool_alloc<wchar_t>;
} // namespace __gnu_cxx } // namespace __gnu_cxx
libstdc++-v3/testsuite/performance/20_util/allocator/insert.cc
...@@ -44,6 +44,7 @@ ...@@ -44,6 +44,7 @@
#include <ext/new_allocator.h> #include <ext/new_allocator.h>
#include <ext/malloc_allocator.h> #include <ext/malloc_allocator.h>
#include <ext/bitmap_allocator.h> #include <ext/bitmap_allocator.h>
#include <ext/pool_allocator.h>
#include <cxxabi.h> #include <cxxabi.h>
#include <testsuite_performance.h> #include <testsuite_performance.h>
...@@ -148,6 +149,7 @@ int main(void) ...@@ -148,6 +149,7 @@ int main(void)
typedef __gnu_cxx::new_allocator<test_type> n_alloc_type; typedef __gnu_cxx::new_allocator<test_type> n_alloc_type;
typedef __gnu_cxx::__mt_alloc<test_type> so_alloc_type; typedef __gnu_cxx::__mt_alloc<test_type> so_alloc_type;
typedef __gnu_cxx::bitmap_allocator<test_type> bit_alloc_type; typedef __gnu_cxx::bitmap_allocator<test_type> bit_alloc_type;
typedef __gnu_cxx::__pool_alloc<test_type> po_alloc_type;
#ifdef TEST_B0 #ifdef TEST_B0
test_container(vector<test_type, m_alloc_type>()); test_container(vector<test_type, m_alloc_type>());
...@@ -161,59 +163,74 @@ int main(void) ...@@ -161,59 +163,74 @@ int main(void)
#ifdef TEST_B3 #ifdef TEST_B3
test_container(vector<test_type, bit_alloc_type>()); test_container(vector<test_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_B4 #ifdef TEST_B4
test_container(list<test_type, m_alloc_type>()); test_container(vector<test_type, po_alloc_type>());
#endif #endif
#ifdef TEST_B5 #ifdef TEST_B5
test_container(list<test_type, n_alloc_type>()); test_container(list<test_type, m_alloc_type>());
#endif #endif
#ifdef TEST_B6 #ifdef TEST_B6
test_container(list<test_type, so_alloc_type>()); test_container(list<test_type, n_alloc_type>());
#endif #endif
#ifdef TEST_B7 #ifdef TEST_B7
test_container(list<test_type, so_alloc_type>());
#endif
#ifdef TEST_B8
test_container(list<test_type, bit_alloc_type>()); test_container(list<test_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_B9
test_container(list<test_type, po_alloc_type>());
#endif
#ifdef TEST_B8 #ifdef TEST_B10
test_container(deque<test_type, m_alloc_type>()); test_container(deque<test_type, m_alloc_type>());
#endif #endif
#ifdef TEST_B9 #ifdef TEST_B11
test_container(deque<test_type, n_alloc_type>()); test_container(deque<test_type, n_alloc_type>());
#endif #endif
#ifdef TEST_B10 #ifdef TEST_B12
test_container(deque<test_type, so_alloc_type>()); test_container(deque<test_type, so_alloc_type>());
#endif #endif
#ifdef TEST_B11 #ifdef TEST_B13
test_container(deque<test_type, bit_alloc_type>()); test_container(deque<test_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_B14
test_container(deque<test_type, po_alloc_type>());
#endif
typedef less<test_type> compare_type; typedef less<test_type> compare_type;
#ifdef TEST_B12 #ifdef TEST_B15
test_container(map<test_type, test_type, compare_type, m_alloc_type>()); test_container(map<test_type, test_type, compare_type, m_alloc_type>());
#endif #endif
#ifdef TEST_B13 #ifdef TEST_B16
test_container(map<test_type, test_type, compare_type, n_alloc_type>()); test_container(map<test_type, test_type, compare_type, n_alloc_type>());
#endif #endif
#ifdef TEST_B14 #ifdef TEST_B17
test_container(map<test_type, test_type, compare_type, so_alloc_type>()); test_container(map<test_type, test_type, compare_type, so_alloc_type>());
#endif #endif
#ifdef TEST_B15 #ifdef TEST_B18
test_container(map<test_type, test_type, compare_type, bit_alloc_type>()); test_container(map<test_type, test_type, compare_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_B19
test_container(map<test_type, test_type, compare_type, po_alloc_type>());
#endif
#ifdef TEST_B16 #ifdef TEST_B20
test_container(set<test_type, compare_type, m_alloc_type>()); test_container(set<test_type, compare_type, m_alloc_type>());
#endif #endif
#ifdef TEST_B17 #ifdef TEST_B21
test_container(set<test_type, compare_type, n_alloc_type>()); test_container(set<test_type, compare_type, n_alloc_type>());
#endif #endif
#ifdef TEST_B18 #ifdef TEST_B22
test_container(set<test_type, compare_type, so_alloc_type>()); test_container(set<test_type, compare_type, so_alloc_type>());
#endif #endif
#ifdef TEST_B19 #ifdef TEST_B23
test_container(set<test_type, compare_type, bit_alloc_type>()); test_container(set<test_type, compare_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_B24
test_container(set<test_type, compare_type, po_alloc_type>());
#endif
#ifdef TEST_T0 #ifdef TEST_T0
test_container(vector<test_type, m_alloc_type>(), true); test_container(vector<test_type, m_alloc_type>(), true);
...@@ -227,59 +244,73 @@ int main(void) ...@@ -227,59 +244,73 @@ int main(void)
#ifdef TEST_T3 #ifdef TEST_T3
test_container(vector<test_type, bit_alloc_type>(), true); test_container(vector<test_type, bit_alloc_type>(), true);
#endif #endif
#ifdef TEST_T4 #ifdef TEST_T4
test_container(list<test_type, m_alloc_type>(), true); test_container(vector<test_type, po_alloc_type>(), true);
#endif #endif
#ifdef TEST_T5 #ifdef TEST_T5
test_container(list<test_type, n_alloc_type>(), true); test_container(list<test_type, m_alloc_type>(), true);
#endif #endif
#ifdef TEST_T6 #ifdef TEST_T6
test_container(list<test_type, so_alloc_type>(), true); test_container(list<test_type, n_alloc_type>(), true);
#endif #endif
#ifdef TEST_T7 #ifdef TEST_T7
test_container(list<test_type, so_alloc_type>(), true);
#endif
#ifdef TEST_T8
test_container(list<test_type, bit_alloc_type>(), true); test_container(list<test_type, bit_alloc_type>(), true);
#endif #endif
#ifdef TEST_T9
test_container(list<test_type, po_alloc_type>(), true);
#endif
#ifdef TEST_T8 #ifdef TEST_T10
test_container(deque<test_type, m_alloc_type>(), true); test_container(deque<test_type, m_alloc_type>(), true);
#endif #endif
#ifdef TEST_T9 #ifdef TEST_T11
test_container(deque<test_type, n_alloc_type>(), true); test_container(deque<test_type, n_alloc_type>(), true);
#endif #endif
#ifdef TEST_T10 #ifdef TEST_T12
test_container(deque<test_type, so_alloc_type>(), true); test_container(deque<test_type, so_alloc_type>(), true);
#endif #endif
#ifdef TEST_T11 #ifdef TEST_T13
test_container(deque<test_type, bit_alloc_type>(), true); test_container(deque<test_type, bit_alloc_type>(), true);
#endif #endif
#ifdef TEST_T14
test_container(deque<test_type, po_alloc_type>(), true);
#endif
typedef less<test_type> compare_type; typedef less<test_type> compare_type;
#ifdef TEST_T12 #ifdef TEST_T15
test_container(map<test_type, test_type, compare_type, m_alloc_type>(), true); test_container(map<test_type, test_type, compare_type, m_alloc_type>(), true);
#endif #endif
#ifdef TEST_T13 #ifdef TEST_T16
test_container(map<test_type, test_type, compare_type, n_alloc_type>(), true); test_container(map<test_type, test_type, compare_type, n_alloc_type>(), true);
#endif #endif
#ifdef TEST_T14 #ifdef TEST_T17
test_container(map<test_type, test_type, compare_type, so_alloc_type>(), true); test_container(map<test_type, test_type, compare_type, so_alloc_type>(), true);
#endif #endif
#ifdef TEST_T15 #ifdef TEST_T18
test_container(map<test_type, test_type, compare_type, bit_alloc_type>(), true); test_container(map<test_type, test_type, compare_type, bit_alloc_type>(), true);
#endif #endif
#ifdef TEST_T19
test_container(map<test_type, test_type, compare_type, po_alloc_type>(), true);
#endif
#ifdef TEST_T16 #ifdef TEST_T20
test_container(set<test_type, compare_type, m_alloc_type>(), true); test_container(set<test_type, compare_type, m_alloc_type>(), true);
#endif #endif
#ifdef TEST_T17 #ifdef TEST_T21
test_container(set<test_type, compare_type, n_alloc_type>(), true); test_container(set<test_type, compare_type, n_alloc_type>(), true);
#endif #endif
#ifdef TEST_T18 #ifdef TEST_T22
test_container(set<test_type, compare_type, so_alloc_type>(), true); test_container(set<test_type, compare_type, so_alloc_type>(), true);
#endif #endif
#ifdef TEST_T19 #ifdef TEST_T23
test_container(set<test_type, compare_type, bit_alloc_type>(), true); test_container(set<test_type, compare_type, bit_alloc_type>(), true);
#endif #endif
#ifdef TEST_T24
test_container(set<test_type, compare_type, po_alloc_type>(), true);
#endif
return 0; return 0;
} }
libstdc++-v3/testsuite/performance/20_util/allocator/insert_insert.cc
...@@ -44,6 +44,7 @@ ...@@ -44,6 +44,7 @@
#include <ext/new_allocator.h> #include <ext/new_allocator.h>
#include <ext/malloc_allocator.h> #include <ext/malloc_allocator.h>
#include <ext/bitmap_allocator.h> #include <ext/bitmap_allocator.h>
#include <ext/pool_allocator.h>
#include <cxxabi.h> #include <cxxabi.h>
#include <testsuite_performance.h> #include <testsuite_performance.h>
...@@ -119,6 +120,7 @@ int main(void) ...@@ -119,6 +120,7 @@ int main(void)
typedef __gnu_cxx::new_allocator<test_type> n_alloc_type; typedef __gnu_cxx::new_allocator<test_type> n_alloc_type;
typedef __gnu_cxx::__mt_alloc<test_type> so_alloc_type; typedef __gnu_cxx::__mt_alloc<test_type> so_alloc_type;
typedef __gnu_cxx::bitmap_allocator<test_type> bit_alloc_type; typedef __gnu_cxx::bitmap_allocator<test_type> bit_alloc_type;
typedef __gnu_cxx::__pool_alloc<test_type> po_alloc_type;
#ifdef TEST_S0 #ifdef TEST_S0
test_container(vector<test_type, m_alloc_type>()); test_container(vector<test_type, m_alloc_type>());
...@@ -132,62 +134,73 @@ int main(void) ...@@ -132,62 +134,73 @@ int main(void)
#ifdef TEST_S3 #ifdef TEST_S3
test_container(vector<test_type, bit_alloc_type>()); test_container(vector<test_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_S4 #ifdef TEST_S4
test_container(list<test_type, m_alloc_type>()); test_container(vector<test_type, po_alloc_type>());
#endif #endif
#ifdef TEST_S5 #ifdef TEST_S5
test_container(list<test_type, n_alloc_type>()); test_container(list<test_type, m_alloc_type>());
#endif #endif
#ifdef TEST_S6 #ifdef TEST_S6
test_container(list<test_type, so_alloc_type>()); test_container(list<test_type, n_alloc_type>());
#endif #endif
#ifdef TEST_S7 #ifdef TEST_S7
test_container(list<test_type, so_alloc_type>());
#endif
#ifdef TEST_S8
test_container(list<test_type, bit_alloc_type>()); test_container(list<test_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_S9
test_container(list<test_type, po_alloc_type>());
#endif
#ifdef TEST_S10
#ifdef TEST_S8
test_container(deque<test_type, m_alloc_type>()); test_container(deque<test_type, m_alloc_type>());
#endif #endif
#ifdef TEST_S9 #ifdef TEST_S11
test_container(deque<test_type, n_alloc_type>()); test_container(deque<test_type, n_alloc_type>());
#endif #endif
#ifdef TEST_S10 #ifdef TEST_S12
test_container(deque<test_type, so_alloc_type>()); test_container(deque<test_type, so_alloc_type>());
#endif #endif
#ifdef TEST_S11 #ifdef TEST_S13
test_container(deque<test_type, bit_alloc_type>()); test_container(deque<test_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_S14
test_container(deque<test_type, po_alloc_type>());
#endif
typedef less<test_type> compare_type; typedef less<test_type> compare_type;
#ifdef TEST_S12 #ifdef TEST_S15
test_container(map<test_type, test_type, compare_type, m_alloc_type>()); test_container(map<test_type, test_type, compare_type, m_alloc_type>());
#endif #endif
#ifdef TEST_S13 #ifdef TEST_S16
test_container(map<test_type, test_type, compare_type, n_alloc_type>()); test_container(map<test_type, test_type, compare_type, n_alloc_type>());
#endif #endif
#ifdef TEST_S14 #ifdef TEST_S17
test_container(map<test_type, test_type, compare_type, so_alloc_type>()); test_container(map<test_type, test_type, compare_type, so_alloc_type>());
#endif #endif
#ifdef TEST_S15 #ifdef TEST_S18
test_container(map<test_type, test_type, compare_type, bit_alloc_type>()); test_container(map<test_type, test_type, compare_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_S19
test_container(map<test_type, test_type, compare_type, po_alloc_type>());
#endif
#ifdef TEST_S20
#ifdef TEST_S12
test_container(set<test_type, compare_type, m_alloc_type>()); test_container(set<test_type, compare_type, m_alloc_type>());
#endif #endif
#ifdef TEST_S13 #ifdef TEST_S21
test_container(set<test_type, compare_type, n_alloc_type>()); test_container(set<test_type, compare_type, n_alloc_type>());
#endif #endif
#ifdef TEST_S14 #ifdef TEST_S22
test_container(set<test_type, compare_type, so_alloc_type>()); test_container(set<test_type, compare_type, so_alloc_type>());
#endif #endif
#ifdef TEST_S14 #ifdef TEST_S23
test_container(set<test_type, compare_type, bit_alloc_type>()); test_container(set<test_type, compare_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_S24
test_container(set<test_type, compare_type, po_alloc_type>());
#endif
return 0; return 0;
} }
libstdc++-v3/testsuite/performance/20_util/allocator/list_sort_search.cc
...@@ -34,11 +34,13 @@ ...@@ -34,11 +34,13 @@
#include <cxxabi.h> #include <cxxabi.h>
#include <testsuite_performance.h> #include <testsuite_performance.h>
#include <ext/bitmap_allocator.h> #include <ext/bitmap_allocator.h>
#include <ext/pool_allocator.h>
using namespace std; using namespace std;
using __gnu_cxx::malloc_allocator; using __gnu_cxx::malloc_allocator;
using __gnu_cxx::__mt_alloc; using __gnu_cxx::__mt_alloc;
using __gnu_cxx::bitmap_allocator; using __gnu_cxx::bitmap_allocator;
using __gnu_cxx::__pool_alloc;
typedef int test_type; typedef int test_type;
...@@ -105,7 +107,6 @@ void do_test () ...@@ -105,7 +107,6 @@ void do_test ()
report_performance(__FILE__, string(), time, resource); report_performance(__FILE__, string(), time, resource);
} }
int main () int main ()
{ {
#ifdef TEST_S0 #ifdef TEST_S0
...@@ -120,6 +121,9 @@ int main () ...@@ -120,6 +121,9 @@ int main ()
#ifdef TEST_S3 #ifdef TEST_S3
do_test<__mt_alloc<int> >(); do_test<__mt_alloc<int> >();
#endif #endif
#ifdef TEST_S4
do_test<__pool_alloc<int> >();
#endif
} }
libstdc++-v3/testsuite/performance/20_util/allocator/map_mt_find.cc
...@@ -40,11 +40,13 @@ ...@@ -40,11 +40,13 @@
#include <cxxabi.h> #include <cxxabi.h>
#include <testsuite_performance.h> #include <testsuite_performance.h>
#include <ext/bitmap_allocator.h> #include <ext/bitmap_allocator.h>
#include <ext/pool_allocator.h>
using namespace std; using namespace std;
using __gnu_cxx::malloc_allocator; using __gnu_cxx::malloc_allocator;
using __gnu_cxx::__mt_alloc; using __gnu_cxx::__mt_alloc;
using __gnu_cxx::bitmap_allocator; using __gnu_cxx::bitmap_allocator;
using __gnu_cxx::__pool_alloc;
typedef int test_type; typedef int test_type;
...@@ -145,4 +147,7 @@ int main() ...@@ -145,4 +147,7 @@ int main()
#ifdef TEST_T3 #ifdef TEST_T3
exec_tests<__mt_alloc<int> >(); exec_tests<__mt_alloc<int> >();
#endif #endif
#ifdef TEST_T4
exec_tests<__pool_alloc<int> >();
#endif
} }
libstdc++-v3/testsuite/performance/20_util/allocator/map_thread.cc
...@@ -41,6 +41,7 @@ ...@@ -41,6 +41,7 @@
#include <ext/new_allocator.h> #include <ext/new_allocator.h>
#include <ext/malloc_allocator.h> #include <ext/malloc_allocator.h>
#include <ext/bitmap_allocator.h> #include <ext/bitmap_allocator.h>
#include <ext/pool_allocator.h>
#include <cxxabi.h> #include <cxxabi.h>
#include <testsuite_performance.h> #include <testsuite_performance.h>
...@@ -49,6 +50,7 @@ using __gnu_cxx::__mt_alloc; ...@@ -49,6 +50,7 @@ using __gnu_cxx::__mt_alloc;
using __gnu_cxx::new_allocator; using __gnu_cxx::new_allocator;
using __gnu_cxx::malloc_allocator; using __gnu_cxx::malloc_allocator;
using __gnu_cxx::bitmap_allocator; using __gnu_cxx::bitmap_allocator;
using __gnu_cxx::__pool_alloc;
// The number of iterations to be performed. // The number of iterations to be performed.
int iterations = 10000; int iterations = 10000;
...@@ -125,7 +127,8 @@ int main(void) ...@@ -125,7 +127,8 @@ int main(void)
#ifdef TEST_T5 #ifdef TEST_T5
test_container(map<int, int, less<const int>, bitmap_allocator<int> >()); test_container(map<int, int, less<const int>, bitmap_allocator<int> >());
#endif #endif
#ifdef TEST_T6
test_container(map<int, int, less<const int>, __pool_alloc<int> >());
#endif
return 0; return 0;
} }
libstdc++-v3/testsuite/performance/20_util/allocator/producer_consumer.cc
...@@ -42,6 +42,7 @@ ...@@ -42,6 +42,7 @@
#include <ext/new_allocator.h> #include <ext/new_allocator.h>
#include <ext/malloc_allocator.h> #include <ext/malloc_allocator.h>
#include <ext/bitmap_allocator.h> #include <ext/bitmap_allocator.h>
#include <ext/pool_allocator.h>
#include <cxxabi.h> #include <cxxabi.h>
#include <testsuite_performance.h> #include <testsuite_performance.h>
...@@ -51,6 +52,7 @@ using __gnu_cxx::__mt_alloc; ...@@ -51,6 +52,7 @@ using __gnu_cxx::__mt_alloc;
using __gnu_cxx::new_allocator; using __gnu_cxx::new_allocator;
using __gnu_cxx::malloc_allocator; using __gnu_cxx::malloc_allocator;
using __gnu_cxx::bitmap_allocator; using __gnu_cxx::bitmap_allocator;
using __gnu_cxx::__pool_alloc;
using abi::__cxa_demangle; using abi::__cxa_demangle;
typedef int test_type; typedef int test_type;
...@@ -59,6 +61,7 @@ typedef malloc_allocator<test_type> malloc_alloc_type; ...@@ -59,6 +61,7 @@ typedef malloc_allocator<test_type> malloc_alloc_type;
typedef new_allocator<test_type> new_alloc_type; typedef new_allocator<test_type> new_alloc_type;
typedef __mt_alloc<test_type> so_alloc_type; typedef __mt_alloc<test_type> so_alloc_type;
typedef bitmap_allocator<test_type> bit_alloc_type; typedef bitmap_allocator<test_type> bit_alloc_type;
typedef __pool_alloc<test_type> po_alloc_type;
// The number of iterations to be performed. // The number of iterations to be performed.
int iterations = 10000; int iterations = 10000;
...@@ -298,35 +301,41 @@ int main(void) ...@@ -298,35 +301,41 @@ int main(void)
#ifdef TEST_T4 #ifdef TEST_T4
test_container(vector<test_type, bit_alloc_type>()); test_container(vector<test_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_T5 #ifdef TEST_T5
test_container(list<test_type, malloc_alloc_type>()); test_container(vector<test_type, po_alloc_type>());
#endif #endif
#ifdef TEST_T6 #ifdef TEST_T6
test_container(list<test_type, new_alloc_type>()); test_container(list<test_type, malloc_alloc_type>());
#endif #endif
#ifdef TEST_T7 #ifdef TEST_T7
test_container(list<test_type, so_alloc_type>()); test_container(list<test_type, new_alloc_type>());
#endif #endif
#ifdef TEST_T8 #ifdef TEST_T8
test_container(list<test_type, so_alloc_type>());
#endif
#ifdef TEST_T9
test_container(list<test_type, bit_alloc_type>()); test_container(list<test_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_T10
test_container(list<test_type, po_alloc_type>());
#endif
#ifdef TEST_T11
#ifdef TEST_T9
test_container(map<test_type, test_type, compare_type, malloc_alloc_type>()); test_container(map<test_type, test_type, compare_type, malloc_alloc_type>());
#endif #endif
#ifdef TEST_T10 #ifdef TEST_T12
test_container(map<test_type, test_type, compare_type, new_alloc_type>()); test_container(map<test_type, test_type, compare_type, new_alloc_type>());
#endif #endif
#ifdef TEST_T11 #ifdef TEST_T13
test_container(map<test_type, test_type, compare_type, so_alloc_type>()); test_container(map<test_type, test_type, compare_type, so_alloc_type>());
#endif #endif
#ifdef TEST_T12 #ifdef TEST_T14
test_container(map<test_type, test_type, compare_type, bit_alloc_type>()); test_container(map<test_type, test_type, compare_type, bit_alloc_type>());
#endif #endif
#ifdef TEST_T15
test_container(map<test_type, test_type, compare_type, po_alloc_type>());
#endif
return 0; return 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