Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //==- llvm/Support/RecyclingAllocator.h - Recycling Allocator ----*- C++ -*-==//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // This file defines the RecyclingAllocator class.  See the doxygen comment for
  10. // RecyclingAllocator for more details on the implementation.
  11. //
  12. //===----------------------------------------------------------------------===//
  13.  
  14. #ifndef LLVM_SUPPORT_RECYCLINGALLOCATOR_H
  15. #define LLVM_SUPPORT_RECYCLINGALLOCATOR_H
  16.  
  17. #include "llvm/Support/Recycler.h"
  18.  
  19. namespace llvm {
  20.  
  21. /// RecyclingAllocator - This class wraps an Allocator, adding the
  22. /// functionality of recycling deleted objects.
  23. ///
  24. template <class AllocatorType, class T, size_t Size = sizeof(T),
  25.           size_t Align = alignof(T)>
  26. class RecyclingAllocator {
  27. private:
  28.   /// Base - Implementation details.
  29.   ///
  30.   Recycler<T, Size, Align> Base;
  31.  
  32.   /// Allocator - The wrapped allocator.
  33.   ///
  34.   AllocatorType Allocator;
  35.  
  36. public:
  37.   ~RecyclingAllocator() { Base.clear(Allocator); }
  38.  
  39.   /// Allocate - Return a pointer to storage for an object of type
  40.   /// SubClass. The storage may be either newly allocated or recycled.
  41.   ///
  42.   template<class SubClass>
  43.   SubClass *Allocate() { return Base.template Allocate<SubClass>(Allocator); }
  44.  
  45.   T *Allocate() { return Base.Allocate(Allocator); }
  46.  
  47.   /// Deallocate - Release storage for the pointed-to object. The
  48.   /// storage will be kept track of and may be recycled.
  49.   ///
  50.   template<class SubClass>
  51.   void Deallocate(SubClass* E) { return Base.Deallocate(Allocator, E); }
  52.  
  53.   void PrintStats() {
  54.     Allocator.PrintStats();
  55.     Base.PrintStats();
  56.   }
  57. };
  58.  
  59. }
  60.  
  61. template<class AllocatorType, class T, size_t Size, size_t Align>
  62. inline void *operator new(size_t size,
  63.                           llvm::RecyclingAllocator<AllocatorType,
  64.                                                    T, Size, Align> &Allocator) {
  65.   assert(size <= Size && "allocation size exceeded");
  66.   return Allocator.Allocate();
  67. }
  68.  
  69. template<class AllocatorType, class T, size_t Size, size_t Align>
  70. inline void operator delete(void *E,
  71.                             llvm::RecyclingAllocator<AllocatorType,
  72.                                                      T, Size, Align> &A) {
  73.   A.Deallocate(E);
  74. }
  75.  
  76. #endif
  77.