548b99df21da8a872ae52ace9783072d7cc6fa43
[WebKit-https.git] / Source / JavaScriptCore / heap / SlotVisitorInlines.h
1 /*
2  * Copyright (C) 2012, 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef SlotVisitorInlines_h
27 #define SlotVisitorInlines_h
28
29 #include "CopiedBlockInlines.h"
30 #include "CopiedSpaceInlines.h"
31 #include "Options.h"
32 #include "SlotVisitor.h"
33 #include "Weak.h"
34 #include "WeakInlines.h"
35
36 namespace JSC {
37
38 ALWAYS_INLINE void SlotVisitor::append(JSValue* slot, size_t count)
39 {
40     for (size_t i = 0; i < count; ++i) {
41         JSValue& value = slot[i];
42         internalAppend(&value, value);
43     }
44 }
45
46 template<typename T>
47 inline void SlotVisitor::appendUnbarrieredPointer(T** slot)
48 {
49     ASSERT(slot);
50     JSCell* cell = *slot;
51     internalAppend(slot, cell);
52 }
53
54 template<typename T>
55 inline void SlotVisitor::appendUnbarrieredReadOnlyPointer(T* cell)
56 {
57     internalAppend(0, cell);
58 }
59
60 ALWAYS_INLINE void SlotVisitor::append(JSValue* slot)
61 {
62     ASSERT(slot);
63     internalAppend(slot, *slot);
64 }
65
66 ALWAYS_INLINE void SlotVisitor::appendUnbarrieredValue(JSValue* slot)
67 {
68     ASSERT(slot);
69     internalAppend(slot, *slot);
70 }
71
72 ALWAYS_INLINE void SlotVisitor::appendUnbarrieredReadOnlyValue(JSValue value)
73 {
74     internalAppend(0, value);
75 }
76
77 ALWAYS_INLINE void SlotVisitor::append(JSCell** slot)
78 {
79     ASSERT(slot);
80     internalAppend(slot, *slot);
81 }
82
83 template<typename T>
84 ALWAYS_INLINE void SlotVisitor::appendUnbarrieredWeak(Weak<T>* weak)
85 {
86     ASSERT(weak);
87     if (weak->get())
88         internalAppend(0, weak->get());
89 }
90
91 ALWAYS_INLINE void SlotVisitor::internalAppend(void* from, JSValue value)
92 {
93     if (!value || !value.isCell())
94         return;
95     internalAppend(from, value.asCell());
96 }
97
98 ALWAYS_INLINE void SlotVisitor::internalAppend(void* from, JSCell* cell)
99 {
100     ASSERT(!m_isCheckingForDefaultMarkViolation);
101     if (!cell)
102         return;
103 #if ENABLE(ALLOCATION_LOGGING)
104     dataLogF("JSC GC noticing reference from %p to %p.\n", from, cell);
105 #else
106     UNUSED_PARAM(from);
107 #endif
108 #if ENABLE(GC_VALIDATION)
109     validate(cell);
110 #endif
111     if (Heap::testAndSetMarked(cell) || !cell->structure()) {
112         ASSERT(cell->structure());
113         return;
114     }
115
116     cell->setMarked();
117     m_bytesVisited += MarkedBlock::blockFor(cell)->cellSize();
118         
119     unconditionallyAppend(cell);
120 }
121
122 ALWAYS_INLINE void SlotVisitor::unconditionallyAppend(JSCell* cell)
123 {
124     ASSERT(Heap::isMarked(cell));
125     m_visitCount++;
126         
127     // Should never attempt to mark something that is zapped.
128     ASSERT(!cell->isZapped());
129         
130     m_stack.append(cell);
131 }
132
133 template<typename T> inline void SlotVisitor::append(WriteBarrierBase<T>* slot)
134 {
135     internalAppend(slot, *slot->slot());
136 }
137
138 template<typename Iterator> inline void SlotVisitor::append(Iterator begin, Iterator end)
139 {
140     for (auto it = begin; it != end; ++it)
141         append(&*it);
142 }
143
144 ALWAYS_INLINE void SlotVisitor::appendValues(WriteBarrierBase<Unknown>* barriers, size_t count)
145 {
146     append(barriers->slot(), count);
147 }
148
149 inline void SlotVisitor::addWeakReferenceHarvester(WeakReferenceHarvester* weakReferenceHarvester)
150 {
151     m_shared.m_weakReferenceHarvesters.addThreadSafe(weakReferenceHarvester);
152 }
153
154 inline void SlotVisitor::addUnconditionalFinalizer(UnconditionalFinalizer* unconditionalFinalizer)
155 {
156     m_shared.m_unconditionalFinalizers.addThreadSafe(unconditionalFinalizer);
157 }
158
159 inline void SlotVisitor::addOpaqueRoot(void* root)
160 {
161 #if ENABLE(PARALLEL_GC)
162     if (Options::numberOfGCMarkers() == 1) {
163         // Put directly into the shared HashSet.
164         m_shared.m_opaqueRoots.add(root);
165         return;
166     }
167     // Put into the local set, but merge with the shared one every once in
168     // a while to make sure that the local sets don't grow too large.
169     mergeOpaqueRootsIfProfitable();
170     m_opaqueRoots.add(root);
171 #else
172     m_opaqueRoots.add(root);
173 #endif
174 }
175
176 inline bool SlotVisitor::containsOpaqueRoot(void* root) const
177 {
178     ASSERT(!m_isInParallelMode);
179 #if ENABLE(PARALLEL_GC)
180     ASSERT(m_opaqueRoots.isEmpty());
181     return m_shared.m_opaqueRoots.contains(root);
182 #else
183     return m_opaqueRoots.contains(root);
184 #endif
185 }
186
187 inline TriState SlotVisitor::containsOpaqueRootTriState(void* root) const
188 {
189     if (m_opaqueRoots.contains(root))
190         return TrueTriState;
191     std::lock_guard<std::mutex> lock(m_shared.m_opaqueRootsMutex);
192     if (m_shared.m_opaqueRoots.contains(root))
193         return TrueTriState;
194     return MixedTriState;
195 }
196
197 inline int SlotVisitor::opaqueRootCount()
198 {
199     ASSERT(!m_isInParallelMode);
200 #if ENABLE(PARALLEL_GC)
201     ASSERT(m_opaqueRoots.isEmpty());
202     return m_shared.m_opaqueRoots.size();
203 #else
204     return m_opaqueRoots.size();
205 #endif
206 }
207
208 inline void SlotVisitor::mergeOpaqueRootsIfNecessary()
209 {
210     if (m_opaqueRoots.isEmpty())
211         return;
212     mergeOpaqueRoots();
213 }
214     
215 inline void SlotVisitor::mergeOpaqueRootsIfProfitable()
216 {
217     if (static_cast<unsigned>(m_opaqueRoots.size()) < Options::opaqueRootMergeThreshold())
218         return;
219     mergeOpaqueRoots();
220 }
221     
222 inline void SlotVisitor::donate()
223 {
224     ASSERT(m_isInParallelMode);
225     if (Options::numberOfGCMarkers() == 1)
226         return;
227     
228     donateKnownParallel();
229 }
230
231 inline void SlotVisitor::donateAndDrain()
232 {
233     donate();
234     drain();
235 }
236
237 inline void SlotVisitor::copyLater(JSCell* owner, CopyToken token, void* ptr, size_t bytes)
238 {
239     ASSERT(bytes);
240     CopiedBlock* block = CopiedSpace::blockFor(ptr);
241     if (block->isOversize()) {
242         ASSERT(bytes <= block->size());
243         // FIXME: We should be able to shrink the allocation if bytes went below the block size.
244         // For now, we just make sure that our accounting of how much memory we are actually using
245         // is correct.
246         // https://bugs.webkit.org/show_bug.cgi?id=144749
247         bytes = block->size();
248         m_shared.m_copiedSpace->pin(block);
249     }
250
251     ASSERT(heap()->m_storageSpace.contains(block));
252
253     LockHolder locker(&block->workListLock());
254     if (heap()->operationInProgress() == FullCollection || block->shouldReportLiveBytes(locker, owner)) {
255         m_bytesCopied += bytes;
256         block->reportLiveBytes(locker, owner, token, bytes);
257     }
258 }
259     
260 inline void SlotVisitor::reportExtraMemoryVisited(JSCell* owner, size_t size)
261 {
262     heap()->reportExtraMemoryVisited(owner, size);
263 }
264
265 inline Heap* SlotVisitor::heap() const
266 {
267     return &sharedData().m_vm->heap;
268 }
269
270 inline VM& SlotVisitor::vm()
271 {
272     return *sharedData().m_vm;
273 }
274
275 inline const VM& SlotVisitor::vm() const
276 {
277     return *sharedData().m_vm;
278 }
279
280 } // namespace JSC
281
282 #endif // SlotVisitorInlines_h
283