Home | History | Annotate | Line # | Download | only in Support 
      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