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