OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 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 #ifndef V8_HEAP_MARK_COMPACT_H_ | 5 #ifndef V8_HEAP_MARK_COMPACT_H_ |
6 #define V8_HEAP_MARK_COMPACT_H_ | 6 #define V8_HEAP_MARK_COMPACT_H_ |
7 | 7 |
8 #include <deque> | 8 #include <deque> |
9 | 9 |
10 #include "src/base/bits.h" | 10 #include "src/base/bits.h" |
(...skipping 29 matching lines...) Expand all Loading... |
40 const MemoryChunk* p = MemoryChunk::FromAddress(address); | 40 const MemoryChunk* p = MemoryChunk::FromAddress(address); |
41 return p->markbits<mode>()->MarkBitFromIndex( | 41 return p->markbits<mode>()->MarkBitFromIndex( |
42 p->AddressToMarkbitIndex(address)); | 42 p->AddressToMarkbitIndex(address)); |
43 } | 43 } |
44 | 44 |
45 template <MarkingMode mode = MarkingMode::FULL> | 45 template <MarkingMode mode = MarkingMode::FULL> |
46 static Marking::ObjectColor Color(HeapObject* obj) { | 46 static Marking::ObjectColor Color(HeapObject* obj) { |
47 return Marking::Color(ObjectMarking::MarkBitFrom<mode>(obj)); | 47 return Marking::Color(ObjectMarking::MarkBitFrom<mode>(obj)); |
48 } | 48 } |
49 | 49 |
50 template <MarkingMode mode = MarkingMode::FULL> | 50 template <MarkBit::AccessMode access_mode = MarkBit::NON_ATOMIC, |
| 51 MarkingMode mode = MarkingMode::FULL> |
51 V8_INLINE static bool IsImpossible(HeapObject* obj) { | 52 V8_INLINE static bool IsImpossible(HeapObject* obj) { |
52 return Marking::IsImpossible(MarkBitFrom<mode>(obj)); | 53 return Marking::IsImpossible<access_mode>(MarkBitFrom<mode>(obj)); |
53 } | 54 } |
54 | 55 |
55 template <MarkingMode mode = MarkingMode::FULL> | 56 template <MarkBit::AccessMode access_mode = MarkBit::NON_ATOMIC, |
| 57 MarkingMode mode = MarkingMode::FULL> |
56 V8_INLINE static bool IsBlack(HeapObject* obj) { | 58 V8_INLINE static bool IsBlack(HeapObject* obj) { |
57 return Marking::IsBlack(MarkBitFrom<mode>(obj)); | 59 return Marking::IsBlack<access_mode>(MarkBitFrom<mode>(obj)); |
58 } | 60 } |
59 | 61 |
60 template <MarkingMode mode = MarkingMode::FULL> | 62 template <MarkBit::AccessMode access_mode = MarkBit::NON_ATOMIC, |
| 63 MarkingMode mode = MarkingMode::FULL> |
61 V8_INLINE static bool IsWhite(HeapObject* obj) { | 64 V8_INLINE static bool IsWhite(HeapObject* obj) { |
62 return Marking::IsWhite(MarkBitFrom<mode>(obj)); | 65 return Marking::IsWhite<access_mode>(MarkBitFrom<mode>(obj)); |
63 } | 66 } |
64 | 67 |
65 template <MarkingMode mode = MarkingMode::FULL> | 68 template <MarkBit::AccessMode access_mode = MarkBit::NON_ATOMIC, |
| 69 MarkingMode mode = MarkingMode::FULL> |
66 V8_INLINE static bool IsGrey(HeapObject* obj) { | 70 V8_INLINE static bool IsGrey(HeapObject* obj) { |
67 return Marking::IsGrey(MarkBitFrom<mode>(obj)); | 71 return Marking::IsGrey<access_mode>(MarkBitFrom<mode>(obj)); |
68 } | 72 } |
69 | 73 |
70 template <MarkingMode mode = MarkingMode::FULL> | 74 template <MarkBit::AccessMode access_mode = MarkBit::NON_ATOMIC, |
| 75 MarkingMode mode = MarkingMode::FULL> |
71 V8_INLINE static bool IsBlackOrGrey(HeapObject* obj) { | 76 V8_INLINE static bool IsBlackOrGrey(HeapObject* obj) { |
72 return Marking::IsBlackOrGrey(MarkBitFrom<mode>(obj)); | 77 return Marking::IsBlackOrGrey<access_mode>(MarkBitFrom<mode>(obj)); |
73 } | 78 } |
74 | 79 |
75 template <MarkingMode mode = MarkingMode::FULL> | 80 template <MarkBit::AccessMode access_mode = MarkBit::NON_ATOMIC, |
76 V8_INLINE static void BlackToGrey(HeapObject* obj) { | 81 MarkingMode mode = MarkingMode::FULL> |
77 DCHECK(IsBlack<mode>(obj)); | 82 V8_INLINE static bool BlackToGrey(HeapObject* obj) { |
| 83 DCHECK((access_mode == MarkBit::ATOMIC || IsBlack<access_mode, mode>(obj))); |
78 MarkBit markbit = MarkBitFrom<mode>(obj); | 84 MarkBit markbit = MarkBitFrom<mode>(obj); |
79 Marking::BlackToGrey(markbit); | 85 if (!Marking::BlackToGrey<access_mode>(markbit)) return false; |
80 MemoryChunk::IncrementLiveBytes<mode>(obj, -obj->Size()); | 86 MemoryChunk::IncrementLiveBytes<mode>(obj, -obj->Size()); |
| 87 return true; |
81 } | 88 } |
82 | 89 |
83 template <MarkingMode mode = MarkingMode::FULL> | 90 template <MarkBit::AccessMode access_mode = MarkBit::NON_ATOMIC, |
84 V8_INLINE static void WhiteToGrey(HeapObject* obj) { | 91 MarkingMode mode = MarkingMode::FULL> |
85 DCHECK(IsWhite<mode>(obj)); | 92 V8_INLINE static bool WhiteToGrey(HeapObject* obj) { |
86 Marking::WhiteToGrey(MarkBitFrom<mode>(obj)); | 93 DCHECK((access_mode == MarkBit::ATOMIC || IsWhite<access_mode, mode>(obj))); |
| 94 return Marking::WhiteToGrey<access_mode>(MarkBitFrom<mode>(obj)); |
87 } | 95 } |
88 | 96 |
89 template <MarkingMode mode = MarkingMode::FULL> | 97 template <MarkBit::AccessMode access_mode = MarkBit::NON_ATOMIC, |
90 V8_INLINE static void WhiteToBlack(HeapObject* obj) { | 98 MarkingMode mode = MarkingMode::FULL> |
91 DCHECK(IsWhite<mode>(obj)); | 99 V8_INLINE static bool WhiteToBlack(HeapObject* obj) { |
92 MarkBit markbit = MarkBitFrom<mode>(obj); | 100 DCHECK((access_mode == MarkBit::ATOMIC || IsWhite<access_mode, mode>(obj))); |
93 Marking::WhiteToBlack(markbit); | 101 if (!ObjectMarking::WhiteToGrey<access_mode, mode>(obj)) return false; |
94 MemoryChunk::IncrementLiveBytes<mode>(obj, obj->Size()); | 102 return ObjectMarking::GreyToBlack<access_mode, mode>(obj); |
95 } | 103 } |
96 | 104 |
97 template <MarkingMode mode = MarkingMode::FULL> | 105 template <MarkBit::AccessMode access_mode = MarkBit::NON_ATOMIC, |
98 V8_INLINE static void GreyToBlack(HeapObject* obj) { | 106 MarkingMode mode = MarkingMode::FULL> |
99 DCHECK(IsGrey<mode>(obj)); | 107 V8_INLINE static bool GreyToBlack(HeapObject* obj) { |
| 108 DCHECK((access_mode == MarkBit::ATOMIC || IsGrey<access_mode, mode>(obj))); |
100 MarkBit markbit = MarkBitFrom<mode>(obj); | 109 MarkBit markbit = MarkBitFrom<mode>(obj); |
101 Marking::GreyToBlack(markbit); | 110 if (!Marking::GreyToBlack<access_mode>(markbit)) return false; |
102 MemoryChunk::IncrementLiveBytes<mode>(obj, obj->Size()); | 111 MemoryChunk::IncrementLiveBytes<mode>(obj, obj->Size()); |
| 112 return true; |
103 } | 113 } |
104 | 114 |
105 private: | 115 private: |
106 DISALLOW_IMPLICIT_CONSTRUCTORS(ObjectMarking); | 116 DISALLOW_IMPLICIT_CONSTRUCTORS(ObjectMarking); |
107 }; | 117 }; |
108 | 118 |
109 // ---------------------------------------------------------------------------- | 119 // ---------------------------------------------------------------------------- |
110 // Marking deque for tracing live objects. | 120 // Marking deque for tracing live objects. |
111 class MarkingDeque { | 121 class MarkingDeque { |
112 public: | 122 public: |
(...skipping 717 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
830 | 840 |
831 private: | 841 private: |
832 MarkCompactCollector* collector_; | 842 MarkCompactCollector* collector_; |
833 }; | 843 }; |
834 | 844 |
835 V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space); | 845 V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space); |
836 } // namespace internal | 846 } // namespace internal |
837 } // namespace v8 | 847 } // namespace v8 |
838 | 848 |
839 #endif // V8_HEAP_MARK_COMPACT_H_ | 849 #endif // V8_HEAP_MARK_COMPACT_H_ |
OLD | NEW |