Line data Source code
1 : // Copyright 2016 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #ifndef V8_HEAP_REMEMBERED_SET_H_
6 : #define V8_HEAP_REMEMBERED_SET_H_
7 :
8 : #include "src/heap/heap.h"
9 : #include "src/heap/slot-set.h"
10 : #include "src/heap/spaces.h"
11 : #include "src/reloc-info.h"
12 : #include "src/v8memory.h"
13 :
14 : namespace v8 {
15 : namespace internal {
16 :
17 : enum RememberedSetIterationMode { SYNCHRONIZED, NON_SYNCHRONIZED };
18 :
19 : // TODO(ulan): Investigate performance of de-templatizing this class.
20 : template <RememberedSetType type>
21 : class RememberedSet : public AllStatic {
22 : public:
23 : // Given a page and a slot in that page, this function adds the slot to the
24 : // remembered set.
25 : template <AccessMode access_mode = AccessMode::ATOMIC>
26 182720345 : static void Insert(MemoryChunk* chunk, Address slot_addr) {
27 : DCHECK(chunk->Contains(slot_addr));
28 : SlotSet* slot_set = chunk->slot_set<type, access_mode>();
29 182720345 : if (slot_set == nullptr) {
30 105249 : slot_set = chunk->AllocateSlotSet<type>();
31 : }
32 182720346 : uintptr_t offset = slot_addr - chunk->address();
33 182720346 : slot_set[offset / Page::kPageSize].Insert<access_mode>(offset %
34 : Page::kPageSize);
35 182796138 : }
36 :
37 : // Given a page and a slot in that page, this function returns true if
38 : // the remembered set contains the slot.
39 : static bool Contains(MemoryChunk* chunk, Address slot_addr) {
40 : DCHECK(chunk->Contains(slot_addr));
41 : SlotSet* slot_set = chunk->slot_set<type>();
42 : if (slot_set == nullptr) {
43 : return false;
44 : }
45 : uintptr_t offset = slot_addr - chunk->address();
46 : return slot_set[offset / Page::kPageSize].Contains(offset %
47 : Page::kPageSize);
48 : }
49 :
50 : // Given a page and a slot in that page, this function removes the slot from
51 : // the remembered set.
52 : // If the slot was never added, then the function does nothing.
53 701 : static void Remove(MemoryChunk* chunk, Address slot_addr) {
54 : DCHECK(chunk->Contains(slot_addr));
55 : SlotSet* slot_set = chunk->slot_set<type>();
56 701 : if (slot_set != nullptr) {
57 385 : uintptr_t offset = slot_addr - chunk->address();
58 385 : slot_set[offset / Page::kPageSize].Remove(offset % Page::kPageSize);
59 : }
60 701 : }
61 :
62 : // Given a page and a range of slots in that page, this function removes the
63 : // slots from the remembered set.
64 33997916 : static void RemoveRange(MemoryChunk* chunk, Address start, Address end,
65 : SlotSet::EmptyBucketMode mode) {
66 : SlotSet* slot_set = chunk->slot_set<type>();
67 33997916 : if (slot_set != nullptr) {
68 16546899 : uintptr_t start_offset = start - chunk->address();
69 16546899 : uintptr_t end_offset = end - chunk->address();
70 : DCHECK_LT(start_offset, end_offset);
71 16546899 : if (end_offset < static_cast<uintptr_t>(Page::kPageSize)) {
72 16327203 : slot_set->RemoveRange(static_cast<int>(start_offset),
73 : static_cast<int>(end_offset), mode);
74 : } else {
75 : // The large page has multiple slot sets.
76 : // Compute slot set indicies for the range [start_offset, end_offset).
77 219696 : int start_chunk = static_cast<int>(start_offset / Page::kPageSize);
78 219696 : int end_chunk = static_cast<int>((end_offset - 1) / Page::kPageSize);
79 : int offset_in_start_chunk =
80 219696 : static_cast<int>(start_offset % Page::kPageSize);
81 : // Note that using end_offset % Page::kPageSize would be incorrect
82 : // because end_offset is one beyond the last slot to clear.
83 : int offset_in_end_chunk = static_cast<int>(
84 219696 : end_offset - static_cast<uintptr_t>(end_chunk) * Page::kPageSize);
85 219696 : if (start_chunk == end_chunk) {
86 219684 : slot_set[start_chunk].RemoveRange(offset_in_start_chunk,
87 : offset_in_end_chunk, mode);
88 : } else {
89 : // Clear all slots from start_offset to the end of first chunk.
90 12 : slot_set[start_chunk].RemoveRange(offset_in_start_chunk,
91 : Page::kPageSize, mode);
92 : // Clear all slots in intermediate chunks.
93 16 : for (int i = start_chunk + 1; i < end_chunk; i++) {
94 4 : slot_set[i].RemoveRange(0, Page::kPageSize, mode);
95 : }
96 : // Clear slots from the beginning of the last page to end_offset.
97 12 : slot_set[end_chunk].RemoveRange(0, offset_in_end_chunk, mode);
98 : }
99 : }
100 : }
101 34005017 : }
102 :
103 : // Iterates and filters the remembered set with the given callback.
104 : // The callback should take (Address slot) and return SlotCallbackResult.
105 : template <typename Callback>
106 : static void Iterate(Heap* heap, RememberedSetIterationMode mode,
107 : Callback callback) {
108 : IterateMemoryChunks(heap, [mode, callback](MemoryChunk* chunk) {
109 : if (mode == SYNCHRONIZED) chunk->mutex()->Lock();
110 : Iterate(chunk, callback);
111 : if (mode == SYNCHRONIZED) chunk->mutex()->Unlock();
112 : });
113 : }
114 :
115 : // Iterates over all memory chunks that contains non-empty slot sets.
116 : // The callback should take (MemoryChunk* chunk) and return void.
117 : template <typename Callback>
118 52196 : static void IterateMemoryChunks(Heap* heap, Callback callback) {
119 : OldGenerationMemoryChunkIterator it(heap);
120 : MemoryChunk* chunk;
121 1570562 : while ((chunk = it.next()) != nullptr) {
122 : SlotSet* slots = chunk->slot_set<type>();
123 : TypedSlotSet* typed_slots = chunk->typed_slot_set<type>();
124 1518366 : if (slots != nullptr || typed_slots != nullptr ||
125 : chunk->invalidated_slots() != nullptr) {
126 315181 : callback(chunk);
127 : }
128 : }
129 52196 : }
130 :
131 : // Iterates and filters the remembered set in the given memory chunk with
132 : // the given callback. The callback should take (Address slot) and return
133 : // SlotCallbackResult.
134 : //
135 : // Notice that |mode| can only be of FREE* or PREFREE* if there are no other
136 : // threads concurrently inserting slots.
137 : template <typename Callback>
138 475696 : static void Iterate(MemoryChunk* chunk, Callback callback,
139 : SlotSet::EmptyBucketMode mode) {
140 : SlotSet* slots = chunk->slot_set<type>();
141 475696 : if (slots != nullptr) {
142 473841 : size_t pages = (chunk->size() + Page::kPageSize - 1) / Page::kPageSize;
143 : int new_count = 0;
144 1448941 : for (size_t page = 0; page < pages; page++) {
145 487036 : new_count += slots[page].Iterate(callback, mode);
146 : }
147 : // Only old-to-old slot sets are released eagerly. Old-new-slot sets are
148 : // released by the sweeper threads.
149 13623 : if (type == OLD_TO_OLD && new_count == 0) {
150 13623 : chunk->ReleaseSlotSet<OLD_TO_OLD>();
151 : }
152 : }
153 476214 : }
154 :
155 10 : static int NumberOfPreFreedEmptyBuckets(MemoryChunk* chunk) {
156 : DCHECK(type == OLD_TO_NEW);
157 : int result = 0;
158 : SlotSet* slots = chunk->slot_set<type>();
159 10 : if (slots != nullptr) {
160 10 : size_t pages = (chunk->size() + Page::kPageSize - 1) / Page::kPageSize;
161 30 : for (size_t page = 0; page < pages; page++) {
162 10 : result += slots[page].NumberOfPreFreedEmptyBuckets();
163 : }
164 : }
165 10 : return result;
166 : }
167 :
168 963 : static void PreFreeEmptyBuckets(MemoryChunk* chunk) {
169 : DCHECK(type == OLD_TO_NEW);
170 : SlotSet* slots = chunk->slot_set<type>();
171 963 : if (slots != nullptr) {
172 963 : size_t pages = (chunk->size() + Page::kPageSize - 1) / Page::kPageSize;
173 2889 : for (size_t page = 0; page < pages; page++) {
174 963 : slots[page].PreFreeEmptyBuckets();
175 : }
176 : }
177 963 : }
178 :
179 206697 : static void FreeEmptyBuckets(MemoryChunk* chunk) {
180 : DCHECK(type == OLD_TO_NEW);
181 : SlotSet* slots = chunk->slot_set<type>();
182 206697 : if (slots != nullptr) {
183 158559 : size_t pages = (chunk->size() + Page::kPageSize - 1) / Page::kPageSize;
184 496543 : for (size_t page = 0; page < pages; page++) {
185 168992 : slots[page].FreeEmptyBuckets();
186 168992 : slots[page].FreeToBeFreedBuckets();
187 : }
188 : }
189 206697 : }
190 :
191 : // Given a page and a typed slot in that page, this function adds the slot
192 : // to the remembered set.
193 351607 : static void InsertTyped(MemoryChunk* memory_chunk, SlotType slot_type,
194 : uint32_t offset) {
195 : TypedSlotSet* slot_set = memory_chunk->typed_slot_set<type>();
196 351607 : if (slot_set == nullptr) {
197 9253 : slot_set = memory_chunk->AllocateTypedSlotSet<type>();
198 : }
199 351607 : slot_set->Insert(slot_type, offset);
200 351607 : }
201 :
202 468 : static void MergeTyped(MemoryChunk* page, std::unique_ptr<TypedSlots> slots) {
203 : TypedSlotSet* slot_set = page->typed_slot_set<type>();
204 468 : if (slot_set == nullptr) {
205 338 : slot_set = page->AllocateTypedSlotSet<type>();
206 : }
207 468 : slot_set->Merge(slots.get());
208 468 : }
209 :
210 : // Given a page and a range of typed slots in that page, this function removes
211 : // the slots from the remembered set.
212 193 : static void RemoveRangeTyped(MemoryChunk* page, Address start, Address end) {
213 : TypedSlotSet* slots = page->typed_slot_set<type>();
214 193 : if (slots != nullptr) {
215 0 : slots->Iterate(
216 : [=](SlotType slot_type, Address slot_addr) {
217 0 : return start <= slot_addr && slot_addr < end ? REMOVE_SLOT
218 : : KEEP_SLOT;
219 0 : },
220 : TypedSlotSet::PREFREE_EMPTY_CHUNKS);
221 : }
222 193 : }
223 :
224 : // Iterates and filters the remembered set with the given callback.
225 : // The callback should take (SlotType slot_type, Address addr) and return
226 : // SlotCallbackResult.
227 : template <typename Callback>
228 : static void IterateTyped(Heap* heap, RememberedSetIterationMode mode,
229 : Callback callback) {
230 : IterateMemoryChunks(heap, [mode, callback](MemoryChunk* chunk) {
231 : if (mode == SYNCHRONIZED) chunk->mutex()->Lock();
232 : IterateTyped(chunk, callback);
233 : if (mode == SYNCHRONIZED) chunk->mutex()->Unlock();
234 : });
235 : }
236 :
237 : // Iterates and filters typed old to old pointers in the given memory chunk
238 : // with the given callback. The callback should take (SlotType slot_type,
239 : // Address addr) and return SlotCallbackResult.
240 : template <typename Callback>
241 159235 : static void IterateTyped(MemoryChunk* chunk, Callback callback) {
242 : TypedSlotSet* slots = chunk->typed_slot_set<type>();
243 159235 : if (slots != nullptr) {
244 4498 : int new_count = slots->Iterate(callback, TypedSlotSet::KEEP_EMPTY_CHUNKS);
245 4498 : if (new_count == 0) {
246 2484 : chunk->ReleaseTypedSlotSet<type>();
247 : }
248 : }
249 159235 : }
250 :
251 : // Clear all old to old slots from the remembered set.
252 38 : static void ClearAll(Heap* heap) {
253 : STATIC_ASSERT(type == OLD_TO_OLD);
254 : OldGenerationMemoryChunkIterator it(heap);
255 : MemoryChunk* chunk;
256 1944 : while ((chunk = it.next()) != nullptr) {
257 953 : chunk->ReleaseSlotSet<OLD_TO_OLD>();
258 953 : chunk->ReleaseTypedSlotSet<OLD_TO_OLD>();
259 953 : chunk->ReleaseInvalidatedSlots();
260 : }
261 38 : }
262 :
263 : private:
264 : static bool IsValidSlot(Heap* heap, MemoryChunk* chunk, ObjectSlot slot);
265 : };
266 :
267 : class UpdateTypedSlotHelper {
268 : public:
269 : // Updates a typed slot using an untyped slot callback where |addr| depending
270 : // on slot type represents either address for respective RelocInfo or address
271 : // of the uncompressed constant pool entry.
272 : // The callback accepts FullMaybeObjectSlot and returns SlotCallbackResult.
273 : template <typename Callback>
274 315568 : static SlotCallbackResult UpdateTypedSlot(Heap* heap, SlotType slot_type,
275 : Address addr, Callback callback) {
276 315568 : switch (slot_type) {
277 : case CODE_TARGET_SLOT: {
278 : RelocInfo rinfo(addr, RelocInfo::CODE_TARGET, 0, Code());
279 0 : return UpdateCodeTarget(&rinfo, callback);
280 : }
281 : case CODE_ENTRY_SLOT: {
282 0 : return UpdateCodeEntry(addr, callback);
283 : }
284 : case EMBEDDED_OBJECT_SLOT: {
285 : RelocInfo rinfo(addr, RelocInfo::EMBEDDED_OBJECT, 0, Code());
286 315568 : return UpdateEmbeddedPointer(heap, &rinfo, callback);
287 : }
288 : case OBJECT_SLOT: {
289 0 : return callback(FullMaybeObjectSlot(addr));
290 : }
291 : case CLEARED_SLOT:
292 : break;
293 : }
294 0 : UNREACHABLE();
295 : }
296 :
297 : private:
298 : // Updates a code entry slot using an untyped slot callback.
299 : // The callback accepts FullMaybeObjectSlot and returns SlotCallbackResult.
300 : template <typename Callback>
301 0 : static SlotCallbackResult UpdateCodeEntry(Address entry_address,
302 : Callback callback) {
303 0 : Code code = Code::GetObjectFromEntryAddress(entry_address);
304 : Code old_code = code;
305 0 : SlotCallbackResult result = callback(FullMaybeObjectSlot(&code));
306 : DCHECK(!HasWeakHeapObjectTag(code.ptr()));
307 0 : if (code != old_code) {
308 0 : Memory<Address>(entry_address) = code->entry();
309 : }
310 0 : return result;
311 : }
312 :
313 : // Updates a code target slot using an untyped slot callback.
314 : // The callback accepts FullMaybeObjectSlot and returns SlotCallbackResult.
315 : template <typename Callback>
316 0 : static SlotCallbackResult UpdateCodeTarget(RelocInfo* rinfo,
317 : Callback callback) {
318 : DCHECK(RelocInfo::IsCodeTargetMode(rinfo->rmode()));
319 0 : Code old_target = Code::GetCodeFromTargetAddress(rinfo->target_address());
320 0 : Code new_target = old_target;
321 0 : SlotCallbackResult result = callback(FullMaybeObjectSlot(&new_target));
322 : DCHECK(!HasWeakHeapObjectTag(new_target.ptr()));
323 0 : if (new_target != old_target) {
324 0 : rinfo->set_target_address(
325 : Code::cast(new_target)->raw_instruction_start());
326 : }
327 0 : return result;
328 : }
329 :
330 : // Updates an embedded pointer slot using an untyped slot callback.
331 : // The callback accepts FullMaybeObjectSlot and returns SlotCallbackResult.
332 : template <typename Callback>
333 315546 : static SlotCallbackResult UpdateEmbeddedPointer(Heap* heap, RelocInfo* rinfo,
334 : Callback callback) {
335 : DCHECK(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
336 : HeapObject old_target = rinfo->target_object();
337 315546 : HeapObject new_target = old_target;
338 180873 : SlotCallbackResult result = callback(FullMaybeObjectSlot(&new_target));
339 : DCHECK(!HasWeakHeapObjectTag(new_target->ptr()));
340 315464 : if (new_target != old_target) {
341 : rinfo->set_target_object(heap, HeapObject::cast(new_target));
342 : }
343 315638 : return result;
344 : }
345 : };
346 :
347 : inline SlotType SlotTypeForRelocInfoMode(RelocInfo::Mode rmode) {
348 400860 : if (RelocInfo::IsCodeTargetMode(rmode)) {
349 : return CODE_TARGET_SLOT;
350 400860 : } else if (RelocInfo::IsEmbeddedObject(rmode)) {
351 : return EMBEDDED_OBJECT_SLOT;
352 : }
353 0 : UNREACHABLE();
354 : }
355 :
356 : } // namespace internal
357 : } // namespace v8
358 :
359 : #endif // V8_HEAP_REMEMBERED_SET_H_
|
