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 176053513 : 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 176053513 : if (slot_set == nullptr) {
30 88542 : slot_set = chunk->AllocateSlotSet<type>();
31 : }
32 176053516 : uintptr_t offset = slot_addr - chunk->address();
33 176053516 : slot_set[offset / Page::kPageSize].Insert<access_mode>(offset %
34 : Page::kPageSize);
35 176134907 : }
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 666 : static void Remove(MemoryChunk* chunk, Address slot_addr) {
54 : DCHECK(chunk->Contains(slot_addr));
55 : SlotSet* slot_set = chunk->slot_set<type>();
56 666 : if (slot_set != nullptr) {
57 340 : uintptr_t offset = slot_addr - chunk->address();
58 340 : slot_set[offset / Page::kPageSize].Remove(offset % Page::kPageSize);
59 : }
60 666 : }
61 :
62 : // Given a page and a range of slots in that page, this function removes the
63 : // slots from the remembered set.
64 39761336 : static void RemoveRange(MemoryChunk* chunk, Address start, Address end,
65 : SlotSet::EmptyBucketMode mode) {
66 : SlotSet* slot_set = chunk->slot_set<type>();
67 39761336 : if (slot_set != nullptr) {
68 19505679 : uintptr_t start_offset = start - chunk->address();
69 19505679 : uintptr_t end_offset = end - chunk->address();
70 : DCHECK_LT(start_offset, end_offset);
71 19505679 : if (end_offset < static_cast<uintptr_t>(Page::kPageSize)) {
72 19295726 : 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 209953 : int start_chunk = static_cast<int>(start_offset / Page::kPageSize);
78 209953 : int end_chunk = static_cast<int>((end_offset - 1) / Page::kPageSize);
79 : int offset_in_start_chunk =
80 209953 : 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 209953 : end_offset - static_cast<uintptr_t>(end_chunk) * Page::kPageSize);
85 209953 : if (start_chunk == end_chunk) {
86 209941 : 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 13 : for (int i = start_chunk + 1; i < end_chunk; i++) {
94 1 : 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 39765811 : }
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 41946 : static void IterateMemoryChunks(Heap* heap, Callback callback) {
119 : OldGenerationMemoryChunkIterator it(heap);
120 : MemoryChunk* chunk;
121 562200 : while ((chunk = it.next()) != nullptr) {
122 : SlotSet* slots = chunk->slot_set<type>();
123 : TypedSlotSet* typed_slots = chunk->typed_slot_set<type>();
124 520254 : if (slots != nullptr || typed_slots != nullptr ||
125 : chunk->invalidated_slots() != nullptr) {
126 216554 : callback(chunk);
127 : }
128 : }
129 41946 : }
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 426381 : static void Iterate(MemoryChunk* chunk, Callback callback,
139 : SlotSet::EmptyBucketMode mode) {
140 : SlotSet* slots = chunk->slot_set<type>();
141 426381 : if (slots != nullptr) {
142 424521 : size_t pages = (chunk->size() + Page::kPageSize - 1) / Page::kPageSize;
143 : int new_count = 0;
144 1280671 : for (size_t page = 0; page < pages; page++) {
145 427613 : 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 11402 : if (type == OLD_TO_OLD && new_count == 0) {
150 11402 : chunk->ReleaseSlotSet<OLD_TO_OLD>();
151 : }
152 : }
153 426843 : }
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 609 : static void PreFreeEmptyBuckets(MemoryChunk* chunk) {
169 : DCHECK(type == OLD_TO_NEW);
170 : SlotSet* slots = chunk->slot_set<type>();
171 609 : if (slots != nullptr) {
172 609 : size_t pages = (chunk->size() + Page::kPageSize - 1) / Page::kPageSize;
173 1827 : for (size_t page = 0; page < pages; page++) {
174 609 : slots[page].PreFreeEmptyBuckets();
175 : }
176 : }
177 609 : }
178 :
179 166166 : static void FreeEmptyBuckets(MemoryChunk* chunk) {
180 : DCHECK(type == OLD_TO_NEW);
181 : SlotSet* slots = chunk->slot_set<type>();
182 166166 : if (slots != nullptr) {
183 108934 : size_t pages = (chunk->size() + Page::kPageSize - 1) / Page::kPageSize;
184 331092 : for (size_t page = 0; page < pages; page++) {
185 111079 : slots[page].FreeEmptyBuckets();
186 111079 : slots[page].FreeToBeFreedBuckets();
187 : }
188 : }
189 166166 : }
190 :
191 : // Given a page and a typed slot in that page, this function adds the slot
192 : // to the remembered set.
193 306185 : static void InsertTyped(MemoryChunk* memory_chunk, SlotType slot_type,
194 : uint32_t offset) {
195 : TypedSlotSet* slot_set = memory_chunk->typed_slot_set<type>();
196 306185 : if (slot_set == nullptr) {
197 9079 : slot_set = memory_chunk->AllocateTypedSlotSet<type>();
198 : }
199 306185 : slot_set->Insert(slot_type, offset);
200 306182 : }
201 :
202 639 : static void MergeTyped(MemoryChunk* page, std::unique_ptr<TypedSlots> slots) {
203 : TypedSlotSet* slot_set = page->typed_slot_set<type>();
204 639 : if (slot_set == nullptr) {
205 437 : slot_set = page->AllocateTypedSlotSet<type>();
206 : }
207 639 : slot_set->Merge(slots.get());
208 639 : }
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 201 : static void RemoveRangeTyped(MemoryChunk* page, Address start, Address end) {
213 : TypedSlotSet* slots = page->typed_slot_set<type>();
214 201 : 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 201 : }
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 110593 : static void IterateTyped(MemoryChunk* chunk, Callback callback) {
242 : TypedSlotSet* slots = chunk->typed_slot_set<type>();
243 110593 : if (slots != nullptr) {
244 4553 : int new_count = slots->Iterate(callback, TypedSlotSet::KEEP_EMPTY_CHUNKS);
245 4554 : if (new_count == 0) {
246 2420 : chunk->ReleaseTypedSlotSet<type>();
247 : }
248 : }
249 110594 : }
250 :
251 : // Clear all old to old slots from the remembered set.
252 37 : static void ClearAll(Heap* heap) {
253 : STATIC_ASSERT(type == OLD_TO_OLD);
254 : OldGenerationMemoryChunkIterator it(heap);
255 : MemoryChunk* chunk;
256 1245 : while ((chunk = it.next()) != nullptr) {
257 604 : chunk->ReleaseSlotSet<OLD_TO_OLD>();
258 604 : chunk->ReleaseTypedSlotSet<OLD_TO_OLD>();
259 604 : chunk->ReleaseInvalidatedSlots();
260 : }
261 37 : }
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 413686 : static SlotCallbackResult UpdateTypedSlot(Heap* heap, SlotType slot_type,
275 : Address addr, Callback callback) {
276 413686 : 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 413686 : 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 413650 : 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 413650 : HeapObject new_target = old_target;
338 277533 : SlotCallbackResult result = callback(FullMaybeObjectSlot(&new_target));
339 : DCHECK(!HasWeakHeapObjectTag(new_target->ptr()));
340 413529 : if (new_target != old_target) {
341 : rinfo->set_target_object(heap, HeapObject::cast(new_target));
342 : }
343 413567 : return result;
344 : }
345 : };
346 :
347 : inline SlotType SlotTypeForRelocInfoMode(RelocInfo::Mode rmode) {
348 498397 : if (RelocInfo::IsCodeTargetMode(rmode)) {
349 : return CODE_TARGET_SLOT;
350 498397 : } 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_
|