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:
~RecyclingAllocator()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>
Allocate()43 SubClass *Allocate() { return Base.template Allocate<SubClass>(Allocator); }
44
Allocate()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>
Deallocate(SubClass * E)51 void Deallocate(SubClass* E) { return Base.Deallocate(Allocator, E); }
52
PrintStats()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>
new(size_t size,llvm::RecyclingAllocator<AllocatorType,T,Size,Align> & Allocator)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>
delete(void * E,llvm::RecyclingAllocator<AllocatorType,T,Size,Align> & A)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