libstdc++-v3/testsuite/util/testsuite_allocator.h

   1 // -*- C++ -*-
   2 // Testing allocator for the C++ library testsuite.
   3 //
   4 // Copyright (C) 2002-2013 Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11 //
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License along
  18 // with this library; see the file COPYING3.  If not see
  19 // <http://www.gnu.org/licenses/>.
  20 //
  21
  22 // This file provides an test instrumentation allocator that can be
  23 // used to verify allocation functionality of standard library
  24 // containers.  2002.11.25 smw
  25
  26 #ifndef _GLIBCXX_TESTSUITE_ALLOCATOR_H
  27 #define _GLIBCXX_TESTSUITE_ALLOCATOR_H
  28
  29 #include <tr1/unordered_map>
  30 #include <bits/move.h>
  31 #include <ext/pointer.h>
  32 #include <testsuite_hooks.h>
  33
  34 namespace __gnu_test
  35 {
  36   class tracker_allocator_counter
  37   {
  38   public:
  39     typedef std::size_t    size_type;
  40
  41     static void*
  42     allocate(size_type blocksize)
  43     {
  44       void* p = ::operator new(blocksize);
  45       allocationCount_ += blocksize;
  46       return p;
  47     }
  48
  49     static void
  50     construct() { constructCount_++; }
  51
  52     static void
  53     destroy() { destructCount_++; }
  54
  55     static void
  56     deallocate(void* p, size_type blocksize)
  57     {
  58       ::operator delete(p);
  59       deallocationCount_ += blocksize;
  60     }
  61
  62     static size_type
  63     get_allocation_count() { return allocationCount_; }
  64
  65     static size_type
  66     get_deallocation_count() { return deallocationCount_; }
  67
  68     static int
  69     get_construct_count() { return constructCount_; }
  70
  71     static int
  72     get_destruct_count() { return destructCount_; }
  73
  74     static void
  75     reset()
  76     {
  77       allocationCount_ = 0;
  78       deallocationCount_ = 0;
  79       constructCount_ = 0;
  80       destructCount_ = 0;
  81     }
  82
  83  private:
  84     static size_type  allocationCount_;
  85     static size_type  deallocationCount_;
  86     static int        constructCount_;
  87     static int        destructCount_;
  88   };
  89
  90   // A simple basic allocator that just forwards to the
  91   // tracker_allocator_counter to fulfill memory requests.  This class
  92   // is templated on the target object type, but tracker isn't.
  93   template<class T>
  94   class tracker_allocator
  95   {
  96   private:
  97     typedef tracker_allocator_counter counter_type;
  98
  99   public:
 100     typedef T              value_type;
 101     typedef T*             pointer;
 102     typedef const T*       const_pointer;
 103     typedef T&             reference;
 104     typedef const T&       const_reference;
 105     typedef std::size_t    size_type;
 106     typedef std::ptrdiff_t difference_type;
 107
 108     template<class U> struct rebind { typedef tracker_allocator<U> other; };
 109
 110     pointer
 111     address(reference value) const _GLIBCXX_NOEXCEPT
 112     { return std::__addressof(value); }
 113
 114     const_pointer
 115     address(const_reference value) const _GLIBCXX_NOEXCEPT
 116     { return std::__addressof(value); }
 117
 118     tracker_allocator() _GLIBCXX_USE_NOEXCEPT
 119     { }
 120
 121     tracker_allocator(const tracker_allocator&) _GLIBCXX_USE_NOEXCEPT
 122     { }
 123
 124     template<class U>
 125       tracker_allocator(const tracker_allocator<U>&) _GLIBCXX_USE_NOEXCEPT
 126       { }
 127
 128     ~tracker_allocator() _GLIBCXX_USE_NOEXCEPT
 129     { }
 130
 131     size_type
 132     max_size() const _GLIBCXX_USE_NOEXCEPT
 133     { return size_type(-1) / sizeof(T); }
 134
 135     pointer
 136     allocate(size_type n, const void* = 0)
 137     { return static_cast<pointer>(counter_type::allocate(n * sizeof(T))); }
 138
 139 #if __cplusplus >= 201103L
 140     template<typename U, typename... Args>
 141       void
 142       construct(U* p, Args&&... args)
 143       {
 144         ::new((void *)p) U(std::forward<Args>(args)...);
 145         counter_type::construct();
 146       }
 147
 148     template<typename U>
 149       void
 150       destroy(U* p)
 151       {
 152         p->~U();
 153         counter_type::destroy();
 154       }
 155 #else
 156     void
 157     construct(pointer p, const T& value)
 158     {
 159       ::new ((void *)p) T(value);
 160       counter_type::construct();
 161     }
 162
 163     void
 164     destroy(pointer p)
 165     {
 166       p->~T();
 167       counter_type::destroy();
 168     }
 169 #endif
 170
 171     void
 172     deallocate(pointer p, size_type num)
 173     { counter_type::deallocate(p, num * sizeof(T)); }
 174   };
 175
 176   template<class T1, class T2>
 177     bool
 178     operator==(const tracker_allocator<T1>&,
 179                const tracker_allocator<T2>&) throw()
 180     { return true; }
 181
 182   template<class T1, class T2>
 183     bool
 184     operator!=(const tracker_allocator<T1>&,
 185                const tracker_allocator<T2>&) throw()
 186     { return false; }
 187
 188   bool
 189   check_construct_destroy(const char* tag, int expected_c, int expected_d);
 190
 191   template<typename Alloc>
 192     bool
 193     check_deallocate_null()
 194     {
 195       // Let's not core here...
 196       Alloc  a;
 197       a.deallocate(0, 1);
 198       a.deallocate(0, 10);
 199       return true;
 200     }
 201
 202   template<typename Alloc>
 203     bool
 204     check_allocate_max_size()
 205     {
 206       Alloc a;
 207       try
 208         {
 209           a.allocate(a.max_size() + 1);
 210         }
 211       catch(std::bad_alloc&)
 212         {
 213           return true;
 214         }
 215       catch(...)
 216         {
 217           throw;
 218         }
 219       throw;
 220     }
 221
 222
 223   // A simple allocator which can be constructed endowed of a given
 224   // "personality" (an integer), queried in operator== to simulate the
 225   // behavior of realworld "unequal" allocators (i.e., not exploiting
 226   // the provision in 20.1.5/4, first bullet).  A global unordered_map,
 227   // filled at allocation time with (pointer, personality) pairs, is
 228   // then consulted to enforce the requirements in Table 32 about
 229   // deallocation vs allocator equality.  Note that this allocator is
 230   // swappable, not assignable, consistently with Option 3 of DR 431
 231   // (see N1599).
 232   struct uneq_allocator_base
 233   {
 234     typedef std::tr1::unordered_map<void*, int>   map_type;
 235
 236     // Avoid static initialization troubles and/or bad interactions
 237     // with tests linking testsuite_allocator.o and playing globally
 238     // with operator new/delete.
 239     static map_type&
 240     get_map()
 241     {
 242       static map_type alloc_map;
 243       return alloc_map;
 244     }
 245   };
 246
 247   template<typename Tp>
 248     class uneq_allocator
 249     : private uneq_allocator_base
 250     {
 251     public:
 252       typedef std::size_t                         size_type;
 253       typedef std::ptrdiff_t                      difference_type;
 254       typedef Tp*                                 pointer;
 255       typedef const Tp*                           const_pointer;
 256       typedef Tp&                                 reference;
 257       typedef const Tp&                           const_reference;
 258       typedef Tp                                  value_type;
 259
 260 #if __cplusplus >= 201103L
 261       typedef std::true_type                      propagate_on_container_swap;
 262 #endif
 263
 264       template<typename Tp1>
 265         struct rebind
 266         { typedef uneq_allocator<Tp1> other; };
 267
 268       uneq_allocator() _GLIBCXX_USE_NOEXCEPT
 269       : personality(0) { }
 270
 271       uneq_allocator(int person) _GLIBCXX_USE_NOEXCEPT
 272       : personality(person) { }
 273
 274       template<typename Tp1>
 275         uneq_allocator(const uneq_allocator<Tp1>& b) _GLIBCXX_USE_NOEXCEPT
 276         : personality(b.get_personality()) { }
 277
 278       ~uneq_allocator() _GLIBCXX_USE_NOEXCEPT
 279       { }
 280
 281       int get_personality() const { return personality; }
 282
 283       pointer
 284       address(reference x) const _GLIBCXX_NOEXCEPT
 285       { return std::__addressof(x); }
 286
 287       const_pointer
 288       address(const_reference x) const _GLIBCXX_NOEXCEPT
 289       { return std::__addressof(x); }
 290
 291       pointer
 292       allocate(size_type n, const void* = 0)
 293       {
 294         if (__builtin_expect(n > this->max_size(), false))
 295           std::__throw_bad_alloc();
 296
 297         pointer p = static_cast<Tp*>(::operator new(n * sizeof(Tp)));
 298         try
 299           {
 300             get_map().insert(map_type::value_type(reinterpret_cast<void*>(p),
 301                                                   personality));
 302           }
 303         catch(...)
 304           {
 305             ::operator delete(p);
 306             __throw_exception_again;
 307           }
 308         return p;
 309       }
 310
 311       void
 312       deallocate(pointer p, size_type)
 313       {
 314         bool test __attribute__((unused)) = true;
 315
 316         VERIFY( p );
 317
 318         map_type::iterator it = get_map().find(reinterpret_cast<void*>(p));
 319         VERIFY( it != get_map().end() );
 320
 321         // Enforce requirements in Table 32 about deallocation vs
 322         // allocator equality.
 323         VERIFY( it->second == personality );
 324
 325         get_map().erase(it);
 326         ::operator delete(p);
 327       }
 328
 329       size_type
 330       max_size() const _GLIBCXX_USE_NOEXCEPT
 331       { return size_type(-1) / sizeof(Tp); }
 332
 333 #if __cplusplus >= 201103L
 334       template<typename U, typename... Args>
 335         void
 336         construct(U* p, Args&&... args)
 337         { ::new((void *)p) U(std::forward<Args>(args)...); }
 338
 339       template<typename U>
 340         void
 341         destroy(U* p) { p->~U(); }
 342
 343       // Not copy assignable...
 344       uneq_allocator&
 345       operator=(const uneq_allocator&) = delete;
 346 #else
 347       void
 348       construct(pointer p, const Tp& val)
 349       { ::new((void *)p) Tp(val); }
 350
 351       void
 352       destroy(pointer p) { p->~Tp(); }
 353
 354     private:
 355       // Not assignable...
 356       uneq_allocator&
 357       operator=(const uneq_allocator&);
 358 #endif
 359
 360     private:
 361
 362       // ... yet swappable!
 363       friend inline void
 364       swap(uneq_allocator& a, uneq_allocator& b)
 365       { std::swap(a.personality, b.personality); }
 366
 367       template<typename Tp1>
 368         friend inline bool
 369         operator==(const uneq_allocator& a, const uneq_allocator<Tp1>& b)
 370         { return a.personality == b.personality; }
 371
 372       template<typename Tp1>
 373         friend inline bool
 374         operator!=(const uneq_allocator& a, const uneq_allocator<Tp1>& b)
 375         { return !(a == b); }
 376
 377       int personality;
 378     };
 379
 380 #if __cplusplus >= 201103L
 381   // An uneq_allocator which can be used to test allocator propagation.
 382   template<typename Tp, bool Propagate>
 383     class propagating_allocator : public uneq_allocator<Tp>
 384     {
 385       typedef uneq_allocator<Tp> base_alloc;
 386       base_alloc& base() { return *this; }
 387       const base_alloc& base() const  { return *this; }
 388       void swap_base(base_alloc& b) { swap(b, this->base()); }
 389
 390       typedef std::integral_constant<bool, Propagate> trait_type;
 391
 392     public:
 393       // default allocator_traits::rebind_alloc would select
 394       // uneq_allocator::rebind so we must define rebind here
 395       template<typename Up>
 396         struct rebind { typedef propagating_allocator<Up, Propagate> other; };
 397
 398       propagating_allocator(int i) noexcept
 399       : base_alloc(i)
 400       { }
 401
 402       template<typename Up>
 403         propagating_allocator(const propagating_allocator<Up, Propagate>& a)
 404         noexcept
 405         : base_alloc(a)
 406         { }
 407
 408       propagating_allocator() noexcept = default;
 409
 410       propagating_allocator(const propagating_allocator&) noexcept = default;
 411
 412       propagating_allocator&
 413       operator=(const propagating_allocator& a) noexcept
 414         {
 415           static_assert(Propagate, "assigning propagating_allocator<T, true>");
 416           propagating_allocator(a).swap_base(*this);
 417           return *this;
 418         }
 419
 420       template<bool P2>
 421         propagating_allocator&
 422         operator=(const propagating_allocator<Tp, P2>& a) noexcept
 423         {
 424           static_assert(P2, "assigning propagating_allocator<T, true>");
 425           propagating_allocator(a).swap_base(*this);
 426           return *this;
 427         }
 428
 429       // postcondition: a.get_personality() == 0
 430       propagating_allocator(propagating_allocator&& a) noexcept
 431       : base_alloc()
 432       { swap_base(a); }
 433
 434       // postcondition: a.get_personality() == 0
 435       propagating_allocator&
 436       operator=(propagating_allocator&& a) noexcept
 437       {
 438         propagating_allocator(std::move(a)).swap_base(*this);
 439         return *this;
 440       }
 441
 442       typedef trait_type propagate_on_container_copy_assignment;
 443       typedef trait_type propagate_on_container_move_assignment;
 444       typedef trait_type propagate_on_container_swap;
 445
 446       propagating_allocator select_on_container_copy_construction() const
 447       { return Propagate ? *this : propagating_allocator(); }
 448     };
 449
 450   // Class template supporting the minimal interface that satisfies the
 451   // Allocator requirements, from example in [allocator.requirements]
 452   template <class Tp>
 453     struct SimpleAllocator
 454     {
 455       typedef Tp value_type;
 456
 457       SimpleAllocator() { }
 458
 459       template <class T>
 460         SimpleAllocator(const SimpleAllocator<T>& other) { }
 461
 462       Tp *allocate(std::size_t n)
 463       { return std::allocator<Tp>().allocate(n); }
 464
 465       void deallocate(Tp *p, std::size_t n)
 466       { std::allocator<Tp>().deallocate(p, n); }
 467     };
 468
 469   template <class T, class U>
 470     bool operator==(const SimpleAllocator<T>&, const SimpleAllocator<U>&)
 471     { return true; }
 472   template <class T, class U>
 473     bool operator!=(const SimpleAllocator<T>&, const SimpleAllocator<U>&)
 474     { return false; }
 475
 476 #endif
 477
 478   template<typename Tp>
 479     struct ExplicitConsAlloc : std::allocator<Tp>
 480     {
 481       ExplicitConsAlloc() { }
 482
 483       template<typename Up>
 484         explicit
 485         ExplicitConsAlloc(const ExplicitConsAlloc<Up>&) { }
 486
 487       template<typename Up>
 488         struct rebind
 489         { typedef ExplicitConsAlloc<Up> other; };
 490     };
 491
 492 #if __cplusplus >= 201103L
 493   template<typename Tp>
 494     class CustomPointerAlloc : public std::allocator<Tp>
 495     {
 496       template<typename Up, typename Sp = __gnu_cxx::_Std_pointer_impl<Up>>
 497         using Ptr =  __gnu_cxx::_Pointer_adapter<Sp>;
 498
 499     public:
 500       CustomPointerAlloc() = default;
 501
 502       template<typename Up>
 503         CustomPointerAlloc(const CustomPointerAlloc<Up>&) { }
 504
 505       template<typename Up>
 506         struct rebind
 507         { typedef CustomPointerAlloc<Up> other; };
 508
 509       typedef Ptr<Tp>           pointer;
 510       typedef Ptr<const Tp>     const_pointer;
 511       typedef Ptr<void>         void_pointer;
 512       typedef Ptr<const void>   const_void_pointer;
 513
 514       pointer allocate(std::size_t n, pointer = {})
 515       { return pointer(std::allocator<Tp>::allocate(n)); }
 516
 517       void deallocate(pointer p, std::size_t n)
 518       { std::allocator<Tp>::deallocate(std::addressof(*p), n); }
 519     };
 520 #endif
 521
 522 } // namespace __gnu_test
 523
 524 #endif // _GLIBCXX_TESTSUITE_ALLOCATOR_H