include/llvm/Support/RecyclingAllocator.h

   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