Changeset 190151 in webkit for trunk/Source/JavaScriptCore/heap/Heap.h

Timestamp:

Sep 22, 2015, 6:35:49 PM (10 years ago)

Author:

[email protected]

Message:

GCThreadSharedData is just a bad way of saying Heap
​https://bugs.webkit.org/show_bug.cgi?id=149435

Reviewed by Mark Lam.

This removes the GCThreadSharedData class and moves its members into Heap. This is a net
simplification since GCThreadSharedData had a 1-to-1 mapping to Heap and the two classes had a
vast contract with a lot of interdependencies. Heap would call a lot of GCThreadSharedData
methods; now a lot of those are inlined since they were only called from the one place in Heap.
This makes it a lot easier to see what is going on. For example, you no longer have to look at
code in two places (Heap and GCThreadSharedData) to figure out the timing and synchronization
of GC phases - all of that code is in Heap now.

This also removes weird indirections in other places. It used to be that a lot of GC helper
classes woud have a pointer to GCThreadSharedData, and then would use that to get to Heap, VM,
and the visitors. Now these helpers just point to Heap.

I think that GCThreadSharedData was only useful for defining the set of things that we need to
know to collect garbage. That's how we decided if something would go into GCThreadSharedData
instead of Heap. But I think that separating things into multiple classes usually makes the
code less hackable, so there should be a very high bar for doing this in a way that produces a
1-to-1 mapping between two classes - where one instance of one of the classes is always paired
with exactly one instance of the other class and vice-versa.

• CMakeLists.txt:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
• JavaScriptCore.xcodeproj/project.pbxproj:
• heap/CopiedSpace.h:
• heap/CopyVisitor.cpp:

(JSC::CopyVisitor::CopyVisitor):
(JSC::CopyVisitor::copyFromShared):

• heap/CopyVisitor.h:
• heap/CopyVisitorInlines.h:

(JSC::CopyVisitor::allocateNewSpaceSlow):
(JSC::CopyVisitor::startCopying):
(JSC::CopyVisitor::doneCopying):
(JSC::CopyVisitor::didCopy):

• heap/GCThread.cpp:

(JSC::GCThread::GCThread):
(JSC::GCThread::waitForNextPhase):
(JSC::GCThread::gcThreadMain):

• heap/GCThread.h:
• heap/GCThreadSharedData.cpp: Removed.
• heap/GCThreadSharedData.h: Removed.
• heap/Heap.cpp:

(JSC::Heap::Heap):
(JSC::Heap::~Heap):
(JSC::Heap::isPagedOut):
(JSC::Heap::markRoots):
(JSC::Heap::copyBackingStores):
(JSC::Heap::updateObjectCounts):
(JSC::Heap::resetVisitors):
(JSC::Heap::objectCount):
(JSC::Heap::sweepNextLogicallyEmptyWeakBlock):
(JSC::Heap::threadVisitCount):
(JSC::Heap::threadBytesVisited):
(JSC::Heap::threadBytesCopied):
(JSC::Heap::startNextPhase):
(JSC::Heap::endCurrentPhase):

• heap/Heap.h:
• heap/HeapInlines.h:

(JSC::Heap::unregisterWeakGCMap):
(JSC::Heap::getNextBlocksToCopy):

• heap/ListableHandler.h:
• heap/SlotVisitor.cpp:

(JSC::SlotVisitor::SlotVisitor):
(JSC::SlotVisitor::didStartMarking):
(JSC::SlotVisitor::reset):
(JSC::SlotVisitor::donateKnownParallel):
(JSC::SlotVisitor::drain):
(JSC::SlotVisitor::drainFromShared):
(JSC::SlotVisitor::mergeOpaqueRoots):
(JSC::SlotVisitor::harvestWeakReferences):
(JSC::SlotVisitor::finalizeUnconditionalFinalizers):

• heap/SlotVisitor.h:

(JSC::SlotVisitor::markStack):
(JSC::SlotVisitor::isEmpty):
(JSC::SlotVisitor::sharedData): Deleted.

• heap/SlotVisitorInlines.h:

