URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [testsuite/] [util/] [testsuite_allocator.h] - Rev 830
Go to most recent revision | Compare with Previous | Blame | View Log
// -*- C++ -*- // Testing allocator for the C++ library testsuite. // // Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 // 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 3, 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 COPYING3. If not see // <http://www.gnu.org/licenses/>. // // This file provides an test instrumentation allocator that can be // used to verify allocation functionality of standard library // containers. 2002.11.25 smw #ifndef _GLIBCXX_TESTSUITE_ALLOCATOR_H #define _GLIBCXX_TESTSUITE_ALLOCATOR_H #include <tr1/unordered_map> #include <bits/move.h> #include <testsuite_hooks.h> namespace __gnu_test { class tracker_allocator_counter { public: typedef std::size_t size_type; static void* allocate(size_type blocksize) { void* p = ::operator new(blocksize); allocationCount_ += blocksize; return p; } static void construct() { constructCount_++; } static void destroy() { destructCount_++; } static void deallocate(void* p, size_type blocksize) { ::operator delete(p); deallocationCount_ += blocksize; } static size_type get_allocation_count() { return allocationCount_; } static size_type get_deallocation_count() { return deallocationCount_; } static int get_construct_count() { return constructCount_; } static int get_destruct_count() { return destructCount_; } static void reset() { allocationCount_ = 0; deallocationCount_ = 0; constructCount_ = 0; destructCount_ = 0; } private: static size_type allocationCount_; static size_type deallocationCount_; static int constructCount_; static int destructCount_; }; // A simple basic allocator that just forwards to the // tracker_allocator_counter to fulfill memory requests. This class // is templated on the target object type, but tracker isn't. template<class T> class tracker_allocator { private: typedef tracker_allocator_counter counter_type; public: typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef T& reference; typedef const T& const_reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; template<class U> struct rebind { typedef tracker_allocator<U> other; }; pointer address(reference value) const _GLIBCXX_NOEXCEPT { return std::__addressof(value); } const_pointer address(const_reference value) const _GLIBCXX_NOEXCEPT { return std::__addressof(value); } tracker_allocator() _GLIBCXX_USE_NOEXCEPT { } tracker_allocator(const tracker_allocator&) _GLIBCXX_USE_NOEXCEPT { } template<class U> tracker_allocator(const tracker_allocator<U>&) _GLIBCXX_USE_NOEXCEPT { } ~tracker_allocator() _GLIBCXX_USE_NOEXCEPT { } size_type max_size() const _GLIBCXX_USE_NOEXCEPT { return size_type(-1) / sizeof(T); } pointer allocate(size_type n, const void* = 0) { return static_cast<pointer>(counter_type::allocate(n * sizeof(T))); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ template<typename U, typename... Args> void construct(U* p, Args&&... args) { ::new((void *)p) U(std::forward<Args>(args)...); counter_type::construct(); } template<typename U> void destroy(U* p) { p->~U(); counter_type::destroy(); } #else void construct(pointer p, const T& value) { ::new ((void *)p) T(value); counter_type::construct(); } void destroy(pointer p) { p->~T(); counter_type::destroy(); } #endif void deallocate(pointer p, size_type num) { counter_type::deallocate(p, num * sizeof(T)); } }; template<class T1, class T2> bool operator==(const tracker_allocator<T1>&, const tracker_allocator<T2>&) throw() { return true; } template<class T1, class T2> bool operator!=(const tracker_allocator<T1>&, const tracker_allocator<T2>&) throw() { return false; } bool check_construct_destroy(const char* tag, int expected_c, int expected_d); template<typename Alloc> bool check_deallocate_null() { // Let's not core here... Alloc a; a.deallocate(0, 1); a.deallocate(0, 10); return true; } template<typename Alloc> bool check_allocate_max_size() { Alloc a; try { a.allocate(a.max_size() + 1); } catch(std::bad_alloc&) { return true; } catch(...) { throw; } throw; } // A simple allocator which can be constructed endowed of a given // "personality" (an integer), queried in operator== to simulate the // behavior of realworld "unequal" allocators (i.e., not exploiting // the provision in 20.1.5/4, first bullet). A global unordered_map, // filled at allocation time with (pointer, personality) pairs, is // then consulted to enforce the requirements in Table 32 about // deallocation vs allocator equality. Note that this allocator is // swappable, not assignable, consistently with Option 3 of DR 431 // (see N1599). struct uneq_allocator_base { typedef std::tr1::unordered_map<void*, int> map_type; // Avoid static initialization troubles and/or bad interactions // with tests linking testsuite_allocator.o and playing globally // with operator new/delete. static map_type& get_map() { static map_type alloc_map; return alloc_map; } }; template<typename Tp> class uneq_allocator : private uneq_allocator_base { public: typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef Tp* pointer; typedef const Tp* const_pointer; typedef Tp& reference; typedef const Tp& const_reference; typedef Tp value_type; #ifdef __GXX_EXPERIMENTAL_CXX0X__ typedef std::true_type propagate_on_container_swap; #endif template<typename Tp1> struct rebind { typedef uneq_allocator<Tp1> other; }; uneq_allocator() _GLIBCXX_USE_NOEXCEPT : personality(0) { } uneq_allocator(int person) _GLIBCXX_USE_NOEXCEPT : personality(person) { } template<typename Tp1> uneq_allocator(const uneq_allocator<Tp1>& b) _GLIBCXX_USE_NOEXCEPT : personality(b.get_personality()) { } ~uneq_allocator() _GLIBCXX_USE_NOEXCEPT { } int get_personality() const { return personality; } pointer address(reference x) const _GLIBCXX_NOEXCEPT { return std::__addressof(x); } const_pointer address(const_reference x) const _GLIBCXX_NOEXCEPT { return std::__addressof(x); } pointer allocate(size_type n, const void* = 0) { if (__builtin_expect(n > this->max_size(), false)) std::__throw_bad_alloc(); pointer p = static_cast<Tp*>(::operator new(n * sizeof(Tp))); try { get_map().insert(map_type::value_type(reinterpret_cast<void*>(p), personality)); } catch(...) { ::operator delete(p); __throw_exception_again; } return p; } void deallocate(pointer p, size_type) { bool test __attribute__((unused)) = true; VERIFY( p ); map_type::iterator it = get_map().find(reinterpret_cast<void*>(p)); VERIFY( it != get_map().end() ); // Enforce requirements in Table 32 about deallocation vs // allocator equality. VERIFY( it->second == personality ); get_map().erase(it); ::operator delete(p); } size_type max_size() const _GLIBCXX_USE_NOEXCEPT { return size_type(-1) / sizeof(Tp); } #ifdef __GXX_EXPERIMENTAL_CXX0X__ template<typename U, typename... Args> void construct(U* p, Args&&... args) { ::new((void *)p) U(std::forward<Args>(args)...); } template<typename U> void destroy(U* p) { p->~U(); } // Not copy assignable... uneq_allocator& operator=(const uneq_allocator&) = delete; #else void construct(pointer p, const Tp& val) { ::new((void *)p) Tp(val); } void destroy(pointer p) { p->~Tp(); } private: // Not assignable... uneq_allocator& operator=(const uneq_allocator&); #endif private: // ... yet swappable! friend inline void swap(uneq_allocator& a, uneq_allocator& b) { std::swap(a.personality, b.personality); } template<typename Tp1> friend inline bool operator==(const uneq_allocator& a, const uneq_allocator<Tp1>& b) { return a.personality == b.personality; } template<typename Tp1> friend inline bool operator!=(const uneq_allocator& a, const uneq_allocator<Tp1>& b) { return !(a == b); } int personality; }; #ifdef __GXX_EXPERIMENTAL_CXX0X__ // An uneq_allocator which can be used to test allocator propagation. template<typename Tp, bool Propagate> class propagating_allocator : public uneq_allocator<Tp> { typedef uneq_allocator<Tp> base_alloc; base_alloc& base() { return *this; } const base_alloc& base() const { return *this; } void swap_base(base_alloc& b) { swap(b, this->base()); } typedef std::integral_constant<bool, Propagate> trait_type; public: // default allocator_traits::rebind_alloc would select // uneq_allocator::rebind so we must define rebind here template<typename Up> struct rebind { typedef propagating_allocator<Up, Propagate> other; }; propagating_allocator(int i) noexcept : base_alloc(i) { } template<typename Up> propagating_allocator(const propagating_allocator<Up, Propagate>& a) noexcept : base_alloc(a) { } propagating_allocator() noexcept = default; propagating_allocator(const propagating_allocator&) noexcept = default; propagating_allocator& operator=(const propagating_allocator& a) noexcept { static_assert(Propagate, "assigning propagating_allocator<T, true>"); propagating_allocator(a).swap_base(*this); return *this; } template<bool P2> propagating_allocator& operator=(const propagating_allocator<Tp, P2>& a) noexcept { static_assert(P2, "assigning propagating_allocator<T, true>"); propagating_allocator(a).swap_base(*this); return *this; } // postcondition: a.get_personality() == 0 propagating_allocator(propagating_allocator&& a) noexcept : base_alloc() { swap_base(a); } // postcondition: a.get_personality() == 0 propagating_allocator& operator=(propagating_allocator&& a) noexcept { propagating_allocator(std::move(a)).swap_base(*this); return *this; } typedef trait_type propagate_on_container_copy_assignment; typedef trait_type propagate_on_container_move_assignment; typedef trait_type propagate_on_container_swap; propagating_allocator select_on_container_copy_construction() const { return Propagate ? *this : propagating_allocator(); } }; // Class template supporting the minimal interface that satisfies the // Allocator requirements, from example in [allocator.requirements] template <class Tp> struct SimpleAllocator { typedef Tp value_type; SimpleAllocator() { } template <class T> SimpleAllocator(const SimpleAllocator<T>& other) { } Tp *allocate(std::size_t n) { return std::allocator<Tp>().allocate(n); } void deallocate(Tp *p, std::size_t n) { std::allocator<Tp>().deallocate(p, n); } }; template <class T, class U> bool operator==(const SimpleAllocator<T>&, const SimpleAllocator<U>&) { return true; } template <class T, class U> bool operator!=(const SimpleAllocator<T>&, const SimpleAllocator<U>&) { return false; } #endif template<typename Tp> struct ExplicitConsAlloc : std::allocator<Tp> { ExplicitConsAlloc() { } template<typename Up> explicit ExplicitConsAlloc(const ExplicitConsAlloc<Up>&) { } template<typename Up> struct rebind { typedef ExplicitConsAlloc<Up> other; }; }; } // namespace __gnu_test #endif // _GLIBCXX_TESTSUITE_ALLOCATOR_H
Go to most recent revision | Compare with Previous | Blame | View Log