Subversion Repositories openrisc

// -*- 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