(JSC::SlotVisitor::addWeakReferenceHarvester):
(JSC::SlotVisitor::addUnconditionalFinalizer):
(JSC::SlotVisitor::addOpaqueRoot):
(JSC::SlotVisitor::containsOpaqueRoot):
(JSC::SlotVisitor::containsOpaqueRootTriState):
(JSC::SlotVisitor::opaqueRootCount):
(JSC::SlotVisitor::mergeOpaqueRootsIfNecessary):
(JSC::SlotVisitor::copyLater):
(JSC::SlotVisitor::heap):
(JSC::SlotVisitor::vm):

File:

• trunk/Source/JavaScriptCore/heap/Heap.h (modified) (8 diffs)

trunk/Source/JavaScriptCore/heap/Heap.h

@@ -2 +2 @@
  *  Copyright (C) 1999-2000 Harri Porten ([email protected])
  *  Copyright (C) 2001 Peter Kelly ([email protected])
- *  Copyright (C) 2003-2009, 2013-2014 Apple Inc. All rights reserved.
+ *  Copyright (C) 2003-2009, 2013-2015 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
@@ -27 +27 @@
 #include "CopyVisitor.h"
 #include "GCIncomingRefCountedSet.h"
-#include "GCThreadSharedData.h"
+#include "GCThread.h"
 #include "HandleSet.h"
 #include "HandleStack.h"
 #include "HeapOperation.h"
 #include "JITStubRoutineSet.h"
+#include "ListableHandler.h"
 #include "MarkedAllocator.h"
 #include "MarkedBlock.h"
@@ -39 +40 @@
 #include "SlotVisitor.h"
 #include "StructureIDTable.h"
+#include "UnconditionalFinalizer.h"
 #include "WeakHandleOwner.h"
+#include "WeakReferenceHarvester.h"
 #include "WriteBarrierBuffer.h"
 #include "WriteBarrierSupport.h"
@@ -86 +89 @@
     friend class JIT;
     friend class DFG::SpeculativeJIT;
-    friend class GCThreadSharedData;
     static Heap* heap(const JSValue); // 0 for immediate values
     static Heap* heap(const JSCell*);
@@ -244 +246 @@
     friend class GCAwareJITStubRoutine;
     friend class GCLogging;
+    friend class GCThread;
     friend class HandleSet;
     friend class HeapVerifier;
@@ -340 +343 @@
     void decrementDeferralDepthAndGCIfNeeded();
 
+    size_t threadVisitCount();
+    size_t threadBytesVisited();
+    size_t threadBytesCopied();
+    size_t threadDupStrings();
+
+    void getNextBlocksToCopy(size_t&, size_t&);
+    void startNextPhase(GCPhase);
+    void endCurrentPhase();
+
     const HeapType m_heapType;
     const size_t m_ramSize;
@@ -372 +384 @@
     MachineThreads m_machineThreads;
     
-    GCThreadSharedData m_sharedData;
     SlotVisitor m_slotVisitor;
     CopyVisitor m_copyVisitor;
@@ -410 +421 @@
 
     HashMap<void*, std::function<void()>> m_weakGCMaps;
+
+    bool m_shouldHashCons { false };
+
+    Vector<GCThread*> m_gcThreads;
+
+    Lock m_markingMutex;
+    Condition m_markingConditionVariable;
+    MarkStackArray m_sharedMarkStack;
+    unsigned m_numberOfActiveParallelMarkers { 0 };
+    bool m_parallelMarkersShouldExit { false };
+
+    Lock m_opaqueRootsMutex;
+    HashSet<void*> m_opaqueRoots;
+
+    Lock m_copyLock;
+    Vector<CopiedBlock*> m_blocksToCopy;
+    size_t m_copyIndex { 0 };
+    static const size_t s_blockFragmentLength = 32;
+
+    Lock m_phaseMutex;
+    Condition m_phaseConditionVariable;
+    Condition m_activityConditionVariable;
+    unsigned m_numberOfActiveGCThreads { 0 };
+    bool m_gcThreadsShouldWait { false };
+    GCPhase m_currentPhase { NoPhase };
+
+    ListableHandler<WeakReferenceHarvester>::List m_weakReferenceHarvesters;
+    ListableHandler<UnconditionalFinalizer>::List m_unconditionalFinalizers;
 };