Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(36)

Side by Side Diff: third_party/WebKit/Source/platform/heap/MarkingVisitorImpl.h

Issue 1909803002: Add per thread heap enabled MarkingVisitorImpl Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 4 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 The Chromium 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 MarkingVisitorImpl_h 5 #ifndef MarkingVisitorImpl_h
6 #define MarkingVisitorImpl_h 6 #define MarkingVisitorImpl_h
7 7
8 #include "platform/heap/Heap.h" 8 #include "platform/heap/Heap.h"
9 #include "platform/heap/ThreadState.h" 9 #include "platform/heap/ThreadState.h"
10 #include "platform/heap/Visitor.h" 10 #include "platform/heap/Visitor.h"
11 #include "wtf/Allocator.h" 11 #include "wtf/Allocator.h"
12 #include "wtf/Functional.h" 12 #include "wtf/Functional.h"
13 #include "wtf/HashFunctions.h" 13 #include "wtf/HashFunctions.h"
14 #include "wtf/Locker.h" 14 #include "wtf/Locker.h"
15 #include "wtf/TypeTraits.h" 15 #include "wtf/TypeTraits.h"
16 16
17 namespace blink { 17 namespace blink {
18 18
19 template <typename Derived> 19 template <typename Derived, bool PerThreadHeapEnabled>
20 struct HeapAccessor {
21 static ThreadHeap* heap(Derived* visitor);
22 };
23
24 template<typename Derived>
25 struct HeapAccessor<Derived, true> {
26 static ThreadHeap* heap(Derived* visitor)
27 {
28 return &visitor->heap();
29 }
30 };
31
32 template<typename Derived>
33 struct HeapAccessor<Derived, false> {
34 static ThreadHeap* heap(Derived* visitor)
35 {
36 return ThreadHeap::mainThreadHeap();
37 }
38 };
39
40 template <typename Derived, bool PerThreadHeapEnabled>
20 class MarkingVisitorImpl { 41 class MarkingVisitorImpl {
21 USING_FAST_MALLOC(MarkingVisitorImpl); 42 USING_FAST_MALLOC(MarkingVisitorImpl);
22 protected: 43 protected:
23 inline void markHeader(HeapObjectHeader* header, const void* objectPointer, TraceCallback callback) 44 inline void markHeader(HeapObjectHeader* header, const void* objectPointer, TraceCallback callback)
24 { 45 {
25 ASSERT(header); 46 ASSERT(header);
26 ASSERT(objectPointer); 47 ASSERT(objectPointer);
27 if (!toDerived()->shouldMarkObject(objectPointer)) 48 if (!toDerived()->shouldMarkObject(objectPointer))
28 return; 49 return;
29 50
30 // If you hit this ASSERT, it means that there is a dangling pointer 51 // If you hit this ASSERT, it means that there is a dangling pointer
31 // from a live thread heap to a dead thread heap. We must eliminate 52 // from a live thread heap to a dead thread heap. We must eliminate
32 // the dangling pointer. 53 // the dangling pointer.
33 // Release builds don't have the ASSERT, but it is OK because 54 // Release builds don't have the ASSERT, but it is OK because
34 // release builds will crash in the following header->isMarked() 55 // release builds will crash in the following header->isMarked()
35 // because all the entries of the orphaned arenas are zapped. 56 // because all the entries of the orphaned arenas are zapped.
36 ASSERT(!pageFromObject(objectPointer)->orphaned()); 57 ASSERT(!pageFromObject(objectPointer)->orphaned());
37 58
38 if (header->isMarked()) 59 if (header->isMarked())
39 return; 60 return;
40 61
41 ASSERT(ThreadState::current()->isInGC()); 62 ASSERT(ThreadState::current()->isInGC());
42 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing); 63 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing);
43 64
44 header->mark(); 65 header->mark();
45 66
46 if (callback) 67 if (callback)
47 ThreadHeap::mainThreadHeap()->pushTraceCallback(const_cast<void*>(ob jectPointer), callback); 68 getThreadHeap()->pushTraceCallback(const_cast<void*>(objectPointer), callback);
48 } 69 }
49 70
50 inline void mark(const void* objectPointer, TraceCallback callback) 71 inline void mark(const void* objectPointer, TraceCallback callback)
51 { 72 {
52 if (!objectPointer) 73 if (!objectPointer)
53 return; 74 return;
54 HeapObjectHeader* header = HeapObjectHeader::fromPayload(objectPointer); 75 HeapObjectHeader* header = HeapObjectHeader::fromPayload(objectPointer);
55 markHeader(header, header->payload(), callback); 76 markHeader(header, header->payload(), callback);
56 } 77 }
57 78
58 inline void registerDelayedMarkNoTracing(const void* objectPointer) 79 inline void registerDelayedMarkNoTracing(const void* objectPointer)
59 { 80 {
60 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing); 81 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing);
61 ThreadHeap::mainThreadHeap()->pushPostMarkingCallback(const_cast<void*>( objectPointer), &markNoTracingCallback); 82 getThreadHeap()->pushPostMarkingCallback(const_cast<void*>(objectPointer ), &markNoTracingCallback);
62 } 83 }
63 84
64 inline void registerWeakMembers(const void* closure, const void* objectPoint er, WeakCallback callback) 85 inline void registerWeakMembers(const void* closure, const void* objectPoint er, WeakCallback callback)
65 { 86 {
66 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing); 87 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing);
67 // We don't want to run weak processings when taking a snapshot. 88 // We don't want to run weak processings when taking a snapshot.
68 if (toDerived()->getMarkingMode() == Visitor::SnapshotMarking) 89 if (toDerived()->getMarkingMode() == Visitor::SnapshotMarking)
69 return; 90 return;
70 ThreadHeap::mainThreadHeap()->pushThreadLocalWeakCallback(const_cast<voi d*>(closure), const_cast<void*>(objectPointer), callback); 91 getThreadHeap()->pushThreadLocalWeakCallback(const_cast<void*>(closure), const_cast<void*>(objectPointer), callback);
71 } 92 }
72 93
73 inline void registerWeakTable(const void* closure, EphemeronCallback iterati onCallback, EphemeronCallback iterationDoneCallback) 94 inline void registerWeakTable(const void* closure, EphemeronCallback iterati onCallback, EphemeronCallback iterationDoneCallback)
74 { 95 {
75 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing); 96 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing);
76 ThreadHeap::mainThreadHeap()->registerWeakTable(const_cast<void*>(closur e), iterationCallback, iterationDoneCallback); 97 getThreadHeap()->registerWeakTable(const_cast<void*>(closure), iteration Callback, iterationDoneCallback);
77 } 98 }
78 99
79 #if ENABLE(ASSERT) 100 #if ENABLE(ASSERT)
80 inline bool weakTableRegistered(const void* closure) 101 inline bool weakTableRegistered(const void* closure)
81 { 102 {
82 return ThreadHeap::mainThreadHeap()->weakTableRegistered(closure); 103 return getThreadHeap()->weakTableRegistered(closure);
83 } 104 }
84 #endif 105 #endif
85 106
86 inline bool ensureMarked(const void* objectPointer) 107 inline bool ensureMarked(const void* objectPointer)
87 { 108 {
88 if (!objectPointer) 109 if (!objectPointer)
89 return false; 110 return false;
90 if (!toDerived()->shouldMarkObject(objectPointer)) 111 if (!toDerived()->shouldMarkObject(objectPointer))
91 return false; 112 return false;
92 #if ENABLE(ASSERT) 113 #if ENABLE(ASSERT)
(...skipping 10 matching lines...) Expand all
103 header->mark(); 124 header->mark();
104 #endif 125 #endif
105 return true; 126 return true;
106 } 127 }
107 128
108 Derived* toDerived() 129 Derived* toDerived()
109 { 130 {
110 return static_cast<Derived*>(this); 131 return static_cast<Derived*>(this);
111 } 132 }
112 133
134 ThreadHeap* getThreadHeap()
135 {
136 return HeapAccessor<Derived, PerThreadHeapEnabled>::heap(toDerived());
137 }
138
113 protected: 139 protected:
114 inline void registerWeakCellWithCallback(void** cell, WeakCallback callback) 140 inline void registerWeakCellWithCallback(void** cell, WeakCallback callback)
115 { 141 {
116 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing); 142 ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing);
117 // We don't want to run weak processings when taking a snapshot. 143 // We don't want to run weak processings when taking a snapshot.
118 if (toDerived()->getMarkingMode() == Visitor::SnapshotMarking) 144 if (toDerived()->getMarkingMode() == Visitor::SnapshotMarking)
119 return; 145 return;
120 ThreadHeap::mainThreadHeap()->pushGlobalWeakCallback(cell, callback); 146 getThreadHeap()->pushGlobalWeakCallback(cell, callback);
121 } 147 }
122 148
123 private: 149 private:
124 static void markNoTracingCallback(Visitor* visitor, void* object) 150 static void markNoTracingCallback(Visitor* visitor, void* object)
125 { 151 {
126 visitor->markNoTracing(object); 152 visitor->markNoTracing(object);
127 } 153 }
128 }; 154 };
129 155
130 } // namespace blink 156 } // namespace blink
131 157
132 #endif 158 #endif
OLDNEW
« no previous file with comments | « third_party/WebKit/Source/platform/heap/MarkingVisitor.h ('k') | third_party/WebKit/Source/platform/heap/Visitor.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698