LLVM: include/llvm/ADT/PagedVector.h Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12#ifndef LLVM_ADT_PAGEDVECTOR_H
13#define LLVM_ADT_PAGEDVECTOR_H
14
19#include
20#include
21
22namespace llvm {
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
43 static_assert(PageSize > 1, "PageSize must be greater than 0. Most likely "
44 "you want it to be greater than 16.");
45
46 size_t Size = 0;
47
48
49
51
52
53
55
56public:
58
59
60
63 assert(A && "Allocator cannot be nullptr");
64 }
65
68
69 if (Allocator.getInt())
70 delete Allocator.getPointer();
71 }
72
73
78
79
80
81
85 T *&PagePtr = PageToDataPtrs[Index / PageSize];
86
88 PagePtr = Allocator.getPointer()->template Allocate(PageSize);
89
90
91 std::uninitialized_value_construct_n(PagePtr, PageSize);
92 }
93
94 return PagePtr[Index % PageSize];
95 }
96
97
98
99 [[nodiscard]] size_t capacity() const {
100 return PageToDataPtrs.size() * PageSize;
101 }
102
103
104 [[nodiscard]] size_t size() const { return Size; }
105
106
107
108
109
110
111
112
113
114
115
117 if (NewSize == 0) {
119 return;
120 }
121
122
123
124
125
126
127
128
129
130 size_t NewLastPage = (NewSize - 1) / PageSize;
131 if (NewSize < Size) {
132 for (size_t I = NewLastPage + 1, N = PageToDataPtrs.size(); I < N; ++I) {
133 T *Page = PageToDataPtrs[I];
134 if (!Page)
135 continue;
136
137 std::destroy_n(Page, PageSize);
138 Allocator.getPointer()->Deallocate(Page);
139 }
140 }
141
142 Size = NewSize;
143 PageToDataPtrs.resize(NewLastPage + 1);
144 }
145
146 [[nodiscard]] bool empty() const { return Size == 0; }
147
148
149
151 Size = 0;
152 for (T *Page : PageToDataPtrs) {
153 if (Page == nullptr)
154 continue;
155 std::destroy_n(Page, PageSize);
156
157 if (!Allocator.getInt())
158 Allocator.getPointer()->Deallocate(Page);
159 }
160
161 if (Allocator.getInt())
162 Allocator.getPointer()->Reset();
163 PageToDataPtrs.clear();
164 }
165
166
167
170 size_t ElementIdx;
171
172 public:
178
180 : PV(PV), ElementIdx(ElementIdx) {}
181
182
183
184
185
187 ++ElementIdx;
188 if (ElementIdx % PageSize == 0) {
189 while (ElementIdx < PV->Size &&
190 !PV->PageToDataPtrs[ElementIdx / PageSize])
192 ElementIdx = std::min(ElementIdx, PV->Size);
193 }
194
195 return *this;
196 }
197
200 ++*this;
201 return Copy;
202 }
203
205 assert(ElementIdx < PV->Size);
207 T *PagePtr = PV->PageToDataPtrs[ElementIdx / PageSize];
208 return PagePtr[ElementIdx % PageSize];
209 }
210
211
215 }
216
217 [[nodiscard]] size_t getIndex() const { return ElementIdx; }
218
222 }
223
224 private:
225 void verify() const {
227 ElementIdx == PV->Size ||
228 (ElementIdx < PV->Size && PV->PageToDataPtrs[ElementIdx / PageSize]));
229 }
230
231 bool equals(const MaterializedIterator &Other) const {
235 return ElementIdx == Other.ElementIdx;
236 }
237 };
238
239
240
241
242
243
245
246 for (size_t ElementIdx = 0; ElementIdx < Size; ElementIdx += PageSize)
247 if (PageToDataPtrs[ElementIdx / PageSize])
249
251 }
252
256
261};
262}
263#endif
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file defines the BumpPtrAllocator interface.
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_UNLIKELY(EXPR)
static cl::opt< int > PageSize("imp-null-check-page-size", cl::desc("The page size of the target in bytes"), cl::init(4096), cl::Hidden)
This file defines the PointerIntPair class.
This file defines the SmallVector class.
Iterator on all the elements of the vector which have actually being constructed.
Definition PagedVector.h:168
MaterializedIterator & operator++()
Pre-increment operator.
Definition PagedVector.h:186
std::ptrdiff_t difference_type
Definition PagedVector.h:175
T & reference
Definition PagedVector.h:177
T const & operator*() const
Definition PagedVector.h:204
size_t getIndex() const
Definition PagedVector.h:217
std::forward_iterator_tag iterator_category
Definition PagedVector.h:173
T * pointer
Definition PagedVector.h:176
T value_type
Definition PagedVector.h:174
friend bool operator!=(const MaterializedIterator &LHS, const MaterializedIterator &RHS)
Definition PagedVector.h:219
MaterializedIterator(PagedVector const *PV, size_t ElementIdx)
Definition PagedVector.h:179
MaterializedIterator operator++(int)
Definition PagedVector.h:198
friend bool operator==(const MaterializedIterator &LHS, const MaterializedIterator &RHS)
Equality operator.
Definition PagedVector.h:212
MaterializedIterator materialized_end() const
Definition PagedVector.h:253
PagedVector(BumpPtrAllocator *A)
Definition PagedVector.h:62
bool empty() const
Definition PagedVector.h:146
PagedVector & operator=(const PagedVector &)=delete
size_t size() const
Return the size of the vector.
Definition PagedVector.h:104
PagedVector & operator=(PagedVector &&)=delete
~PagedVector()
Definition PagedVector.h:66
T & operator[](size_t Index) const
Look up an element at position Index.
Definition PagedVector.h:82
MaterializedIterator materialized_begin() const
Iterators over the materialized elements of the vector.
Definition PagedVector.h:244
void resize(size_t NewSize)
Resize the vector.
Definition PagedVector.h:116
PagedVector(const PagedVector &)=delete
PagedVector()
Default constructor.
Definition PagedVector.h:61
T value_type
Definition PagedVector.h:57
PagedVector(PagedVector &&)=delete
llvm::iterator_range< MaterializedIterator > materialized() const
Definition PagedVector.h:258
size_t capacity() const
Return the capacity of the vector.
Definition PagedVector.h:99
void clear()
Clear the vector, i.e.
Definition PagedVector.h:150
PointerIntPair - This class implements a pair of a pointer and small integer.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
A range adaptor for a pair of iterators.
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
This is an optimization pass for GlobalISel generic memory operations.
BumpPtrAllocatorImpl<> BumpPtrAllocator
The standard BumpPtrAllocator which just uses the default template parameters.