OLD | NEW |
1 // Copyright 2016 the V8 project authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/heap/remembered-set.h" | 5 #include "src/heap/remembered-set.h" |
6 #include "src/heap/heap-inl.h" | 6 #include "src/heap/heap-inl.h" |
7 #include "src/heap/heap.h" | 7 #include "src/heap/heap.h" |
8 #include "src/heap/mark-compact.h" | 8 #include "src/heap/mark-compact.h" |
9 #include "src/heap/slot-set.h" | 9 #include "src/heap/slot-set.h" |
10 #include "src/heap/spaces.h" | 10 #include "src/heap/spaces.h" |
11 #include "src/heap/store-buffer.h" | 11 #include "src/heap/store-buffer.h" |
12 #include "src/macro-assembler.h" | 12 #include "src/macro-assembler.h" |
13 | 13 |
14 namespace v8 { | 14 namespace v8 { |
15 namespace internal { | 15 namespace internal { |
16 | 16 |
17 template <PointerDirection direction> | 17 template <PointerDirection direction> |
18 void RememberedSet<direction>::ClearInvalidSlots(Heap* heap, | 18 void RememberedSet<direction>::ClearInvalidSlots(Heap* heap) { |
19 MemoryChunk* chunk) { | |
20 STATIC_ASSERT(direction == OLD_TO_NEW); | 19 STATIC_ASSERT(direction == OLD_TO_NEW); |
21 DCHECK(chunk->owner()->identity() == OLD_SPACE || | 20 for (MemoryChunk* chunk : *heap->old_space()) { |
22 chunk->owner()->identity() == MAP_SPACE); | 21 SlotSet* slots = GetSlotSet(chunk); |
23 SlotSet* slots = GetSlotSet(chunk); | 22 if (slots != nullptr) { |
24 if (slots != nullptr) { | 23 slots->Iterate( |
25 slots->Iterate( | 24 [heap, chunk](Address addr) { |
26 [heap, chunk](Address addr) { | 25 Object** slot = reinterpret_cast<Object**>(addr); |
27 Object** slot = reinterpret_cast<Object**>(addr); | 26 return IsValidSlot(heap, chunk, slot) ? KEEP_SLOT : REMOVE_SLOT; |
28 return IsValidSlot(heap, chunk, slot) ? KEEP_SLOT : REMOVE_SLOT; | 27 }, |
29 }, | 28 SlotSet::PREFREE_EMPTY_BUCKETS); |
30 SlotSet::KEEP_EMPTY_BUCKETS); | 29 } |
| 30 } |
| 31 for (MemoryChunk* chunk : *heap->code_space()) { |
| 32 TypedSlotSet* slots = GetTypedSlotSet(chunk); |
| 33 if (slots != nullptr) { |
| 34 slots->Iterate( |
| 35 [heap, chunk](SlotType type, Address host_addr, Address addr) { |
| 36 if (Marking::IsBlack(ObjectMarking::MarkBitFrom(host_addr))) { |
| 37 return KEEP_SLOT; |
| 38 } else { |
| 39 return REMOVE_SLOT; |
| 40 } |
| 41 }, |
| 42 TypedSlotSet::PREFREE_EMPTY_CHUNKS); |
| 43 } |
| 44 } |
| 45 for (MemoryChunk* chunk : *heap->map_space()) { |
| 46 SlotSet* slots = GetSlotSet(chunk); |
| 47 if (slots != nullptr) { |
| 48 slots->Iterate( |
| 49 [heap, chunk](Address addr) { |
| 50 Object** slot = reinterpret_cast<Object**>(addr); |
| 51 // TODO(mlippautz): In map space all allocations would ideally be |
| 52 // map |
| 53 // aligned. After establishing this invariant IsValidSlot could just |
| 54 // refer to the containing object using alignment and check the mark |
| 55 // bits. |
| 56 return IsValidSlot(heap, chunk, slot) ? KEEP_SLOT : REMOVE_SLOT; |
| 57 }, |
| 58 SlotSet::PREFREE_EMPTY_BUCKETS); |
| 59 } |
31 } | 60 } |
32 } | 61 } |
33 | 62 |
34 template <PointerDirection direction> | 63 template <PointerDirection direction> |
35 void RememberedSet<direction>::ClearInvalidTypedSlots(Heap* heap, | 64 void RememberedSet<direction>::VerifyValidSlots(Heap* heap) { |
36 MemoryChunk* chunk) { | 65 Iterate(heap, [heap](Address addr) { |
37 STATIC_ASSERT(direction == OLD_TO_NEW); | 66 HeapObject* obj = |
38 DCHECK(chunk->owner()->identity() == CODE_SPACE); | 67 heap->mark_compact_collector()->FindBlackObjectBySlotSlow(addr); |
39 TypedSlotSet* slots = GetTypedSlotSet(chunk); | 68 if (obj == nullptr) { |
40 if (slots != nullptr) { | 69 // The slot is in dead object. |
41 slots->Iterate( | 70 MemoryChunk* chunk = MemoryChunk::FromAnyPointerAddress(heap, addr); |
42 [heap, chunk](SlotType type, Address host_addr, Address addr) { | 71 AllocationSpace owner = chunk->owner()->identity(); |
43 if (Marking::IsBlack(ObjectMarking::MarkBitFrom(host_addr))) { | 72 // The old to old remembered set should not have dead slots. |
44 return KEEP_SLOT; | 73 CHECK_NE(direction, OLD_TO_OLD); |
45 } else { | 74 // The old to new remembered set is allowed to have slots in dead |
46 return REMOVE_SLOT; | 75 // objects only in map and large object space because these space |
47 } | 76 // cannot have raw untagged pointers. |
48 }, | 77 CHECK(owner == MAP_SPACE || owner == LO_SPACE); |
49 TypedSlotSet::KEEP_EMPTY_CHUNKS); | 78 } else { |
50 } | 79 int offset = static_cast<int>(addr - obj->address()); |
| 80 CHECK(obj->IsValidSlot(offset)); |
| 81 } |
| 82 return KEEP_SLOT; |
| 83 }); |
51 } | 84 } |
52 | 85 |
53 template <PointerDirection direction> | 86 template <PointerDirection direction> |
54 bool RememberedSet<direction>::IsValidSlot(Heap* heap, MemoryChunk* chunk, | 87 bool RememberedSet<direction>::IsValidSlot(Heap* heap, MemoryChunk* chunk, |
55 Object** slot) { | 88 Object** slot) { |
56 STATIC_ASSERT(direction == OLD_TO_NEW); | 89 STATIC_ASSERT(direction == OLD_TO_NEW); |
| 90 Object* object = *slot; |
| 91 if (!heap->InNewSpace(object)) { |
| 92 return false; |
| 93 } |
| 94 HeapObject* heap_object = HeapObject::cast(object); |
57 // If the target object is not black, the source slot must be part | 95 // If the target object is not black, the source slot must be part |
58 // of a non-black (dead) object. | 96 // of a non-black (dead) object. |
59 return heap->mark_compact_collector()->IsSlotInBlackObject( | 97 return Marking::IsBlack(ObjectMarking::MarkBitFrom(heap_object)) && |
60 chunk, reinterpret_cast<Address>(slot)); | 98 heap->mark_compact_collector()->IsSlotInBlackObject( |
| 99 chunk, reinterpret_cast<Address>(slot)); |
61 } | 100 } |
62 | 101 |
63 template void RememberedSet<OLD_TO_NEW>::ClearInvalidSlots(Heap* heap, | 102 template void RememberedSet<OLD_TO_NEW>::ClearInvalidSlots(Heap* heap); |
64 MemoryChunk* chunk); | 103 template void RememberedSet<OLD_TO_NEW>::VerifyValidSlots(Heap* heap); |
65 template void RememberedSet<OLD_TO_NEW>::ClearInvalidTypedSlots( | 104 template void RememberedSet<OLD_TO_OLD>::VerifyValidSlots(Heap* heap); |
66 Heap* heap, MemoryChunk* chunk); | |
67 | 105 |
68 } // namespace internal | 106 } // namespace internal |
69 } // namespace v8 | 107 } // namespace v8 |
OLD | NEW |