3a736eafc4afcc0b9fdb859c4c3480ec36cdb975
[WebKit-https.git] / Source / JavaScriptCore / heap / Heap.cpp
1 /*
2  *  Copyright (C) 2003-2009, 2011, 2013-2016 Apple Inc. All rights reserved.
3  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Lesser General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public
16  *  License along with this library; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  *
19  */
20
21 #include "config.h"
22 #include "Heap.h"
23
24 #include "CodeBlock.h"
25 #include "ConservativeRoots.h"
26 #include "CopiedSpace.h"
27 #include "CopiedSpaceInlines.h"
28 #include "CopyVisitorInlines.h"
29 #include "DFGWorklist.h"
30 #include "EdenGCActivityCallback.h"
31 #include "FullGCActivityCallback.h"
32 #include "GCActivityCallback.h"
33 #include "GCIncomingRefCountedSetInlines.h"
34 #include "HeapHelperPool.h"
35 #include "HeapIterationScope.h"
36 #include "HeapProfiler.h"
37 #include "HeapRootVisitor.h"
38 #include "HeapSnapshot.h"
39 #include "HeapStatistics.h"
40 #include "HeapVerifier.h"
41 #include "IncrementalSweeper.h"
42 #include "Interpreter.h"
43 #include "JITStubRoutineSet.h"
44 #include "JITWorklist.h"
45 #include "JSCInlines.h"
46 #include "JSGlobalObject.h"
47 #include "JSLock.h"
48 #include "JSVirtualMachineInternal.h"
49 #include "SamplingProfiler.h"
50 #include "ShadowChicken.h"
51 #include "SuperSampler.h"
52 #include "TypeProfilerLog.h"
53 #include "UnlinkedCodeBlock.h"
54 #include "VM.h"
55 #include "WeakSetInlines.h"
56 #include <algorithm>
57 #include <wtf/CurrentTime.h>
58 #include <wtf/MainThread.h>
59 #include <wtf/ParallelVectorIterator.h>
60 #include <wtf/ProcessID.h>
61 #include <wtf/RAMSize.h>
62
63 #if USE(FOUNDATION)
64 #if __has_include(<objc/objc-internal.h>)
65 #include <objc/objc-internal.h>
66 #else
67 extern "C" void* objc_autoreleasePoolPush(void);
68 extern "C" void objc_autoreleasePoolPop(void *context);
69 #endif
70 #endif // USE(FOUNDATION)
71
72 using namespace std;
73
74 namespace JSC {
75
76 namespace {
77
78 static const size_t largeHeapSize = 32 * MB; // About 1.5X the average webpage.
79 const size_t smallHeapSize = 1 * MB; // Matches the FastMalloc per-thread cache.
80
81 size_t minHeapSize(HeapType heapType, size_t ramSize)
82 {
83     if (heapType == LargeHeap)
84         return min(largeHeapSize, ramSize / 4);
85     return smallHeapSize;
86 }
87
88 size_t proportionalHeapSize(size_t heapSize, size_t ramSize)
89 {
90     // Try to stay under 1/2 RAM size to leave room for the DOM, rendering, networking, etc.
91     if (heapSize < ramSize / 4)
92         return 2 * heapSize;
93     if (heapSize < ramSize / 2)
94         return 1.5 * heapSize;
95     return 1.25 * heapSize;
96 }
97
98 bool isValidSharedInstanceThreadState(VM* vm)
99 {
100     return vm->currentThreadIsHoldingAPILock();
101 }
102
103 bool isValidThreadState(VM* vm)
104 {
105     if (vm->atomicStringTable() != wtfThreadData().atomicStringTable())
106         return false;
107
108     if (vm->isSharedInstance() && !isValidSharedInstanceThreadState(vm))
109         return false;
110
111     return true;
112 }
113
114 void recordType(TypeCountSet& set, JSCell* cell)
115 {
116     const char* typeName = "[unknown]";
117     const ClassInfo* info = cell->classInfo();
118     if (info && info->className)
119         typeName = info->className;
120     set.add(typeName);
121 }
122
123 bool measurePhaseTiming()
124 {
125     return false;
126 }
127
128 class TimingScope {
129 public:
130     TimingScope(const char* name)
131         : m_name(name)
132     {
133         if (measurePhaseTiming())
134             m_before = monotonicallyIncreasingTimeMS();
135     }
136     
137     ~TimingScope()
138     {
139         if (measurePhaseTiming()) {
140             double after = monotonicallyIncreasingTimeMS();
141             dataLog("[GC] ", m_name, " took: ", after - m_before, " ms.\n");
142         }
143     }
144 private:
145     double m_before;
146     const char* m_name;
147 };
148
149 } // anonymous namespace
150
151 Heap::Heap(VM* vm, HeapType heapType)
152     : m_heapType(heapType)
153     , m_ramSize(Options::forceRAMSize() ? Options::forceRAMSize() : ramSize())
154     , m_minBytesPerCycle(minHeapSize(m_heapType, m_ramSize))
155     , m_sizeAfterLastCollect(0)
156     , m_sizeAfterLastFullCollect(0)
157     , m_sizeBeforeLastFullCollect(0)
158     , m_sizeAfterLastEdenCollect(0)
159     , m_sizeBeforeLastEdenCollect(0)
160     , m_bytesAllocatedThisCycle(0)
161     , m_bytesAbandonedSinceLastFullCollect(0)
162     , m_maxEdenSize(m_minBytesPerCycle)
163     , m_maxHeapSize(m_minBytesPerCycle)
164     , m_shouldDoFullCollection(false)
165     , m_totalBytesVisited(0)
166     , m_totalBytesCopied(0)
167     , m_operationInProgress(NoOperation)
168     , m_objectSpace(this)
169     , m_storageSpace(this)
170     , m_extraMemorySize(0)
171     , m_deprecatedExtraMemorySize(0)
172     , m_machineThreads(this)
173     , m_slotVisitor(*this)
174     , m_handleSet(vm)
175     , m_codeBlocks(std::make_unique<CodeBlockSet>())
176     , m_jitStubRoutines(std::make_unique<JITStubRoutineSet>())
177     , m_isSafeToCollect(false)
178     , m_writeBarrierBuffer(256)
179     , m_vm(vm)
180     // We seed with 10ms so that GCActivityCallback::didAllocate doesn't continuously 
181     // schedule the timer if we've never done a collection.
182     , m_lastFullGCLength(0.01)
183     , m_lastEdenGCLength(0.01)
184     , m_fullActivityCallback(GCActivityCallback::createFullTimer(this))
185     , m_edenActivityCallback(GCActivityCallback::createEdenTimer(this))
186 #if USE(CF)
187     , m_sweeper(std::make_unique<IncrementalSweeper>(this, CFRunLoopGetCurrent()))
188 #else
189     , m_sweeper(std::make_unique<IncrementalSweeper>(this))
190 #endif
191     , m_deferralDepth(0)
192 #if USE(FOUNDATION)
193     , m_delayedReleaseRecursionCount(0)
194 #endif
195     , m_helperClient(&heapHelperPool())
196 {
197     m_storageSpace.init();
198     if (Options::verifyHeap())
199         m_verifier = std::make_unique<HeapVerifier>(this, Options::numberOfGCCyclesToRecordForVerification());
200 }
201
202 Heap::~Heap()
203 {
204     for (WeakBlock* block : m_logicallyEmptyWeakBlocks)
205         WeakBlock::destroy(*this, block);
206 }
207
208 bool Heap::isPagedOut(double deadline)
209 {
210     return m_objectSpace.isPagedOut(deadline) || m_storageSpace.isPagedOut(deadline);
211 }
212
213 // The VM is being destroyed and the collector will never run again.
214 // Run all pending finalizers now because we won't get another chance.
215 void Heap::lastChanceToFinalize()
216 {
217     RELEASE_ASSERT(!m_vm->entryScope);
218     RELEASE_ASSERT(m_operationInProgress == NoOperation);
219
220     m_arrayBuffers.lastChanceToFinalize();
221     m_codeBlocks->lastChanceToFinalize();
222     m_objectSpace.lastChanceToFinalize();
223     releaseDelayedReleasedObjects();
224
225     sweepAllLogicallyEmptyWeakBlocks();
226 }
227
228 void Heap::releaseDelayedReleasedObjects()
229 {
230 #if USE(FOUNDATION)
231     // We need to guard against the case that releasing an object can create more objects due to the
232     // release calling into JS. When those JS call(s) exit and all locks are being dropped we end up
233     // back here and could try to recursively release objects. We guard that with a recursive entry
234     // count. Only the initial call will release objects, recursive calls simple return and let the
235     // the initial call to the function take care of any objects created during release time.
236     // This also means that we need to loop until there are no objects in m_delayedReleaseObjects
237     // and use a temp Vector for the actual releasing.
238     if (!m_delayedReleaseRecursionCount++) {
239         while (!m_delayedReleaseObjects.isEmpty()) {
240             ASSERT(m_vm->currentThreadIsHoldingAPILock());
241
242             Vector<RetainPtr<CFTypeRef>> objectsToRelease = WTFMove(m_delayedReleaseObjects);
243
244             {
245                 // We need to drop locks before calling out to arbitrary code.
246                 JSLock::DropAllLocks dropAllLocks(m_vm);
247
248                 void* context = objc_autoreleasePoolPush();
249                 objectsToRelease.clear();
250                 objc_autoreleasePoolPop(context);
251             }
252         }
253     }
254     m_delayedReleaseRecursionCount--;
255 #endif
256 }
257
258 void Heap::reportExtraMemoryAllocatedSlowCase(size_t size)
259 {
260     didAllocate(size);
261     collectIfNecessaryOrDefer();
262 }
263
264 void Heap::deprecatedReportExtraMemorySlowCase(size_t size)
265 {
266     m_deprecatedExtraMemorySize += size;
267     reportExtraMemoryAllocatedSlowCase(size);
268 }
269
270 void Heap::reportAbandonedObjectGraph()
271 {
272     // Our clients don't know exactly how much memory they
273     // are abandoning so we just guess for them.
274     size_t abandonedBytes = static_cast<size_t>(0.1 * capacity());
275
276     // We want to accelerate the next collection. Because memory has just 
277     // been abandoned, the next collection has the potential to 
278     // be more profitable. Since allocation is the trigger for collection, 
279     // we hasten the next collection by pretending that we've allocated more memory. 
280     if (m_fullActivityCallback) {
281         m_fullActivityCallback->didAllocate(
282             m_sizeAfterLastCollect - m_sizeAfterLastFullCollect + m_bytesAllocatedThisCycle + m_bytesAbandonedSinceLastFullCollect);
283     }
284     m_bytesAbandonedSinceLastFullCollect += abandonedBytes;
285 }
286
287 void Heap::protect(JSValue k)
288 {
289     ASSERT(k);
290     ASSERT(m_vm->currentThreadIsHoldingAPILock());
291
292     if (!k.isCell())
293         return;
294
295     m_protectedValues.add(k.asCell());
296 }
297
298 bool Heap::unprotect(JSValue k)
299 {
300     ASSERT(k);
301     ASSERT(m_vm->currentThreadIsHoldingAPILock());
302
303     if (!k.isCell())
304         return false;
305
306     return m_protectedValues.remove(k.asCell());
307 }
308
309 void Heap::addReference(JSCell* cell, ArrayBuffer* buffer)
310 {
311     if (m_arrayBuffers.addReference(cell, buffer)) {
312         collectIfNecessaryOrDefer();
313         didAllocate(buffer->gcSizeEstimateInBytes());
314     }
315 }
316
317 void Heap::harvestWeakReferences()
318 {
319     m_slotVisitor.harvestWeakReferences();
320 }
321
322 void Heap::finalizeUnconditionalFinalizers()
323 {
324     m_slotVisitor.finalizeUnconditionalFinalizers();
325 }
326
327 void Heap::willStartIterating()
328 {
329     m_objectSpace.willStartIterating();
330 }
331
332 void Heap::didFinishIterating()
333 {
334     m_objectSpace.didFinishIterating();
335 }
336
337 void Heap::completeAllJITPlans()
338 {
339 #if ENABLE(JIT)
340     JITWorklist::instance()->completeAllForVM(*m_vm);
341 #endif // ENABLE(JIT)
342 #if ENABLE(DFG_JIT)
343     DFG::completeAllPlansForVM(*m_vm);
344 #endif
345 }
346
347 void Heap::markRoots(double gcStartTime, void* stackOrigin, void* stackTop, MachineThreads::RegisterState& calleeSavedRegisters)
348 {
349     TimingScope markRootsTimingScope("Heap::markRoots");
350     
351     ASSERT(isValidThreadState(m_vm));
352
353     // We gather conservative roots before clearing mark bits because conservative
354     // gathering uses the mark bits to determine whether a reference is valid.
355     ConservativeRoots conservativeRoots(*this);
356     {
357         SuperSamplerScope superSamplerScope(false);
358         gatherStackRoots(conservativeRoots, stackOrigin, stackTop, calleeSavedRegisters);
359         gatherJSStackRoots(conservativeRoots);
360         gatherScratchBufferRoots(conservativeRoots);
361     }
362
363 #if ENABLE(DFG_JIT)
364     DFG::rememberCodeBlocks(*m_vm);
365 #endif
366
367 #if ENABLE(SAMPLING_PROFILER)
368     if (SamplingProfiler* samplingProfiler = m_vm->samplingProfiler()) {
369         // Note that we need to own the lock from now until we're done
370         // marking the SamplingProfiler's data because once we verify the
371         // SamplingProfiler's stack traces, we don't want it to accumulate
372         // more stack traces before we get the chance to mark it.
373         // This lock is released inside visitSamplingProfiler().
374         samplingProfiler->getLock().lock();
375         samplingProfiler->processUnverifiedStackTraces();
376     }
377 #endif // ENABLE(SAMPLING_PROFILER)
378
379     if (m_operationInProgress == FullCollection) {
380         m_opaqueRoots.clear();
381         m_slotVisitor.clearMarkStack();
382     }
383
384     clearLivenessData();
385
386     m_parallelMarkersShouldExit = false;
387
388     m_helperClient.setFunction(
389         [this] () {
390             SlotVisitor* slotVisitor;
391             {
392                 LockHolder locker(m_parallelSlotVisitorLock);
393                 if (m_availableParallelSlotVisitors.isEmpty()) {
394                     std::unique_ptr<SlotVisitor> newVisitor =
395                         std::make_unique<SlotVisitor>(*this);
396                     slotVisitor = newVisitor.get();
397                     m_parallelSlotVisitors.append(WTFMove(newVisitor));
398                 } else
399                     slotVisitor = m_availableParallelSlotVisitors.takeLast();
400             }
401
402             WTF::registerGCThread();
403
404             {
405                 ParallelModeEnabler parallelModeEnabler(*slotVisitor);
406                 slotVisitor->didStartMarking();
407                 slotVisitor->drainFromShared(SlotVisitor::SlaveDrain);
408             }
409
410             {
411                 LockHolder locker(m_parallelSlotVisitorLock);
412                 m_availableParallelSlotVisitors.append(slotVisitor);
413             }
414         });
415
416     m_slotVisitor.didStartMarking();
417     
418     HeapRootVisitor heapRootVisitor(m_slotVisitor);
419
420     {
421         SuperSamplerScope superSamplerScope(false);
422         ParallelModeEnabler enabler(m_slotVisitor);
423
424         m_slotVisitor.donateAndDrain();
425         visitExternalRememberedSet();
426         visitSmallStrings();
427         visitConservativeRoots(conservativeRoots);
428         visitProtectedObjects(heapRootVisitor);
429         visitArgumentBuffers(heapRootVisitor);
430         visitException(heapRootVisitor);
431         visitStrongHandles(heapRootVisitor);
432         visitHandleStack(heapRootVisitor);
433         visitSamplingProfiler();
434         visitShadowChicken();
435         traceCodeBlocksAndJITStubRoutines();
436         converge();
437     }
438
439     // Weak references must be marked last because their liveness depends on
440     // the liveness of the rest of the object graph.
441     visitWeakHandles(heapRootVisitor);
442
443     {
444         std::lock_guard<Lock> lock(m_markingMutex);
445         m_parallelMarkersShouldExit = true;
446         m_markingConditionVariable.notifyAll();
447     }
448     m_helperClient.finish();
449     updateObjectCounts(gcStartTime);
450     resetVisitors();
451 }
452
453 void Heap::copyBackingStores()
454 {
455     SuperSamplerScope superSamplerScope(true);
456     if (m_operationInProgress == EdenCollection)
457         m_storageSpace.startedCopying<EdenCollection>();
458     else {
459         ASSERT(m_operationInProgress == FullCollection);
460         m_storageSpace.startedCopying<FullCollection>();
461     }
462
463     if (m_storageSpace.shouldDoCopyPhase()) {
464         if (m_operationInProgress == EdenCollection) {
465             // Reset the vector to be empty, but don't throw away the backing store.
466             m_blocksToCopy.shrink(0);
467             for (CopiedBlock* block = m_storageSpace.m_newGen.fromSpace->head(); block; block = block->next())
468                 m_blocksToCopy.append(block);
469         } else {
470             ASSERT(m_operationInProgress == FullCollection);
471             WTF::copyToVector(m_storageSpace.m_blockSet, m_blocksToCopy);
472         }
473
474         ParallelVectorIterator<Vector<CopiedBlock*>> iterator(
475             m_blocksToCopy, s_blockFragmentLength);
476
477         // Note that it's safe to use the [&] capture list here, even though we're creating a task
478         // that other threads run. That's because after runFunctionInParallel() returns, the task
479         // we have created is not going to be running anymore. Hence, everything on the stack here
480         // outlives the task.
481         m_helperClient.runFunctionInParallel(
482             [&] () {
483                 CopyVisitor copyVisitor(*this);
484                 
485                 iterator.iterate(
486                     [&] (CopiedBlock* block) {
487                         if (!block->hasWorkList())
488                             return;
489                         
490                         CopyWorkList& workList = block->workList();
491                         for (CopyWorklistItem item : workList) {
492                             item.cell()->methodTable()->copyBackingStore(
493                                 item.cell(), copyVisitor, item.token());
494                         }
495                         
496                         ASSERT(!block->liveBytes());
497                         m_storageSpace.recycleEvacuatedBlock(block, m_operationInProgress);
498                     });
499             });
500     }
501     
502     m_storageSpace.doneCopying();
503 }
504
505 void Heap::gatherStackRoots(ConservativeRoots& roots, void* stackOrigin, void* stackTop, MachineThreads::RegisterState& calleeSavedRegisters)
506 {
507     m_jitStubRoutines->clearMarks();
508     m_machineThreads.gatherConservativeRoots(roots, *m_jitStubRoutines, *m_codeBlocks, stackOrigin, stackTop, calleeSavedRegisters);
509 }
510
511 void Heap::gatherJSStackRoots(ConservativeRoots& roots)
512 {
513 #if !ENABLE(JIT)
514     m_vm->interpreter->cloopStack().gatherConservativeRoots(roots, *m_jitStubRoutines, *m_codeBlocks);
515 #else
516     UNUSED_PARAM(roots);
517 #endif
518 }
519
520 void Heap::gatherScratchBufferRoots(ConservativeRoots& roots)
521 {
522 #if ENABLE(DFG_JIT)
523     m_vm->gatherConservativeRoots(roots);
524 #else
525     UNUSED_PARAM(roots);
526 #endif
527 }
528
529 void Heap::clearLivenessData()
530 {
531     if (m_operationInProgress == FullCollection)
532         m_codeBlocks->clearMarksForFullCollection();
533
534     m_objectSpace.clearNewlyAllocated();
535     m_objectSpace.clearMarks();
536 }
537
538 void Heap::visitExternalRememberedSet()
539 {
540 #if JSC_OBJC_API_ENABLED
541     scanExternalRememberedSet(*m_vm, m_slotVisitor);
542 #endif
543 }
544
545 void Heap::visitSmallStrings()
546 {
547     if (!m_vm->smallStrings.needsToBeVisited(m_operationInProgress))
548         return;
549
550     m_vm->smallStrings.visitStrongReferences(m_slotVisitor);
551     if (Options::logGC() == GCLogging::Verbose)
552         dataLog("Small strings:\n", m_slotVisitor);
553     m_slotVisitor.donateAndDrain();
554 }
555
556 void Heap::visitConservativeRoots(ConservativeRoots& roots)
557 {
558     m_slotVisitor.append(roots);
559
560     if (Options::logGC() == GCLogging::Verbose)
561         dataLog("Conservative Roots:\n", m_slotVisitor);
562
563     m_slotVisitor.donateAndDrain();
564 }
565
566 void Heap::visitCompilerWorklistWeakReferences()
567 {
568 #if ENABLE(DFG_JIT)
569     for (auto worklist : m_suspendedCompilerWorklists)
570         worklist->visitWeakReferences(m_slotVisitor);
571
572     if (Options::logGC() == GCLogging::Verbose)
573         dataLog("DFG Worklists:\n", m_slotVisitor);
574 #endif
575 }
576
577 void Heap::removeDeadCompilerWorklistEntries()
578 {
579 #if ENABLE(DFG_JIT)
580     for (auto worklist : m_suspendedCompilerWorklists)
581         worklist->removeDeadPlans(*m_vm);
582 #endif
583 }
584
585 bool Heap::isHeapSnapshotting() const
586 {
587     HeapProfiler* heapProfiler = m_vm->heapProfiler();
588     if (UNLIKELY(heapProfiler))
589         return heapProfiler->activeSnapshotBuilder();
590     return false;
591 }
592
593 struct GatherHeapSnapshotData : MarkedBlock::CountFunctor {
594     GatherHeapSnapshotData(HeapSnapshotBuilder& builder)
595         : m_builder(builder)
596     {
597     }
598
599     IterationStatus operator()(HeapCell* heapCell, HeapCell::Kind kind) const
600     {
601         if (kind == HeapCell::JSCell) {
602             JSCell* cell = static_cast<JSCell*>(heapCell);
603             cell->methodTable()->heapSnapshot(cell, m_builder);
604         }
605         return IterationStatus::Continue;
606     }
607
608     HeapSnapshotBuilder& m_builder;
609 };
610
611 void Heap::gatherExtraHeapSnapshotData(HeapProfiler& heapProfiler)
612 {
613     if (HeapSnapshotBuilder* builder = heapProfiler.activeSnapshotBuilder()) {
614         HeapIterationScope heapIterationScope(*this);
615         GatherHeapSnapshotData functor(*builder);
616         m_objectSpace.forEachLiveCell(heapIterationScope, functor);
617     }
618 }
619
620 struct RemoveDeadHeapSnapshotNodes : MarkedBlock::CountFunctor {
621     RemoveDeadHeapSnapshotNodes(HeapSnapshot& snapshot)
622         : m_snapshot(snapshot)
623     {
624     }
625
626     IterationStatus operator()(HeapCell* cell, HeapCell::Kind kind) const
627     {
628         if (kind == HeapCell::JSCell)
629             m_snapshot.sweepCell(static_cast<JSCell*>(cell));
630         return IterationStatus::Continue;
631     }
632
633     HeapSnapshot& m_snapshot;
634 };
635
636 void Heap::removeDeadHeapSnapshotNodes(HeapProfiler& heapProfiler)
637 {
638     if (HeapSnapshot* snapshot = heapProfiler.mostRecentSnapshot()) {
639         HeapIterationScope heapIterationScope(*this);
640         RemoveDeadHeapSnapshotNodes functor(*snapshot);
641         m_objectSpace.forEachDeadCell(heapIterationScope, functor);
642         snapshot->shrinkToFit();
643     }
644 }
645
646 void Heap::visitProtectedObjects(HeapRootVisitor& heapRootVisitor)
647 {
648     for (auto& pair : m_protectedValues)
649         heapRootVisitor.visit(&pair.key);
650
651     if (Options::logGC() == GCLogging::Verbose)
652         dataLog("Protected Objects:\n", m_slotVisitor);
653
654     m_slotVisitor.donateAndDrain();
655 }
656
657 void Heap::visitArgumentBuffers(HeapRootVisitor& visitor)
658 {
659     if (!m_markListSet || !m_markListSet->size())
660         return;
661
662     MarkedArgumentBuffer::markLists(visitor, *m_markListSet);
663
664     if (Options::logGC() == GCLogging::Verbose)
665         dataLog("Argument Buffers:\n", m_slotVisitor);
666
667     m_slotVisitor.donateAndDrain();
668 }
669
670 void Heap::visitException(HeapRootVisitor& visitor)
671 {
672     if (!m_vm->exception() && !m_vm->lastException())
673         return;
674
675     visitor.visit(m_vm->addressOfException());
676     visitor.visit(m_vm->addressOfLastException());
677
678     if (Options::logGC() == GCLogging::Verbose)
679         dataLog("Exceptions:\n", m_slotVisitor);
680
681     m_slotVisitor.donateAndDrain();
682 }
683
684 void Heap::visitStrongHandles(HeapRootVisitor& visitor)
685 {
686     m_handleSet.visitStrongHandles(visitor);
687
688     if (Options::logGC() == GCLogging::Verbose)
689         dataLog("Strong Handles:\n", m_slotVisitor);
690
691     m_slotVisitor.donateAndDrain();
692 }
693
694 void Heap::visitHandleStack(HeapRootVisitor& visitor)
695 {
696     m_handleStack.visit(visitor);
697
698     if (Options::logGC() == GCLogging::Verbose)
699         dataLog("Handle Stack:\n", m_slotVisitor);
700
701     m_slotVisitor.donateAndDrain();
702 }
703
704 void Heap::visitSamplingProfiler()
705 {
706 #if ENABLE(SAMPLING_PROFILER)
707     if (SamplingProfiler* samplingProfiler = m_vm->samplingProfiler()) {
708         ASSERT(samplingProfiler->getLock().isLocked());
709         samplingProfiler->visit(m_slotVisitor);
710         if (Options::logGC() == GCLogging::Verbose)
711             dataLog("Sampling Profiler data:\n", m_slotVisitor);
712
713         m_slotVisitor.donateAndDrain();
714         samplingProfiler->getLock().unlock();
715     }
716 #endif // ENABLE(SAMPLING_PROFILER)
717 }
718
719 void Heap::visitShadowChicken()
720 {
721     m_vm->shadowChicken().visitChildren(m_slotVisitor);
722 }
723
724 void Heap::traceCodeBlocksAndJITStubRoutines()
725 {
726     m_jitStubRoutines->traceMarkedStubRoutines(m_slotVisitor);
727
728     if (Options::logGC() == GCLogging::Verbose)
729         dataLog("Code Blocks and JIT Stub Routines:\n", m_slotVisitor);
730
731     m_slotVisitor.donateAndDrain();
732 }
733
734 void Heap::converge()
735 {
736     m_slotVisitor.drainFromShared(SlotVisitor::MasterDrain);
737 }
738
739 void Heap::visitWeakHandles(HeapRootVisitor& visitor)
740 {
741     while (true) {
742         m_objectSpace.visitWeakSets(visitor);
743         harvestWeakReferences();
744         visitCompilerWorklistWeakReferences();
745         if (m_slotVisitor.isEmpty())
746             break;
747
748         if (Options::logGC() == GCLogging::Verbose)
749             dataLog("Live Weak Handles:\n", m_slotVisitor);
750
751         {
752             ParallelModeEnabler enabler(m_slotVisitor);
753             m_slotVisitor.donateAndDrain();
754             m_slotVisitor.drainFromShared(SlotVisitor::MasterDrain);
755         }
756     }
757 }
758
759 void Heap::updateObjectCounts(double gcStartTime)
760 {
761     if (Options::logGC() == GCLogging::Verbose) {
762         size_t visitCount = m_slotVisitor.visitCount();
763         visitCount += threadVisitCount();
764         dataLogF("\nNumber of live Objects after GC %lu, took %.6f secs\n", static_cast<unsigned long>(visitCount), WTF::monotonicallyIncreasingTime() - gcStartTime);
765     }
766     
767     size_t bytesRemovedFromOldSpaceDueToReallocation =
768         m_storageSpace.takeBytesRemovedFromOldSpaceDueToReallocation();
769     
770     if (m_operationInProgress == FullCollection) {
771         m_totalBytesVisited = 0;
772         m_totalBytesCopied = 0;
773     } else
774         m_totalBytesCopied -= bytesRemovedFromOldSpaceDueToReallocation;
775
776     m_totalBytesVisitedThisCycle = m_slotVisitor.bytesVisited() + threadBytesVisited();
777     m_totalBytesCopiedThisCycle = m_slotVisitor.bytesCopied() + threadBytesCopied();
778     
779     m_totalBytesVisited += m_totalBytesVisitedThisCycle;
780     m_totalBytesCopied += m_totalBytesCopiedThisCycle;
781 }
782
783 void Heap::resetVisitors()
784 {
785     m_slotVisitor.reset();
786
787     for (auto& parallelVisitor : m_parallelSlotVisitors)
788         parallelVisitor->reset();
789
790     ASSERT(m_sharedMarkStack.isEmpty());
791     m_weakReferenceHarvesters.removeAll();
792 }
793
794 size_t Heap::objectCount()
795 {
796     return m_objectSpace.objectCount();
797 }
798
799 size_t Heap::extraMemorySize()
800 {
801     return m_extraMemorySize + m_deprecatedExtraMemorySize + m_arrayBuffers.size();
802 }
803
804 size_t Heap::size()
805 {
806     return m_objectSpace.size() + m_storageSpace.size() + extraMemorySize();
807 }
808
809 size_t Heap::capacity()
810 {
811     return m_objectSpace.capacity() + m_storageSpace.capacity() + extraMemorySize();
812 }
813
814 size_t Heap::protectedGlobalObjectCount()
815 {
816     size_t result = 0;
817     forEachProtectedCell(
818         [&] (JSCell* cell) {
819             if (cell->isObject() && asObject(cell)->isGlobalObject())
820                 result++;
821         });
822     return result;
823 }
824
825 size_t Heap::globalObjectCount()
826 {
827     HeapIterationScope iterationScope(*this);
828     size_t result = 0;
829     m_objectSpace.forEachLiveCell(
830         iterationScope,
831         [&] (HeapCell* heapCell, HeapCell::Kind kind) -> IterationStatus {
832             if (kind != HeapCell::JSCell)
833                 return IterationStatus::Continue;
834             JSCell* cell = static_cast<JSCell*>(heapCell);
835             if (cell->isObject() && asObject(cell)->isGlobalObject())
836                 result++;
837             return IterationStatus::Continue;
838         });
839     return result;
840 }
841
842 size_t Heap::protectedObjectCount()
843 {
844     size_t result = 0;
845     forEachProtectedCell(
846         [&] (JSCell*) {
847             result++;
848         });
849     return result;
850 }
851
852 std::unique_ptr<TypeCountSet> Heap::protectedObjectTypeCounts()
853 {
854     std::unique_ptr<TypeCountSet> result = std::make_unique<TypeCountSet>();
855     forEachProtectedCell(
856         [&] (JSCell* cell) {
857             recordType(*result, cell);
858         });
859     return result;
860 }
861
862 std::unique_ptr<TypeCountSet> Heap::objectTypeCounts()
863 {
864     std::unique_ptr<TypeCountSet> result = std::make_unique<TypeCountSet>();
865     HeapIterationScope iterationScope(*this);
866     m_objectSpace.forEachLiveCell(
867         iterationScope,
868         [&] (HeapCell* cell, HeapCell::Kind kind) -> IterationStatus {
869             if (kind == HeapCell::JSCell)
870                 recordType(*result, static_cast<JSCell*>(cell));
871             return IterationStatus::Continue;
872         });
873     return result;
874 }
875
876 void Heap::deleteAllCodeBlocks()
877 {
878     // If JavaScript is running, it's not safe to delete all JavaScript code, since
879     // we'll end up returning to deleted code.
880     RELEASE_ASSERT(!m_vm->entryScope);
881     ASSERT(m_operationInProgress == NoOperation);
882
883     completeAllJITPlans();
884
885     for (ExecutableBase* executable : m_executables)
886         executable->clearCode();
887 }
888
889 void Heap::deleteAllUnlinkedCodeBlocks()
890 {
891     for (ExecutableBase* current : m_executables) {
892         if (!current->isFunctionExecutable())
893             continue;
894         static_cast<FunctionExecutable*>(current)->unlinkedExecutable()->clearCode();
895     }
896 }
897
898 void Heap::clearUnmarkedExecutables()
899 {
900     for (unsigned i = m_executables.size(); i--;) {
901         ExecutableBase* current = m_executables[i];
902         if (isMarked(current))
903             continue;
904
905         // Eagerly dereference the Executable's JITCode in order to run watchpoint
906         // destructors. Otherwise, watchpoints might fire for deleted CodeBlocks.
907         current->clearCode();
908         std::swap(m_executables[i], m_executables.last());
909         m_executables.removeLast();
910     }
911
912     m_executables.shrinkToFit();
913 }
914
915 void Heap::deleteUnmarkedCompiledCode()
916 {
917     clearUnmarkedExecutables();
918     m_codeBlocks->deleteUnmarkedAndUnreferenced(m_operationInProgress);
919     m_jitStubRoutines->deleteUnmarkedJettisonedStubRoutines();
920 }
921
922 void Heap::addToRememberedSet(const JSCell* cell)
923 {
924     ASSERT(cell);
925     ASSERT(!Options::useConcurrentJIT() || !isCompilationThread());
926     ASSERT(cell->cellState() == CellState::OldBlack);
927     // Indicate that this object is grey and that it's one of the following:
928     // - A re-greyed object during a concurrent collection.
929     // - An old remembered object.
930     // "OldGrey" doesn't tell us which of these things is true, but we usually treat the two cases the
931     // same.
932     cell->setCellState(CellState::OldGrey);
933     m_slotVisitor.appendToMarkStack(const_cast<JSCell*>(cell));
934 }
935
936 void Heap::collectAllGarbage()
937 {
938     SuperSamplerScope superSamplerScope(false);
939     if (!m_isSafeToCollect)
940         return;
941
942     collectWithoutAnySweep(FullCollection);
943
944     DeferGCForAWhile deferGC(*this);
945     if (UNLIKELY(Options::useImmortalObjects()))
946         sweeper()->willFinishSweeping();
947     else {
948         m_objectSpace.sweep();
949         m_objectSpace.shrink();
950     }
951     ASSERT(m_blockSnapshot.isEmpty());
952
953     sweepAllLogicallyEmptyWeakBlocks();
954 }
955
956 void Heap::collect(HeapOperation collectionType)
957 {
958     SuperSamplerScope superSamplerScope(false);
959     if (!m_isSafeToCollect)
960         return;
961
962     collectWithoutAnySweep(collectionType);
963
964     DeferGCForAWhile deferGC(*this);
965     m_objectSpace.sweepLargeAllocations();
966 }
967
968 NEVER_INLINE void Heap::collectWithoutAnySweep(HeapOperation collectionType)
969 {
970     void* stackTop;
971     ALLOCATE_AND_GET_REGISTER_STATE(registers);
972
973     collectImpl(collectionType, wtfThreadData().stack().origin(), &stackTop, registers);
974
975     sanitizeStackForVM(m_vm);
976 }
977
978 NEVER_INLINE void Heap::collectImpl(HeapOperation collectionType, void* stackOrigin, void* stackTop, MachineThreads::RegisterState& calleeSavedRegisters)
979 {
980     TimingScope collectImplTimingScope("Heap::collectImpl");
981     
982 #if ENABLE(ALLOCATION_LOGGING)
983     dataLogF("JSC GC starting collection.\n");
984 #endif
985     
986     double before = 0;
987     if (Options::logGC()) {
988         dataLog("[GC: ", capacity() / 1024, " kb ");
989         before = currentTimeMS();
990     }
991     
992     if (vm()->typeProfiler()) {
993         DeferGCForAWhile awhile(*this);
994         vm()->typeProfilerLog()->processLogEntries(ASCIILiteral("GC"));
995     }
996
997 #if ENABLE(JIT)
998     {
999         DeferGCForAWhile awhile(*this);
1000         JITWorklist::instance()->completeAllForVM(*m_vm);
1001     }
1002 #endif // ENABLE(JIT)
1003
1004     vm()->shadowChicken().update(*vm(), vm()->topCallFrame);
1005
1006     RELEASE_ASSERT(!m_deferralDepth);
1007     ASSERT(vm()->currentThreadIsHoldingAPILock());
1008     RELEASE_ASSERT(vm()->atomicStringTable() == wtfThreadData().atomicStringTable());
1009     ASSERT(m_isSafeToCollect);
1010     RELEASE_ASSERT(m_operationInProgress == NoOperation);
1011
1012     suspendCompilerThreads();
1013     willStartCollection(collectionType);
1014
1015     double gcStartTime = WTF::monotonicallyIncreasingTime();
1016     if (m_verifier) {
1017         // Verify that live objects from the last GC cycle haven't been corrupted by
1018         // mutators before we begin this new GC cycle.
1019         m_verifier->verify(HeapVerifier::Phase::BeforeGC);
1020
1021         m_verifier->initializeGCCycle();
1022         m_verifier->gatherLiveObjects(HeapVerifier::Phase::BeforeMarking);
1023     }
1024
1025     flushOldStructureIDTables();
1026     stopAllocation();
1027     prepareForMarking();
1028     flushWriteBarrierBuffer();
1029
1030     markRoots(gcStartTime, stackOrigin, stackTop, calleeSavedRegisters);
1031     
1032     TimingScope lateTimingScope("Heap::collectImpl after markRoots");
1033
1034     if (m_verifier) {
1035         m_verifier->gatherLiveObjects(HeapVerifier::Phase::AfterMarking);
1036         m_verifier->verify(HeapVerifier::Phase::AfterMarking);
1037     }
1038
1039     if (vm()->typeProfiler())
1040         vm()->typeProfiler()->invalidateTypeSetCache();
1041
1042     reapWeakHandles();
1043     pruneStaleEntriesFromWeakGCMaps();
1044     sweepArrayBuffers();
1045     snapshotMarkedSpace();
1046     copyBackingStores();
1047     finalizeUnconditionalFinalizers();
1048     removeDeadCompilerWorklistEntries();
1049     deleteUnmarkedCompiledCode();
1050     deleteSourceProviderCaches();
1051
1052     notifyIncrementalSweeper();
1053     writeBarrierCurrentlyExecutingCodeBlocks();
1054
1055     resetAllocators();
1056     updateAllocationLimits();
1057     didFinishCollection(gcStartTime);
1058     resumeCompilerThreads();
1059     
1060     if (m_verifier) {
1061         m_verifier->trimDeadObjects();
1062         m_verifier->verify(HeapVerifier::Phase::AfterGC);
1063     }
1064
1065     if (Options::logGC()) {
1066         double after = currentTimeMS();
1067         dataLog(after - before, " ms]\n");
1068     }
1069 }
1070
1071 void Heap::suspendCompilerThreads()
1072 {
1073 #if ENABLE(DFG_JIT)
1074     ASSERT(m_suspendedCompilerWorklists.isEmpty());
1075     for (unsigned i = DFG::numberOfWorklists(); i--;) {
1076         if (DFG::Worklist* worklist = DFG::worklistForIndexOrNull(i)) {
1077             m_suspendedCompilerWorklists.append(worklist);
1078             worklist->suspendAllThreads();
1079         }
1080     }
1081 #endif
1082 }
1083
1084 void Heap::willStartCollection(HeapOperation collectionType)
1085 {
1086     if (Options::logGC())
1087         dataLog("=> ");
1088     
1089     if (shouldDoFullCollection(collectionType)) {
1090         m_operationInProgress = FullCollection;
1091         m_shouldDoFullCollection = false;
1092         if (Options::logGC())
1093             dataLog("FullCollection, ");
1094     } else {
1095         m_operationInProgress = EdenCollection;
1096         if (Options::logGC())
1097             dataLog("EdenCollection, ");
1098     }
1099     if (m_operationInProgress == FullCollection) {
1100         m_sizeBeforeLastFullCollect = m_sizeAfterLastCollect + m_bytesAllocatedThisCycle;
1101         m_extraMemorySize = 0;
1102         m_deprecatedExtraMemorySize = 0;
1103 #if ENABLE(RESOURCE_USAGE)
1104         m_externalMemorySize = 0;
1105 #endif
1106
1107         if (m_fullActivityCallback)
1108             m_fullActivityCallback->willCollect();
1109     } else {
1110         ASSERT(m_operationInProgress == EdenCollection);
1111         m_sizeBeforeLastEdenCollect = m_sizeAfterLastCollect + m_bytesAllocatedThisCycle;
1112     }
1113
1114     if (m_edenActivityCallback)
1115         m_edenActivityCallback->willCollect();
1116
1117     for (auto* observer : m_observers)
1118         observer->willGarbageCollect();
1119 }
1120
1121 void Heap::flushOldStructureIDTables()
1122 {
1123     m_structureIDTable.flushOldTables();
1124 }
1125
1126 void Heap::flushWriteBarrierBuffer()
1127 {
1128     if (m_operationInProgress == EdenCollection) {
1129         m_writeBarrierBuffer.flush(*this);
1130         return;
1131     }
1132     m_writeBarrierBuffer.reset();
1133 }
1134
1135 void Heap::stopAllocation()
1136 {
1137     m_objectSpace.stopAllocating();
1138     if (m_operationInProgress == FullCollection)
1139         m_storageSpace.didStartFullCollection();
1140 }
1141
1142 void Heap::prepareForMarking()
1143 {
1144     m_objectSpace.prepareForMarking();
1145 }
1146
1147 void Heap::reapWeakHandles()
1148 {
1149     m_objectSpace.reapWeakSets();
1150 }
1151
1152 void Heap::pruneStaleEntriesFromWeakGCMaps()
1153 {
1154     if (m_operationInProgress != FullCollection)
1155         return;
1156     for (auto& pruneCallback : m_weakGCMaps.values())
1157         pruneCallback();
1158 }
1159
1160 void Heap::sweepArrayBuffers()
1161 {
1162     m_arrayBuffers.sweep();
1163 }
1164
1165 struct MarkedBlockSnapshotFunctor : public MarkedBlock::VoidFunctor {
1166     MarkedBlockSnapshotFunctor(Vector<MarkedBlock*>& blocks) 
1167         : m_index(0) 
1168         , m_blocks(blocks)
1169     {
1170     }
1171
1172     void operator()(MarkedBlock* block) const { m_blocks[m_index++] = block; }
1173
1174     // FIXME: This is a mutable field becaue this isn't a C++ lambda.
1175     // https://bugs.webkit.org/show_bug.cgi?id=159644
1176     mutable size_t m_index;
1177     Vector<MarkedBlock*>& m_blocks;
1178 };
1179
1180 void Heap::snapshotMarkedSpace()
1181 {
1182     // FIXME: This should probably be renamed. It's not actually snapshotting all of MarkedSpace.
1183     // This is used by IncrementalSweeper, so it only needs to snapshot blocks. However, if we ever
1184     // wanted to add other snapshotting login, we'd probably put it here.
1185     
1186     if (m_operationInProgress == EdenCollection) {
1187         m_blockSnapshot.appendVector(m_objectSpace.blocksWithNewObjects());
1188         // Sort and deduplicate the block snapshot since we might be appending to an unfinished work list.
1189         std::sort(m_blockSnapshot.begin(), m_blockSnapshot.end());
1190         m_blockSnapshot.shrink(std::unique(m_blockSnapshot.begin(), m_blockSnapshot.end()) - m_blockSnapshot.begin());
1191     } else {
1192         m_blockSnapshot.resizeToFit(m_objectSpace.blocks().set().size());
1193         MarkedBlockSnapshotFunctor functor(m_blockSnapshot);
1194         m_objectSpace.forEachBlock(functor);
1195     }
1196 }
1197
1198 void Heap::deleteSourceProviderCaches()
1199 {
1200     m_vm->clearSourceProviderCaches();
1201 }
1202
1203 void Heap::notifyIncrementalSweeper()
1204 {
1205     if (m_operationInProgress == FullCollection) {
1206         if (!m_logicallyEmptyWeakBlocks.isEmpty())
1207             m_indexOfNextLogicallyEmptyWeakBlockToSweep = 0;
1208     }
1209
1210     m_sweeper->startSweeping();
1211 }
1212
1213 void Heap::writeBarrierCurrentlyExecutingCodeBlocks()
1214 {
1215     m_codeBlocks->writeBarrierCurrentlyExecutingCodeBlocks(this);
1216 }
1217
1218 void Heap::resetAllocators()
1219 {
1220     m_objectSpace.resetAllocators();
1221 }
1222
1223 void Heap::updateAllocationLimits()
1224 {
1225     static const bool verbose = false;
1226     
1227     if (verbose) {
1228         dataLog("\n");
1229         dataLog("bytesAllocatedThisCycle = ", m_bytesAllocatedThisCycle, "\n");
1230     }
1231     
1232     // Calculate our current heap size threshold for the purpose of figuring out when we should
1233     // run another collection. This isn't the same as either size() or capacity(), though it should
1234     // be somewhere between the two. The key is to match the size calculations involved calls to
1235     // didAllocate(), while never dangerously underestimating capacity(). In extreme cases of
1236     // fragmentation, we may have size() much smaller than capacity(). Our collector sometimes
1237     // temporarily allows very high fragmentation because it doesn't defragment old blocks in copied
1238     // space.
1239     size_t currentHeapSize = 0;
1240
1241     // For marked space, we use the total number of bytes visited. This matches the logic for
1242     // MarkedAllocator's calls to didAllocate(), which effectively accounts for the total size of
1243     // objects allocated rather than blocks used. This will underestimate capacity(), and in case
1244     // of fragmentation, this may be substantial. Fortunately, marked space rarely fragments because
1245     // cells usually have a narrow range of sizes. So, the underestimation is probably OK.
1246     currentHeapSize += m_totalBytesVisited;
1247     if (verbose)
1248         dataLog("totalBytesVisited = ", m_totalBytesVisited, ", currentHeapSize = ", currentHeapSize, "\n");
1249
1250     // For copied space, we use the capacity of storage space. This is because copied space may get
1251     // badly fragmented between full collections. This arises when each eden collection evacuates
1252     // much less than one CopiedBlock's worth of stuff. It can also happen when CopiedBlocks get
1253     // pinned due to very short-lived objects. In such a case, we want to get to a full collection
1254     // sooner rather than later. If we used m_totalBytesCopied, then for for each CopiedBlock that an
1255     // eden allocation promoted, we would only deduct the one object's size from eden size. This
1256     // would mean that we could "leak" many CopiedBlocks before we did a full collection and
1257     // defragmented all of them. It would be great to use m_totalBytesCopied, but we'd need to
1258     // augment it with something that accounts for those fragmented blocks.
1259     // FIXME: Make it possible to compute heap size using m_totalBytesCopied rather than
1260     // m_storageSpace.capacity()
1261     // https://bugs.webkit.org/show_bug.cgi?id=150268
1262     ASSERT(m_totalBytesCopied <= m_storageSpace.size());
1263     currentHeapSize += m_storageSpace.capacity();
1264     if (verbose)
1265         dataLog("storageSpace.capacity() = ", m_storageSpace.capacity(), ", currentHeapSize = ", currentHeapSize, "\n");
1266
1267     // It's up to the user to ensure that extraMemorySize() ends up corresponding to allocation-time
1268     // extra memory reporting.
1269     currentHeapSize += extraMemorySize();
1270
1271     if (verbose)
1272         dataLog("extraMemorySize() = ", extraMemorySize(), ", currentHeapSize = ", currentHeapSize, "\n");
1273     
1274     if (Options::gcMaxHeapSize() && currentHeapSize > Options::gcMaxHeapSize())
1275         HeapStatistics::exitWithFailure();
1276
1277     if (m_operationInProgress == FullCollection) {
1278         // To avoid pathological GC churn in very small and very large heaps, we set
1279         // the new allocation limit based on the current size of the heap, with a
1280         // fixed minimum.
1281         m_maxHeapSize = max(minHeapSize(m_heapType, m_ramSize), proportionalHeapSize(currentHeapSize, m_ramSize));
1282         if (verbose)
1283             dataLog("Full: maxHeapSize = ", m_maxHeapSize, "\n");
1284         m_maxEdenSize = m_maxHeapSize - currentHeapSize;
1285         if (verbose)
1286             dataLog("Full: maxEdenSize = ", m_maxEdenSize, "\n");
1287         m_sizeAfterLastFullCollect = currentHeapSize;
1288         if (verbose)
1289             dataLog("Full: sizeAfterLastFullCollect = ", currentHeapSize, "\n");
1290         m_bytesAbandonedSinceLastFullCollect = 0;
1291         if (verbose)
1292             dataLog("Full: bytesAbandonedSinceLastFullCollect = ", 0, "\n");
1293     } else {
1294         ASSERT(currentHeapSize >= m_sizeAfterLastCollect);
1295         // Theoretically, we shouldn't ever scan more memory than the heap size we planned to have.
1296         // But we are sloppy, so we have to defend against the overflow.
1297         m_maxEdenSize = currentHeapSize > m_maxHeapSize ? 0 : m_maxHeapSize - currentHeapSize;
1298         if (verbose)
1299             dataLog("Eden: maxEdenSize = ", m_maxEdenSize, "\n");
1300         m_sizeAfterLastEdenCollect = currentHeapSize;
1301         if (verbose)
1302             dataLog("Eden: sizeAfterLastEdenCollect = ", currentHeapSize, "\n");
1303         double edenToOldGenerationRatio = (double)m_maxEdenSize / (double)m_maxHeapSize;
1304         double minEdenToOldGenerationRatio = 1.0 / 3.0;
1305         if (edenToOldGenerationRatio < minEdenToOldGenerationRatio)
1306             m_shouldDoFullCollection = true;
1307         // This seems suspect at first, but what it does is ensure that the nursery size is fixed.
1308         m_maxHeapSize += currentHeapSize - m_sizeAfterLastCollect;
1309         if (verbose)
1310             dataLog("Eden: maxHeapSize = ", m_maxHeapSize, "\n");
1311         m_maxEdenSize = m_maxHeapSize - currentHeapSize;
1312         if (verbose)
1313             dataLog("Eden: maxEdenSize = ", m_maxEdenSize, "\n");
1314         if (m_fullActivityCallback) {
1315             ASSERT(currentHeapSize >= m_sizeAfterLastFullCollect);
1316             m_fullActivityCallback->didAllocate(currentHeapSize - m_sizeAfterLastFullCollect);
1317         }
1318     }
1319
1320     m_sizeAfterLastCollect = currentHeapSize;
1321     if (verbose)
1322         dataLog("sizeAfterLastCollect = ", m_sizeAfterLastCollect, "\n");
1323     m_bytesAllocatedThisCycle = 0;
1324
1325     if (Options::logGC())
1326         dataLog(currentHeapSize / 1024, " kb, ");
1327 }
1328
1329 void Heap::didFinishCollection(double gcStartTime)
1330 {
1331     double gcEndTime = WTF::monotonicallyIncreasingTime();
1332     HeapOperation operation = m_operationInProgress;
1333     if (m_operationInProgress == FullCollection)
1334         m_lastFullGCLength = gcEndTime - gcStartTime;
1335     else
1336         m_lastEdenGCLength = gcEndTime - gcStartTime;
1337
1338 #if ENABLE(RESOURCE_USAGE)
1339     ASSERT(externalMemorySize() <= extraMemorySize());
1340 #endif
1341
1342     if (Options::recordGCPauseTimes())
1343         HeapStatistics::recordGCPauseTime(gcStartTime, gcEndTime);
1344
1345     if (Options::useZombieMode())
1346         zombifyDeadObjects();
1347
1348     if (Options::dumpObjectStatistics())
1349         HeapStatistics::dumpObjectStatistics(this);
1350
1351     if (HeapProfiler* heapProfiler = m_vm->heapProfiler()) {
1352         gatherExtraHeapSnapshotData(*heapProfiler);
1353         removeDeadHeapSnapshotNodes(*heapProfiler);
1354     }
1355
1356     RELEASE_ASSERT(m_operationInProgress == EdenCollection || m_operationInProgress == FullCollection);
1357     m_operationInProgress = NoOperation;
1358
1359     for (auto* observer : m_observers)
1360         observer->didGarbageCollect(operation);
1361 }
1362
1363 void Heap::resumeCompilerThreads()
1364 {
1365 #if ENABLE(DFG_JIT)
1366     for (auto worklist : m_suspendedCompilerWorklists)
1367         worklist->resumeAllThreads();
1368     m_suspendedCompilerWorklists.clear();
1369 #endif
1370 }
1371
1372 void Heap::setFullActivityCallback(PassRefPtr<FullGCActivityCallback> activityCallback)
1373 {
1374     m_fullActivityCallback = activityCallback;
1375 }
1376
1377 void Heap::setEdenActivityCallback(PassRefPtr<EdenGCActivityCallback> activityCallback)
1378 {
1379     m_edenActivityCallback = activityCallback;
1380 }
1381
1382 GCActivityCallback* Heap::fullActivityCallback()
1383 {
1384     return m_fullActivityCallback.get();
1385 }
1386
1387 GCActivityCallback* Heap::edenActivityCallback()
1388 {
1389     return m_edenActivityCallback.get();
1390 }
1391
1392 void Heap::setIncrementalSweeper(std::unique_ptr<IncrementalSweeper> sweeper)
1393 {
1394     m_sweeper = WTFMove(sweeper);
1395 }
1396
1397 IncrementalSweeper* Heap::sweeper()
1398 {
1399     return m_sweeper.get();
1400 }
1401
1402 void Heap::setGarbageCollectionTimerEnabled(bool enable)
1403 {
1404     if (m_fullActivityCallback)
1405         m_fullActivityCallback->setEnabled(enable);
1406     if (m_edenActivityCallback)
1407         m_edenActivityCallback->setEnabled(enable);
1408 }
1409
1410 void Heap::didAllocate(size_t bytes)
1411 {
1412     if (m_edenActivityCallback)
1413         m_edenActivityCallback->didAllocate(m_bytesAllocatedThisCycle + m_bytesAbandonedSinceLastFullCollect);
1414     m_bytesAllocatedThisCycle += bytes;
1415 }
1416
1417 bool Heap::isValidAllocation(size_t)
1418 {
1419     if (!isValidThreadState(m_vm))
1420         return false;
1421
1422     if (m_operationInProgress != NoOperation)
1423         return false;
1424     
1425     return true;
1426 }
1427
1428 void Heap::addFinalizer(JSCell* cell, Finalizer finalizer)
1429 {
1430     WeakSet::allocate(cell, &m_finalizerOwner, reinterpret_cast<void*>(finalizer)); // Balanced by FinalizerOwner::finalize().
1431 }
1432
1433 void Heap::FinalizerOwner::finalize(Handle<Unknown> handle, void* context)
1434 {
1435     HandleSlot slot = handle.slot();
1436     Finalizer finalizer = reinterpret_cast<Finalizer>(context);
1437     finalizer(slot->asCell());
1438     WeakSet::deallocate(WeakImpl::asWeakImpl(slot));
1439 }
1440
1441 void Heap::addExecutable(ExecutableBase* executable)
1442 {
1443     m_executables.append(executable);
1444 }
1445
1446 void Heap::collectAllGarbageIfNotDoneRecently()
1447 {
1448     if (!m_fullActivityCallback) {
1449         collectAllGarbage();
1450         return;
1451     }
1452
1453     if (m_fullActivityCallback->didSyncGCRecently()) {
1454         // A synchronous GC was already requested recently so we merely accelerate next collection.
1455         reportAbandonedObjectGraph();
1456         return;
1457     }
1458
1459     m_fullActivityCallback->setDidSyncGCRecently();
1460     collectAllGarbage();
1461 }
1462
1463 class Zombify : public MarkedBlock::VoidFunctor {
1464 public:
1465     inline void visit(HeapCell* cell) const
1466     {
1467         void** current = reinterpret_cast<void**>(cell);
1468
1469         // We want to maintain zapped-ness because that's how we know if we've called 
1470         // the destructor.
1471         if (cell->isZapped())
1472             current++;
1473
1474         void* limit = static_cast<void*>(reinterpret_cast<char*>(cell) + cell->cellSize());
1475         for (; current < limit; current++)
1476             *current = zombifiedBits;
1477     }
1478     IterationStatus operator()(HeapCell* cell, HeapCell::Kind) const
1479     {
1480         visit(cell);
1481         return IterationStatus::Continue;
1482     }
1483 };
1484
1485 void Heap::zombifyDeadObjects()
1486 {
1487     // Sweep now because destructors will crash once we're zombified.
1488     m_objectSpace.zombifySweep();
1489     HeapIterationScope iterationScope(*this);
1490     m_objectSpace.forEachDeadCell(iterationScope, Zombify());
1491 }
1492
1493 void Heap::flushWriteBarrierBuffer(JSCell* cell)
1494 {
1495     m_writeBarrierBuffer.flush(*this);
1496     m_writeBarrierBuffer.add(cell);
1497 }
1498
1499 bool Heap::shouldDoFullCollection(HeapOperation requestedCollectionType) const
1500 {
1501     if (!Options::useGenerationalGC())
1502         return true;
1503
1504     switch (requestedCollectionType) {
1505     case EdenCollection:
1506         return false;
1507     case FullCollection:
1508         return true;
1509     case AnyCollection:
1510         return m_shouldDoFullCollection;
1511     default:
1512         RELEASE_ASSERT_NOT_REACHED();
1513         return false;
1514     }
1515     RELEASE_ASSERT_NOT_REACHED();
1516     return false;
1517 }
1518
1519 void Heap::addLogicallyEmptyWeakBlock(WeakBlock* block)
1520 {
1521     m_logicallyEmptyWeakBlocks.append(block);
1522 }
1523
1524 void Heap::sweepAllLogicallyEmptyWeakBlocks()
1525 {
1526     if (m_logicallyEmptyWeakBlocks.isEmpty())
1527         return;
1528
1529     m_indexOfNextLogicallyEmptyWeakBlockToSweep = 0;
1530     while (sweepNextLogicallyEmptyWeakBlock()) { }
1531 }
1532
1533 bool Heap::sweepNextLogicallyEmptyWeakBlock()
1534 {
1535     if (m_indexOfNextLogicallyEmptyWeakBlockToSweep == WTF::notFound)
1536         return false;
1537
1538     WeakBlock* block = m_logicallyEmptyWeakBlocks[m_indexOfNextLogicallyEmptyWeakBlockToSweep];
1539
1540     block->sweep();
1541     if (block->isEmpty()) {
1542         std::swap(m_logicallyEmptyWeakBlocks[m_indexOfNextLogicallyEmptyWeakBlockToSweep], m_logicallyEmptyWeakBlocks.last());
1543         m_logicallyEmptyWeakBlocks.removeLast();
1544         WeakBlock::destroy(*this, block);
1545     } else
1546         m_indexOfNextLogicallyEmptyWeakBlockToSweep++;
1547
1548     if (m_indexOfNextLogicallyEmptyWeakBlockToSweep >= m_logicallyEmptyWeakBlocks.size()) {
1549         m_indexOfNextLogicallyEmptyWeakBlockToSweep = WTF::notFound;
1550         return false;
1551     }
1552
1553     return true;
1554 }
1555
1556 size_t Heap::threadVisitCount()
1557 {       
1558     unsigned long result = 0;
1559     for (auto& parallelVisitor : m_parallelSlotVisitors)
1560         result += parallelVisitor->visitCount();
1561     return result;
1562 }
1563
1564 size_t Heap::threadBytesVisited()
1565 {       
1566     size_t result = 0;
1567     for (auto& parallelVisitor : m_parallelSlotVisitors)
1568         result += parallelVisitor->bytesVisited();
1569     return result;
1570 }
1571
1572 size_t Heap::threadBytesCopied()
1573 {       
1574     size_t result = 0;
1575     for (auto& parallelVisitor : m_parallelSlotVisitors)
1576         result += parallelVisitor->bytesCopied();
1577     return result;
1578 }
1579
1580 void Heap::forEachCodeBlockImpl(const ScopedLambda<bool(CodeBlock*)>& func)
1581 {
1582     // We don't know the full set of CodeBlocks until compilation has terminated.
1583     completeAllJITPlans();
1584
1585     return m_codeBlocks->iterate(func);
1586 }
1587
1588 } // namespace JSC