mirror of
git://gcc.gnu.org/git/gcc.git
synced 2025-04-03 05:10:26 +08:00
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
This commit is contained in:
Paolo Carlini
Paolo Carlini
parent
1bbd65cd87
commit
29d4adf460
@ -1,3 +1,18 @@
|
||||
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>
|
||||
|
||||
* config/cpu/cris/atomicity.h (__atomic_add): Remove "static
|
||||
|
||||
@ -1183,7 +1183,7 @@ AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
|
||||
AC_MSG_CHECKING([for std::allocator base class to use])
|
||||
GLIBCXX_ENABLE(libstdcxx-allocator,auto,[=KIND],
|
||||
[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
|
||||
# with no specific model, we'll have to look for one. If they
|
||||
# specified --disable (???), do likewise.
|
||||
@ -1224,6 +1224,10 @@ AC_DEFUN([GLIBCXX_ENABLE_ALLOCATOR], [
|
||||
ALLOCATOR_H=config/allocator/new_allocator_base.h
|
||||
ALLOCATOR_NAME=__gnu_cxx::new_allocator
|
||||
;;
|
||||
pool)
|
||||
ALLOCATOR_H=config/allocator/pool_allocator_base.h
|
||||
ALLOCATOR_NAME=__gnu_cxx::__pool_alloc
|
||||
;;
|
||||
esac
|
||||
|
||||
AC_SUBST(ALLOCATOR_H)
|
||||
|
||||
37
libstdc++-v3/config/allocator/pool_allocator_base.h
Normal file
37
libstdc++-v3/config/allocator/pool_allocator_base.h
Normal file
@ -0,0 +1,37 @@
|
||||
// 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
|
||||
2068
libstdc++-v3/configure
vendored
2068
libstdc++-v3/configure
vendored
File diff suppressed because it is too large
Load Diff
@ -59,9 +59,8 @@ namespace __gnu_cxx
|
||||
|
||||
/**
|
||||
* @if maint
|
||||
* Default node allocator. "SGI" style. Uses various allocators to
|
||||
* fulfill underlying requests (and makes as few requests as possible
|
||||
* when in default high-speed pool mode).
|
||||
* Uses various allocators to fulfill underlying requests (and makes as
|
||||
* few requests as possible when in default high-speed pool mode).
|
||||
*
|
||||
* Important implementation properties:
|
||||
* 0. If globally mandated, then allocate objects from new
|
||||
@ -72,25 +71,59 @@ namespace __gnu_cxx
|
||||
* information that we can return the object to the proper free list
|
||||
* 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
|
||||
* (See @link Allocators allocators info @endlink for more.)
|
||||
*/
|
||||
template<bool __threads, int __inst>
|
||||
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); }
|
||||
|
||||
// _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:
|
||||
enum {_S_align = 8};
|
||||
enum {_S_max_bytes = 128};
|
||||
@ -134,40 +167,28 @@ namespace __gnu_cxx
|
||||
// test whether threads are in use.
|
||||
struct _Lock
|
||||
{
|
||||
_Lock() { if (__threads) _S_lock._M_acquire_lock(); }
|
||||
~_Lock() { if (__threads) _S_lock._M_release_lock(); }
|
||||
_Lock() { _S_lock._M_acquire_lock(); }
|
||||
~_Lock() { _S_lock._M_release_lock(); }
|
||||
} __attribute__ ((__unused__));
|
||||
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
|
||||
operator==(const __pool_alloc<__threads,__inst>&,
|
||||
const __pool_alloc<__threads,__inst>&)
|
||||
operator==(const __pool_alloc<_Tp>&, const __pool_alloc<_Tp>&)
|
||||
{ return true; }
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
template<typename _Tp>
|
||||
inline bool
|
||||
operator!=(const __pool_alloc<__threads,__inst>&,
|
||||
const __pool_alloc<__threads,__inst>&)
|
||||
operator!=(const __pool_alloc<_Tp>&, const __pool_alloc<_Tp>&)
|
||||
{ return false; }
|
||||
|
||||
|
||||
// Allocate memory in large chunks in order to avoid fragmenting the
|
||||
// heap too much. Assume that __n is properly aligned. We hold
|
||||
// the allocation lock.
|
||||
template<bool __threads, int __inst>
|
||||
template<typename _Tp>
|
||||
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;
|
||||
size_t __total_bytes = __n * __nobjs;
|
||||
@ -238,9 +259,9 @@ namespace __gnu_cxx
|
||||
// Returns an object of size __n, and optionally adds to "size
|
||||
// __n"'s free list. We assume that __n is properly aligned. We
|
||||
// hold the allocation lock.
|
||||
template<bool __threads, int __inst>
|
||||
template<typename _Tp>
|
||||
void*
|
||||
__pool_alloc<__threads, __inst>::_S_refill(size_t __n)
|
||||
__pool_alloc<_Tp>::_S_refill(size_t __n)
|
||||
{
|
||||
int __nobjs = 20;
|
||||
char* __chunk = _S_chunk_alloc(__n, __nobjs);
|
||||
@ -272,92 +293,99 @@ namespace __gnu_cxx
|
||||
return __result;
|
||||
}
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
void*
|
||||
__pool_alloc<__threads, __inst>::allocate(size_t __n)
|
||||
template<typename _Tp>
|
||||
_Tp*
|
||||
__pool_alloc<_Tp>::allocate(size_type __n, const void*)
|
||||
{
|
||||
void* __ret = 0;
|
||||
|
||||
// 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)
|
||||
pointer __ret = 0;
|
||||
if (__n)
|
||||
{
|
||||
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);
|
||||
// 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
|
||||
if (__n <= max_size())
|
||||
{
|
||||
*__free_list = __result -> _M_free_list_link;
|
||||
__ret = __result;
|
||||
const size_t __bytes = __n * sizeof(_Tp);
|
||||
// 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();
|
||||
}
|
||||
return __ret;
|
||||
}
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
template<typename _Tp>
|
||||
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))
|
||||
::operator delete(__p);
|
||||
else
|
||||
if (__n)
|
||||
{
|
||||
_Obj* volatile* __free_list = _S_free_list + _S_freelist_index(__n);
|
||||
_Obj* __q = (_Obj*)__p;
|
||||
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;
|
||||
|
||||
// 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;
|
||||
// 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>
|
||||
typename __pool_alloc<__threads, __inst>::_Obj* volatile
|
||||
__pool_alloc<__threads, __inst>::_S_free_list[_S_freelists];
|
||||
template<typename _Tp>
|
||||
typename __pool_alloc<_Tp>::_Obj* volatile
|
||||
__pool_alloc<_Tp>::_S_free_list[_S_freelists];
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
char* __pool_alloc<__threads, __inst>::_S_start_free = 0;
|
||||
template<typename _Tp>
|
||||
char* __pool_alloc<_Tp>::_S_start_free = 0;
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
char* __pool_alloc<__threads, __inst>::_S_end_free = 0;
|
||||
template<typename _Tp>
|
||||
char* __pool_alloc<_Tp>::_S_end_free = 0;
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
size_t __pool_alloc<__threads, __inst>::_S_heap_size = 0;
|
||||
template<typename _Tp>
|
||||
size_t __pool_alloc<_Tp>::_S_heap_size = 0;
|
||||
|
||||
template<bool __threads, int __inst>
|
||||
template<typename _Tp>
|
||||
_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
|
||||
__pool_alloc<__threads, __inst>::_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
|
||||
template<typename _Tp> _Atomic_word
|
||||
__pool_alloc<_Tp>::_S_force_new = 0;
|
||||
} // namespace __gnu_cxx
|
||||
|
||||
#endif
|
||||
|
||||
@ -44,5 +44,6 @@ namespace __gnu_cxx
|
||||
template class __mt_alloc<wchar_t>;
|
||||
|
||||
// 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
|
||||
|
||||
@ -44,6 +44,7 @@
|
||||
#include <ext/new_allocator.h>
|
||||
#include <ext/malloc_allocator.h>
|
||||
#include <ext/bitmap_allocator.h>
|
||||
#include <ext/pool_allocator.h>
|
||||
#include <cxxabi.h>
|
||||
#include <testsuite_performance.h>
|
||||
|
||||
@ -148,6 +149,7 @@ int main(void)
|
||||
typedef __gnu_cxx::new_allocator<test_type> n_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::__pool_alloc<test_type> po_alloc_type;
|
||||
|
||||
#ifdef TEST_B0
|
||||
test_container(vector<test_type, m_alloc_type>());
|
||||
@ -161,59 +163,74 @@ int main(void)
|
||||
#ifdef TEST_B3
|
||||
test_container(vector<test_type, bit_alloc_type>());
|
||||
#endif
|
||||
|
||||
#ifdef TEST_B4
|
||||
test_container(vector<test_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
#ifdef TEST_B5
|
||||
test_container(list<test_type, m_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B5
|
||||
#ifdef TEST_B6
|
||||
test_container(list<test_type, n_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B6
|
||||
#ifdef TEST_B7
|
||||
test_container(list<test_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B7
|
||||
#ifdef TEST_B8
|
||||
test_container(list<test_type, bit_alloc_type>());
|
||||
#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>());
|
||||
#endif
|
||||
#ifdef TEST_B9
|
||||
#ifdef TEST_B11
|
||||
test_container(deque<test_type, n_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B10
|
||||
#ifdef TEST_B12
|
||||
test_container(deque<test_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B11
|
||||
#ifdef TEST_B13
|
||||
test_container(deque<test_type, bit_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B14
|
||||
test_container(deque<test_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
typedef less<test_type> compare_type;
|
||||
#ifdef TEST_B12
|
||||
#ifdef TEST_B15
|
||||
test_container(map<test_type, test_type, compare_type, m_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B13
|
||||
#ifdef TEST_B16
|
||||
test_container(map<test_type, test_type, compare_type, n_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B14
|
||||
#ifdef TEST_B17
|
||||
test_container(map<test_type, test_type, compare_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B15
|
||||
#ifdef TEST_B18
|
||||
test_container(map<test_type, test_type, compare_type, bit_alloc_type>());
|
||||
#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>());
|
||||
#endif
|
||||
#ifdef TEST_B17
|
||||
#ifdef TEST_B21
|
||||
test_container(set<test_type, compare_type, n_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B18
|
||||
#ifdef TEST_B22
|
||||
test_container(set<test_type, compare_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B19
|
||||
#ifdef TEST_B23
|
||||
test_container(set<test_type, compare_type, bit_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_B24
|
||||
test_container(set<test_type, compare_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
#ifdef TEST_T0
|
||||
test_container(vector<test_type, m_alloc_type>(), true);
|
||||
@ -227,59 +244,73 @@ int main(void)
|
||||
#ifdef TEST_T3
|
||||
test_container(vector<test_type, bit_alloc_type>(), true);
|
||||
#endif
|
||||
|
||||
#ifdef TEST_T4
|
||||
test_container(vector<test_type, po_alloc_type>(), true);
|
||||
#endif
|
||||
|
||||
#ifdef TEST_T5
|
||||
test_container(list<test_type, m_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T5
|
||||
#ifdef TEST_T6
|
||||
test_container(list<test_type, n_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T6
|
||||
#ifdef TEST_T7
|
||||
test_container(list<test_type, so_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T7
|
||||
#ifdef TEST_T8
|
||||
test_container(list<test_type, bit_alloc_type>(), true);
|
||||
#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);
|
||||
#endif
|
||||
#ifdef TEST_T9
|
||||
#ifdef TEST_T11
|
||||
test_container(deque<test_type, n_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T10
|
||||
#ifdef TEST_T12
|
||||
test_container(deque<test_type, so_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T11
|
||||
#ifdef TEST_T13
|
||||
test_container(deque<test_type, bit_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T14
|
||||
test_container(deque<test_type, po_alloc_type>(), true);
|
||||
#endif
|
||||
|
||||
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);
|
||||
#endif
|
||||
#ifdef TEST_T13
|
||||
#ifdef TEST_T16
|
||||
test_container(map<test_type, test_type, compare_type, n_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T14
|
||||
#ifdef TEST_T17
|
||||
test_container(map<test_type, test_type, compare_type, so_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T15
|
||||
#ifdef TEST_T18
|
||||
test_container(map<test_type, test_type, compare_type, bit_alloc_type>(), true);
|
||||
#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);
|
||||
#endif
|
||||
#ifdef TEST_T17
|
||||
#ifdef TEST_T21
|
||||
test_container(set<test_type, compare_type, n_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T18
|
||||
#ifdef TEST_T22
|
||||
test_container(set<test_type, compare_type, so_alloc_type>(), true);
|
||||
#endif
|
||||
#ifdef TEST_T19
|
||||
#ifdef TEST_T23
|
||||
test_container(set<test_type, compare_type, bit_alloc_type>(), true);
|
||||
#endif
|
||||
|
||||
#ifdef TEST_T24
|
||||
test_container(set<test_type, compare_type, po_alloc_type>(), true);
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -44,6 +44,7 @@
|
||||
#include <ext/new_allocator.h>
|
||||
#include <ext/malloc_allocator.h>
|
||||
#include <ext/bitmap_allocator.h>
|
||||
#include <ext/pool_allocator.h>
|
||||
#include <cxxabi.h>
|
||||
#include <testsuite_performance.h>
|
||||
|
||||
@ -119,6 +120,7 @@ int main(void)
|
||||
typedef __gnu_cxx::new_allocator<test_type> n_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::__pool_alloc<test_type> po_alloc_type;
|
||||
|
||||
#ifdef TEST_S0
|
||||
test_container(vector<test_type, m_alloc_type>());
|
||||
@ -132,62 +134,73 @@ int main(void)
|
||||
#ifdef TEST_S3
|
||||
test_container(vector<test_type, bit_alloc_type>());
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef TEST_S4
|
||||
test_container(vector<test_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
#ifdef TEST_S5
|
||||
test_container(list<test_type, m_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S5
|
||||
#ifdef TEST_S6
|
||||
test_container(list<test_type, n_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S6
|
||||
#ifdef TEST_S7
|
||||
test_container(list<test_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S7
|
||||
#ifdef TEST_S8
|
||||
test_container(list<test_type, bit_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S9
|
||||
test_container(list<test_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef TEST_S8
|
||||
#ifdef TEST_S10
|
||||
test_container(deque<test_type, m_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S9
|
||||
#ifdef TEST_S11
|
||||
test_container(deque<test_type, n_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S10
|
||||
#ifdef TEST_S12
|
||||
test_container(deque<test_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S11
|
||||
#ifdef TEST_S13
|
||||
test_container(deque<test_type, bit_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S14
|
||||
test_container(deque<test_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
typedef less<test_type> compare_type;
|
||||
#ifdef TEST_S12
|
||||
#ifdef TEST_S15
|
||||
test_container(map<test_type, test_type, compare_type, m_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S13
|
||||
#ifdef TEST_S16
|
||||
test_container(map<test_type, test_type, compare_type, n_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S14
|
||||
#ifdef TEST_S17
|
||||
test_container(map<test_type, test_type, compare_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S15
|
||||
#ifdef TEST_S18
|
||||
test_container(map<test_type, test_type, compare_type, bit_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S19
|
||||
test_container(map<test_type, test_type, compare_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef TEST_S12
|
||||
#ifdef TEST_S20
|
||||
test_container(set<test_type, compare_type, m_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S13
|
||||
#ifdef TEST_S21
|
||||
test_container(set<test_type, compare_type, n_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S14
|
||||
#ifdef TEST_S22
|
||||
test_container(set<test_type, compare_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_S14
|
||||
#ifdef TEST_S23
|
||||
test_container(set<test_type, compare_type, bit_alloc_type>());
|
||||
#endif
|
||||
|
||||
#ifdef TEST_S24
|
||||
test_container(set<test_type, compare_type, po_alloc_type>());
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -34,11 +34,13 @@
|
||||
#include <cxxabi.h>
|
||||
#include <testsuite_performance.h>
|
||||
#include <ext/bitmap_allocator.h>
|
||||
#include <ext/pool_allocator.h>
|
||||
|
||||
using namespace std;
|
||||
using __gnu_cxx::malloc_allocator;
|
||||
using __gnu_cxx::__mt_alloc;
|
||||
using __gnu_cxx::bitmap_allocator;
|
||||
using __gnu_cxx::__pool_alloc;
|
||||
|
||||
typedef int test_type;
|
||||
|
||||
@ -105,7 +107,6 @@ void do_test ()
|
||||
report_performance(__FILE__, string(), time, resource);
|
||||
}
|
||||
|
||||
|
||||
int main ()
|
||||
{
|
||||
#ifdef TEST_S0
|
||||
@ -120,6 +121,9 @@ int main ()
|
||||
#ifdef TEST_S3
|
||||
do_test<__mt_alloc<int> >();
|
||||
#endif
|
||||
#ifdef TEST_S4
|
||||
do_test<__pool_alloc<int> >();
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -40,11 +40,13 @@
|
||||
#include <cxxabi.h>
|
||||
#include <testsuite_performance.h>
|
||||
#include <ext/bitmap_allocator.h>
|
||||
#include <ext/pool_allocator.h>
|
||||
|
||||
using namespace std;
|
||||
using __gnu_cxx::malloc_allocator;
|
||||
using __gnu_cxx::__mt_alloc;
|
||||
using __gnu_cxx::bitmap_allocator;
|
||||
using __gnu_cxx::__pool_alloc;
|
||||
|
||||
typedef int test_type;
|
||||
|
||||
@ -145,4 +147,7 @@ int main()
|
||||
#ifdef TEST_T3
|
||||
exec_tests<__mt_alloc<int> >();
|
||||
#endif
|
||||
#ifdef TEST_T4
|
||||
exec_tests<__pool_alloc<int> >();
|
||||
#endif
|
||||
}
|
||||
|
||||
@ -41,6 +41,7 @@
|
||||
#include <ext/new_allocator.h>
|
||||
#include <ext/malloc_allocator.h>
|
||||
#include <ext/bitmap_allocator.h>
|
||||
#include <ext/pool_allocator.h>
|
||||
#include <cxxabi.h>
|
||||
#include <testsuite_performance.h>
|
||||
|
||||
@ -49,6 +50,7 @@ using __gnu_cxx::__mt_alloc;
|
||||
using __gnu_cxx::new_allocator;
|
||||
using __gnu_cxx::malloc_allocator;
|
||||
using __gnu_cxx::bitmap_allocator;
|
||||
using __gnu_cxx::__pool_alloc;
|
||||
|
||||
// The number of iterations to be performed.
|
||||
int iterations = 10000;
|
||||
@ -125,7 +127,8 @@ int main(void)
|
||||
#ifdef TEST_T5
|
||||
test_container(map<int, int, less<const int>, bitmap_allocator<int> >());
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef TEST_T6
|
||||
test_container(map<int, int, less<const int>, __pool_alloc<int> >());
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -42,6 +42,7 @@
|
||||
#include <ext/new_allocator.h>
|
||||
#include <ext/malloc_allocator.h>
|
||||
#include <ext/bitmap_allocator.h>
|
||||
#include <ext/pool_allocator.h>
|
||||
#include <cxxabi.h>
|
||||
#include <testsuite_performance.h>
|
||||
|
||||
@ -51,6 +52,7 @@ using __gnu_cxx::__mt_alloc;
|
||||
using __gnu_cxx::new_allocator;
|
||||
using __gnu_cxx::malloc_allocator;
|
||||
using __gnu_cxx::bitmap_allocator;
|
||||
using __gnu_cxx::__pool_alloc;
|
||||
using abi::__cxa_demangle;
|
||||
|
||||
typedef int test_type;
|
||||
@ -59,6 +61,7 @@ typedef malloc_allocator<test_type> malloc_alloc_type;
|
||||
typedef new_allocator<test_type> new_alloc_type;
|
||||
typedef __mt_alloc<test_type> so_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.
|
||||
int iterations = 10000;
|
||||
@ -298,35 +301,41 @@ int main(void)
|
||||
#ifdef TEST_T4
|
||||
test_container(vector<test_type, bit_alloc_type>());
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef TEST_T5
|
||||
test_container(vector<test_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
#ifdef TEST_T6
|
||||
test_container(list<test_type, malloc_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_T6
|
||||
#ifdef TEST_T7
|
||||
test_container(list<test_type, new_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_T7
|
||||
#ifdef TEST_T8
|
||||
test_container(list<test_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_T8
|
||||
#ifdef TEST_T9
|
||||
test_container(list<test_type, bit_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_T10
|
||||
test_container(list<test_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef TEST_T9
|
||||
#ifdef TEST_T11
|
||||
test_container(map<test_type, test_type, compare_type, malloc_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_T10
|
||||
#ifdef TEST_T12
|
||||
test_container(map<test_type, test_type, compare_type, new_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_T11
|
||||
#ifdef TEST_T13
|
||||
test_container(map<test_type, test_type, compare_type, so_alloc_type>());
|
||||
#endif
|
||||
#ifdef TEST_T12
|
||||
#ifdef TEST_T14
|
||||
test_container(map<test_type, test_type, compare_type, bit_alloc_type>());
|
||||
#endif
|
||||
|
||||
#ifdef TEST_T15
|
||||
test_container(map<test_type, test_type, compare_type, po_alloc_type>());
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user