Changeset 166278 in webkit


Ignore:
Timestamp:
Mar 25, 2014 7:37:51 PM (10 years ago)
Author:
mhahnenberg@apple.com
Message:

Add HeapInlines
​https://bugs.webkit.org/show_bug.cgi?id=130759

Reviewed by Filip Pizlo.

(JSC::MarkedBlockSnapshotFunctor::MarkedBlockSnapshotFunctor):
(JSC::MarkedBlockSnapshotFunctor::operator()):

  • heap/Heap.h: Also reindented while we're here.

(JSC::Heap::writeBarrierBuffer):
(JSC::Heap::vm):
(JSC::Heap::objectSpace):
(JSC::Heap::machineThreads):
(JSC::Heap::operationInProgress):
(JSC::Heap::allocatorForObjectWithoutDestructor):
(JSC::Heap::allocatorForObjectWithNormalDestructor):
(JSC::Heap::allocatorForObjectWithImmortalStructureDestructor):
(JSC::Heap::storageAllocator):
(JSC::Heap::notifyIsSafeToCollect):
(JSC::Heap::isSafeToCollect):
(JSC::Heap::handleSet):
(JSC::Heap::handleStack):
(JSC::Heap::lastFullGCLength):
(JSC::Heap::lastEdenGCLength):
(JSC::Heap::increaseLastFullGCLength):
(JSC::Heap::sizeBeforeLastEdenCollection):
(JSC::Heap::sizeAfterLastEdenCollection):
(JSC::Heap::sizeBeforeLastFullCollection):
(JSC::Heap::sizeAfterLastFullCollection):
(JSC::Heap::jitStubRoutines):
(JSC::Heap::isDeferred):
(JSC::Heap::structureIDTable):
(JSC::Heap::removeCodeBlock):

  • heap/HeapInlines.h: Added.

(JSC::Heap::shouldCollect):
(JSC::Heap::isBusy):
(JSC::Heap::isCollecting):
(JSC::Heap::heap):
(JSC::Heap::isLive):
(JSC::Heap::isInRememberedSet):
(JSC::Heap::isMarked):
(JSC::Heap::testAndSetMarked):
(JSC::Heap::setMarked):
(JSC::Heap::isWriteBarrierEnabled):
(JSC::Heap::writeBarrier):
(JSC::Heap::reportExtraMemoryCost):
(JSC::Heap::forEachProtectedCell):
(JSC::Heap::forEachCodeBlock):
(JSC::Heap::allocateWithNormalDestructor):
(JSC::Heap::allocateWithImmortalStructureDestructor):
(JSC::Heap::allocateWithoutDestructor):
(JSC::Heap::tryAllocateStorage):
(JSC::Heap::tryReallocateStorage):
(JSC::Heap::ascribeOwner):
(JSC::Heap::blockAllocator):
(JSC::Heap::releaseSoon):
(JSC::Heap::incrementDeferralDepth):
(JSC::Heap::decrementDeferralDepth):
(JSC::Heap::collectIfNecessaryOrDefer):
(JSC::Heap::decrementDeferralDepthAndGCIfNeeded):
(JSC::Heap::markListSet):

  • runtime/JSCInlines.h:
Location:
trunk/Source/JavaScriptCore
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r166276 r166278  
     12014-03-25  Mark Hahnenberg  <mhahnenberg@apple.com>
     2
     3        Add HeapInlines
     4        https://bugs.webkit.org/show_bug.cgi?id=130759
     5
     6        Reviewed by Filip Pizlo.
     7
     8        * GNUmakefile.list.am:
     9        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
     10        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
     11        * JavaScriptCore.xcodeproj/project.pbxproj:
     12        * heap/Heap.cpp:
     13        (JSC::MarkedBlockSnapshotFunctor::MarkedBlockSnapshotFunctor):
     14        (JSC::MarkedBlockSnapshotFunctor::operator()):
     15        * heap/Heap.h: Also reindented while we're here.
     16        (JSC::Heap::writeBarrierBuffer):
     17        (JSC::Heap::vm):
     18        (JSC::Heap::objectSpace):
     19        (JSC::Heap::machineThreads):
     20        (JSC::Heap::operationInProgress):
     21        (JSC::Heap::allocatorForObjectWithoutDestructor):
     22        (JSC::Heap::allocatorForObjectWithNormalDestructor):
     23        (JSC::Heap::allocatorForObjectWithImmortalStructureDestructor):
     24        (JSC::Heap::storageAllocator):
     25        (JSC::Heap::notifyIsSafeToCollect):
     26        (JSC::Heap::isSafeToCollect):
     27        (JSC::Heap::handleSet):
     28        (JSC::Heap::handleStack):
     29        (JSC::Heap::lastFullGCLength):
     30        (JSC::Heap::lastEdenGCLength):
     31        (JSC::Heap::increaseLastFullGCLength):
     32        (JSC::Heap::sizeBeforeLastEdenCollection):
     33        (JSC::Heap::sizeAfterLastEdenCollection):
     34        (JSC::Heap::sizeBeforeLastFullCollection):
     35        (JSC::Heap::sizeAfterLastFullCollection):
     36        (JSC::Heap::jitStubRoutines):
     37        (JSC::Heap::isDeferred):
     38        (JSC::Heap::structureIDTable):
     39        (JSC::Heap::removeCodeBlock):
     40        * heap/HeapInlines.h: Added.
     41        (JSC::Heap::shouldCollect):
     42        (JSC::Heap::isBusy):
     43        (JSC::Heap::isCollecting):
     44        (JSC::Heap::heap):
     45        (JSC::Heap::isLive):
     46        (JSC::Heap::isInRememberedSet):
     47        (JSC::Heap::isMarked):
     48        (JSC::Heap::testAndSetMarked):
     49        (JSC::Heap::setMarked):
     50        (JSC::Heap::isWriteBarrierEnabled):
     51        (JSC::Heap::writeBarrier):
     52        (JSC::Heap::reportExtraMemoryCost):
     53        (JSC::Heap::forEachProtectedCell):
     54        (JSC::Heap::forEachCodeBlock):
     55        (JSC::Heap::allocateWithNormalDestructor):
     56        (JSC::Heap::allocateWithImmortalStructureDestructor):
     57        (JSC::Heap::allocateWithoutDestructor):
     58        (JSC::Heap::tryAllocateStorage):
     59        (JSC::Heap::tryReallocateStorage):
     60        (JSC::Heap::ascribeOwner):
     61        (JSC::Heap::blockAllocator):
     62        (JSC::Heap::releaseSoon):
     63        (JSC::Heap::incrementDeferralDepth):
     64        (JSC::Heap::decrementDeferralDepth):
     65        (JSC::Heap::collectIfNecessaryOrDefer):
     66        (JSC::Heap::decrementDeferralDepthAndGCIfNeeded):
     67        (JSC::Heap::markListSet):
     68        * runtime/JSCInlines.h:
     69
    1702014-03-25  Filip Pizlo  <fpizlo@apple.com>
    271

  • trunk/Source/JavaScriptCore/GNUmakefile.list.am

    r165940 r166278  
    595595        Source/JavaScriptCore/heap/Heap.cpp \
    596596        Source/JavaScriptCore/heap/Heap.h \
     597        Source/JavaScriptCore/heap/HeapInlines.h \
    597598        Source/JavaScriptCore/heap/HeapIterationScope.h \
    598599        Source/JavaScriptCore/heap/HeapOperation.h \

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj

    r166263 r166278  
    10641064    <ClInclude Include="..\heap\Heap.h" />
    10651065    <ClInclude Include="..\heap\HeapBlock.h" />
     1066    <ClInclude Include="..\heap\HeapInlines.h" />
    10661067    <ClInclude Include="..\heap\HeapOperation.h" />
    10671068    <ClInclude Include="..\heap\HeapRootVisitor.h" />

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters

    r165940 r166278  
    17401740      <Filter>heap</Filter>
    17411741    </ClInclude>
     1742    <ClInclude Include="..\heap\HeapInlines.h">
     1743      <Filter>heap</Filter>
     1744    </ClInclude>
    17421745    <ClInclude Include="..\heap\HeapOperation.h">
    17431746      <Filter>heap</Filter>

  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r166263 r166278  
    14361436                C2CF39C116E15A8100DD69BE /* JSAPIWrapperObject.mm in Sources */ = {isa = PBXBuildFile; fileRef = C2CF39BF16E15A8100DD69BE /* JSAPIWrapperObject.mm */; };
    14371437                C2CF39C216E15A8100DD69BE /* JSAPIWrapperObject.h in Headers */ = {isa = PBXBuildFile; fileRef = C2CF39C016E15A8100DD69BE /* JSAPIWrapperObject.h */; };
     1438                C2DA778318E259990066FCB6 /* HeapInlines.h in Headers */ = {isa = PBXBuildFile; fileRef = C2DA778218E259990066FCB6 /* HeapInlines.h */; settings = {ATTRIBUTES = (Private, ); }; };
    14381439                C2DF442F1707AC0100A5CA96 /* SuperRegion.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C2DF442D1707AC0100A5CA96 /* SuperRegion.cpp */; };
    14391440                C2DF44301707AC0100A5CA96 /* SuperRegion.h in Headers */ = {isa = PBXBuildFile; fileRef = C2DF442E1707AC0100A5CA96 /* SuperRegion.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    29772978                C2CF39BF16E15A8100DD69BE /* JSAPIWrapperObject.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = JSAPIWrapperObject.mm; sourceTree = "<group>"; };
    29782979                C2CF39C016E15A8100DD69BE /* JSAPIWrapperObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSAPIWrapperObject.h; sourceTree = "<group>"; };
     2980                C2DA778218E259990066FCB6 /* HeapInlines.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = HeapInlines.h; sourceTree = "<group>"; };
    29792981                C2DF442D1707AC0100A5CA96 /* SuperRegion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SuperRegion.cpp; sourceTree = "<group>"; };
    29802982                C2DF442E1707AC0100A5CA96 /* SuperRegion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SuperRegion.h; sourceTree = "<group>"; };
    … …  
    35203522                        isa = PBXGroup;
    35213523                        children = (
     3524                                C2DA778218E259990066FCB6 /* HeapInlines.h */,
    35223525                                ADDB1F6218D77DB7009B58A8 /* OpaqueRootSet.h */,
    35233526                                2AACE63A18CA5A0300ED0191 /* GCActivityCallback.cpp */,
    … …  
    49414944                                86D3B2C410156BDE002865E7 /* ARMAssembler.h in Headers */,
    49424945                                A584032018BFFBE1005A0811 /* InspectorAgent.h in Headers */,
     4946                                C2DA778318E259990066FCB6 /* HeapInlines.h in Headers */,
    49434947                                2AACE63D18CA5A0300ED0191 /* GCActivityCallback.h in Headers */,
    49444948                                2A83638618D7D0EE0000EBCC /* EdenGCActivityCallback.h in Headers */,

  • trunk/Source/JavaScriptCore/heap/Heap.cpp

    r166099 r166278  
    10171017}
    10181018
     1019struct MarkedBlockSnapshotFunctor : public MarkedBlock::VoidFunctor {
     1020    MarkedBlockSnapshotFunctor(Vector<MarkedBlock*>& blocks)
     1021        : m_index(0)
     1022        , m_blocks(blocks)
     1023    {
     1024    }
     1025
     1026    void operator()(MarkedBlock* block) { m_blocks[m_index++] = block; }
     1027
     1028    size_t m_index;
     1029    Vector<MarkedBlock*>& m_blocks;
     1030};
     1031
    10191032void Heap::snapshotMarkedSpace()
    10201033{

  • trunk/Source/JavaScriptCore/heap/Heap.h

    r165940 r166278  
    5050namespace JSC {
    5151
    52     class CopiedSpace;
    53     class CodeBlock;
    54     class ExecutableBase;
    55     class EdenGCActivityCallback;
    56     class FullGCActivityCallback;
    57     class GCActivityCallback;
    58     class GCAwareJITStubRoutine;
    59     class GlobalCodeBlock;
    60     class Heap;
    61     class HeapRootVisitor;
    62     class IncrementalSweeper;
    63     class JITStubRoutine;
    64     class JSCell;
    65     class VM;
    66     class JSStack;
    67     class JSValue;
    68     class LiveObjectIterator;
    69     class LLIntOffsetsExtractor;
    70     class MarkedArgumentBuffer;
    71     class WeakGCHandlePool;
    72     class SlotVisitor;
    73 
    74     typedef std::pair<JSValue, WTF::String> ValueStringPair;
    75     typedef HashCountedSet<JSCell*> ProtectCountSet;
    76     typedef HashCountedSet<const char*> TypeCountSet;
    77 
    78     enum HeapType { SmallHeap, LargeHeap };
    79 
    80     class Heap {
    81         WTF_MAKE_NONCOPYABLE(Heap);
    82     public:
    83         friend class JIT;
    84         friend class DFG::SpeculativeJIT;
    85         friend class GCThreadSharedData;
    86         static Heap* heap(const JSValue); // 0 for immediate values
    87         static Heap* heap(const JSCell*);
    88 
    89         // This constant determines how many blocks we iterate between checks of our
    90         // deadline when calling Heap::isPagedOut. Decreasing it will cause us to detect
    91         // overstepping our deadline more quickly, while increasing it will cause
    92         // our scan to run faster.
    93         static const unsigned s_timeCheckResolution = 16;
    94 
    95         static bool isLive(const void*);
    96         static bool isMarked(const void*);
    97         static bool testAndSetMarked(const void*);
    98         static void setMarked(const void*);
    99 
    100         JS_EXPORT_PRIVATE void addToRememberedSet(const JSCell*);
    101         bool isInRememberedSet(const JSCell* cell) const
    102         {
    103             ASSERT(cell);
    104             ASSERT(!Options::enableConcurrentJIT() || !isCompilationThread());
    105             return MarkedBlock::blockFor(cell)->isRemembered(cell);
    106         }
    107         static bool isWriteBarrierEnabled();
    108         JS_EXPORT_PRIVATE void writeBarrier(const JSCell*);
    109         void writeBarrier(const JSCell*, JSValue);
    110         void writeBarrier(const JSCell*, JSCell*);
    111 
    112         WriteBarrierBuffer& writeBarrierBuffer() { return m_writeBarrierBuffer; }
    113         void flushWriteBarrierBuffer(JSCell*);
    114 
    115         Heap(VM*, HeapType);
    116         ~Heap();
    117         JS_EXPORT_PRIVATE void lastChanceToFinalize();
    118 
    119         VM* vm() const { return m_vm; }
    120         MarkedSpace& objectSpace() { return m_objectSpace; }
    121         MachineThreads& machineThreads() { return m_machineThreads; }
    122 
    123         JS_EXPORT_PRIVATE GCActivityCallback* fullActivityCallback();
    124         JS_EXPORT_PRIVATE GCActivityCallback* edenActivityCallback();
    125         JS_EXPORT_PRIVATE void setFullActivityCallback(PassRefPtr<FullGCActivityCallback>);
    126         JS_EXPORT_PRIVATE void setEdenActivityCallback(PassRefPtr<EdenGCActivityCallback>);
    127         JS_EXPORT_PRIVATE void setGarbageCollectionTimerEnabled(bool);
    128 
    129         JS_EXPORT_PRIVATE IncrementalSweeper* sweeper();
    130         JS_EXPORT_PRIVATE void setIncrementalSweeper(PassOwnPtr<IncrementalSweeper>);
    131 
    132         // true if collection is in progress
    133         inline bool isCollecting();
    134         inline HeapOperation operationInProgress() { return m_operationInProgress; }
    135         // true if an allocation or collection is in progress
    136         inline bool isBusy();
    137        
    138         MarkedAllocator& allocatorForObjectWithoutDestructor(size_t bytes) { return m_objectSpace.allocatorFor(bytes); }
    139         MarkedAllocator& allocatorForObjectWithNormalDestructor(size_t bytes) { return m_objectSpace.normalDestructorAllocatorFor(bytes); }
    140         MarkedAllocator& allocatorForObjectWithImmortalStructureDestructor(size_t bytes) { return m_objectSpace.immortalStructureDestructorAllocatorFor(bytes); }
    141         CopiedAllocator& storageAllocator() { return m_storageSpace.allocator(); }
    142         CheckedBoolean tryAllocateStorage(JSCell* intendedOwner, size_t, void**);
    143         CheckedBoolean tryReallocateStorage(JSCell* intendedOwner, void**, size_t, size_t);
    144         void ascribeOwner(JSCell* intendedOwner, void*);
    145 
    146         typedef void (*Finalizer)(JSCell*);
    147         JS_EXPORT_PRIVATE void addFinalizer(JSCell*, Finalizer);
    148         void addCompiledCode(ExecutableBase*);
    149 
    150         void notifyIsSafeToCollect() { m_isSafeToCollect = true; }
    151         bool isSafeToCollect() const { return m_isSafeToCollect; }
    152 
    153         JS_EXPORT_PRIVATE void collectAllGarbage();
    154         bool shouldCollect();
    155         JS_EXPORT_PRIVATE void collect(HeapOperation collectionType = AnyCollection);
    156         bool collectIfNecessaryOrDefer(); // Returns true if it did collect.
    157 
    158         void reportExtraMemoryCost(size_t cost);
    159         JS_EXPORT_PRIVATE void reportAbandonedObjectGraph();
    160 
    161         JS_EXPORT_PRIVATE void protect(JSValue);
    162         JS_EXPORT_PRIVATE bool unprotect(JSValue); // True when the protect count drops to 0.
    163        
    164         size_t extraSize(); // extra memory usage outside of pages allocated by the heap
    165         JS_EXPORT_PRIVATE size_t size();
    166         JS_EXPORT_PRIVATE size_t capacity();
    167         JS_EXPORT_PRIVATE size_t objectCount();
    168         JS_EXPORT_PRIVATE size_t globalObjectCount();
    169         JS_EXPORT_PRIVATE size_t protectedObjectCount();
    170         JS_EXPORT_PRIVATE size_t protectedGlobalObjectCount();
    171         JS_EXPORT_PRIVATE PassOwnPtr<TypeCountSet> protectedObjectTypeCounts();
    172         JS_EXPORT_PRIVATE PassOwnPtr<TypeCountSet> objectTypeCounts();
    173         void showStatistics();
    174 
    175         void pushTempSortVector(Vector<ValueStringPair, 0, UnsafeVectorOverflow>*);
    176         void popTempSortVector(Vector<ValueStringPair, 0, UnsafeVectorOverflow>*);
    177    
    178         HashSet<MarkedArgumentBuffer*>& markListSet() { if (!m_markListSet) m_markListSet = adoptPtr(new HashSet<MarkedArgumentBuffer*>); return *m_markListSet; }
    179        
    180         template<typename Functor> typename Functor::ReturnType forEachProtectedCell(Functor&);
    181         template<typename Functor> typename Functor::ReturnType forEachProtectedCell();
    182         template<typename Functor> inline void forEachCodeBlock(Functor&);
    183 
    184         HandleSet* handleSet() { return &m_handleSet; }
    185         HandleStack* handleStack() { return &m_handleStack; }
    186 
    187         void willStartIterating();
    188         void didFinishIterating();
    189         void getConservativeRegisterRoots(HashSet<JSCell*>& roots);
    190 
    191         double lastFullGCLength() const { return m_lastFullGCLength; }
    192         double lastEdenGCLength() const { return m_lastEdenGCLength; }
    193         void increaseLastFullGCLength(double amount) { m_lastFullGCLength += amount; }
    194 
    195         size_t sizeBeforeLastEdenCollection() const { return m_sizeBeforeLastEdenCollect; }
    196         size_t sizeAfterLastEdenCollection() const { return m_sizeAfterLastEdenCollect; }
    197         size_t sizeBeforeLastFullCollection() const { return m_sizeBeforeLastFullCollect; }
    198         size_t sizeAfterLastFullCollection() const { return m_sizeAfterLastFullCollect; }
    199 
    200         JS_EXPORT_PRIVATE void deleteAllCompiledCode();
    201         void deleteAllUnlinkedFunctionCode();
    202 
    203         void didAllocate(size_t);
    204         void didAbandon(size_t);
    205 
    206         bool isPagedOut(double deadline);
    207        
    208         const JITStubRoutineSet& jitStubRoutines() { return m_jitStubRoutines; }
    209        
    210         void addReference(JSCell*, ArrayBuffer*);
    211        
    212         bool isDeferred() const { return !!m_deferralDepth || Options::disableGC(); }
    213 
    214         BlockAllocator& blockAllocator();
    215         StructureIDTable& structureIDTable() { return m_structureIDTable; }
     52class CopiedSpace;
     53class CodeBlock;
     54class ExecutableBase;
     55class EdenGCActivityCallback;
     56class FullGCActivityCallback;
     57class GCActivityCallback;
     58class GCAwareJITStubRoutine;
     59class GlobalCodeBlock;
     60class Heap;
     61class HeapRootVisitor;
     62class IncrementalSweeper;
     63class JITStubRoutine;
     64class JSCell;
     65class VM;
     66class JSStack;
     67class JSValue;
     68class LiveObjectIterator;
     69class LLIntOffsetsExtractor;
     70class MarkedArgumentBuffer;
     71class WeakGCHandlePool;
     72class SlotVisitor;
     73
     74typedef std::pair<JSValue, WTF::String> ValueStringPair;
     75typedef HashCountedSet<JSCell*> ProtectCountSet;
     76typedef HashCountedSet<const char*> TypeCountSet;
     77
     78enum HeapType { SmallHeap, LargeHeap };
     79
     80class Heap {
     81    WTF_MAKE_NONCOPYABLE(Heap);
     82public:
     83    friend class JIT;
     84    friend class DFG::SpeculativeJIT;
     85    friend class GCThreadSharedData;
     86    static Heap* heap(const JSValue); // 0 for immediate values
     87    static Heap* heap(const JSCell*);
     88
     89    // This constant determines how many blocks we iterate between checks of our
     90    // deadline when calling Heap::isPagedOut. Decreasing it will cause us to detect
     91    // overstepping our deadline more quickly, while increasing it will cause
     92    // our scan to run faster.
     93    static const unsigned s_timeCheckResolution = 16;
     94
     95    static bool isLive(const void*);
     96    static bool isMarked(const void*);
     97    static bool testAndSetMarked(const void*);
     98    static void setMarked(const void*);
     99    static bool isRemembered(const void*);
     100
     101    JS_EXPORT_PRIVATE void addToRememberedSet(const JSCell*);
     102    bool isInRememberedSet(const JSCell*) const;
     103    static bool isWriteBarrierEnabled();
     104    JS_EXPORT_PRIVATE void writeBarrier(const JSCell*);
     105    void writeBarrier(const JSCell*, JSValue);
     106    void writeBarrier(const JSCell*, JSCell*);
     107
     108    WriteBarrierBuffer& writeBarrierBuffer() { return m_writeBarrierBuffer; }
     109    void flushWriteBarrierBuffer(JSCell*);
     110
     111    Heap(VM*, HeapType);
     112    ~Heap();
     113    JS_EXPORT_PRIVATE void lastChanceToFinalize();
     114
     115    VM* vm() const { return m_vm; }
     116    MarkedSpace& objectSpace() { return m_objectSpace; }
     117    MachineThreads& machineThreads() { return m_machineThreads; }
     118
     119    JS_EXPORT_PRIVATE GCActivityCallback* fullActivityCallback();
     120    JS_EXPORT_PRIVATE GCActivityCallback* edenActivityCallback();
     121    JS_EXPORT_PRIVATE void setFullActivityCallback(PassRefPtr<FullGCActivityCallback>);
     122    JS_EXPORT_PRIVATE void setEdenActivityCallback(PassRefPtr<EdenGCActivityCallback>);
     123    JS_EXPORT_PRIVATE void setGarbageCollectionTimerEnabled(bool);
     124
     125    JS_EXPORT_PRIVATE IncrementalSweeper* sweeper();
     126    JS_EXPORT_PRIVATE void setIncrementalSweeper(PassOwnPtr<IncrementalSweeper>);
     127
     128    // true if collection is in progress
     129    bool isCollecting();
     130    HeapOperation operationInProgress() { return m_operationInProgress; }
     131    // true if an allocation or collection is in progress
     132    bool isBusy();
     133   
     134    MarkedAllocator& allocatorForObjectWithoutDestructor(size_t bytes) { return m_objectSpace.allocatorFor(bytes); }
     135    MarkedAllocator& allocatorForObjectWithNormalDestructor(size_t bytes) { return m_objectSpace.normalDestructorAllocatorFor(bytes); }
     136    MarkedAllocator& allocatorForObjectWithImmortalStructureDestructor(size_t bytes) { return m_objectSpace.immortalStructureDestructorAllocatorFor(bytes); }
     137    CopiedAllocator& storageAllocator() { return m_storageSpace.allocator(); }
     138    CheckedBoolean tryAllocateStorage(JSCell* intendedOwner, size_t, void**);
     139    CheckedBoolean tryReallocateStorage(JSCell* intendedOwner, void**, size_t, size_t);
     140    void ascribeOwner(JSCell* intendedOwner, void*);
     141
     142    typedef void (*Finalizer)(JSCell*);
     143    JS_EXPORT_PRIVATE void addFinalizer(JSCell*, Finalizer);
     144    void addCompiledCode(ExecutableBase*);
     145
     146    void notifyIsSafeToCollect() { m_isSafeToCollect = true; }
     147    bool isSafeToCollect() const { return m_isSafeToCollect; }
     148
     149    JS_EXPORT_PRIVATE void collectAllGarbage();
     150    bool shouldCollect();
     151    JS_EXPORT_PRIVATE void collect(HeapOperation collectionType = AnyCollection);
     152    bool collectIfNecessaryOrDefer(); // Returns true if it did collect.
     153
     154    void reportExtraMemoryCost(size_t cost);
     155    JS_EXPORT_PRIVATE void reportAbandonedObjectGraph();
     156
     157    JS_EXPORT_PRIVATE void protect(JSValue);
     158    JS_EXPORT_PRIVATE bool unprotect(JSValue); // True when the protect count drops to 0.
     159   
     160    size_t extraSize(); // extra memory usage outside of pages allocated by the heap
     161    JS_EXPORT_PRIVATE size_t size();
     162    JS_EXPORT_PRIVATE size_t capacity();
     163    JS_EXPORT_PRIVATE size_t objectCount();
     164    JS_EXPORT_PRIVATE size_t globalObjectCount();
     165    JS_EXPORT_PRIVATE size_t protectedObjectCount();
     166    JS_EXPORT_PRIVATE size_t protectedGlobalObjectCount();
     167    JS_EXPORT_PRIVATE PassOwnPtr<TypeCountSet> protectedObjectTypeCounts();
     168    JS_EXPORT_PRIVATE PassOwnPtr<TypeCountSet> objectTypeCounts();
     169    void showStatistics();
     170
     171    void pushTempSortVector(Vector<ValueStringPair, 0, UnsafeVectorOverflow>*);
     172    void popTempSortVector(Vector<ValueStringPair, 0, UnsafeVectorOverflow>*);
     173
     174    HashSet<MarkedArgumentBuffer*>& markListSet();
     175   
     176    template<typename Functor> typename Functor::ReturnType forEachProtectedCell(Functor&);
     177    template<typename Functor> typename Functor::ReturnType forEachProtectedCell();
     178    template<typename Functor> void forEachCodeBlock(Functor&);
     179
     180    HandleSet* handleSet() { return &m_handleSet; }
     181    HandleStack* handleStack() { return &m_handleStack; }
     182
     183    void willStartIterating();
     184    void didFinishIterating();
     185    void getConservativeRegisterRoots(HashSet<JSCell*>& roots);
     186
     187    double lastFullGCLength() const { return m_lastFullGCLength; }
     188    double lastEdenGCLength() const { return m_lastEdenGCLength; }
     189    void increaseLastFullGCLength(double amount) { m_lastFullGCLength += amount; }
     190
     191    size_t sizeBeforeLastEdenCollection() const { return m_sizeBeforeLastEdenCollect; }
     192    size_t sizeAfterLastEdenCollection() const { return m_sizeAfterLastEdenCollect; }
     193    size_t sizeBeforeLastFullCollection() const { return m_sizeBeforeLastFullCollect; }
     194    size_t sizeAfterLastFullCollection() const { return m_sizeAfterLastFullCollect; }
     195
     196    JS_EXPORT_PRIVATE void deleteAllCompiledCode();
     197    void deleteAllUnlinkedFunctionCode();
     198
     199    void didAllocate(size_t);
     200    void didAbandon(size_t);
     201
     202    bool isPagedOut(double deadline);
     203   
     204    const JITStubRoutineSet& jitStubRoutines() { return m_jitStubRoutines; }
     205   
     206    void addReference(JSCell*, ArrayBuffer*);
     207   
     208    bool isDeferred() const { return !!m_deferralDepth || Options::disableGC(); }
     209
     210    BlockAllocator& blockAllocator();
     211    StructureIDTable& structureIDTable() { return m_structureIDTable; }
    216212
    217213#if USE(CF)
    … …  
    219215#endif
    220216
    221         void removeCodeBlock(CodeBlock* cb) { m_codeBlocks.remove(cb); }
    222 
    223     private:
    224         friend class CodeBlock;
    225         friend class CopiedBlock;
    226         friend class DeferGC;
    227         friend class DeferGCForAWhile;
    228         friend class DelayedReleaseScope;
    229         friend class GCAwareJITStubRoutine;
    230         friend class HandleSet;
    231         friend class JITStubRoutine;
    232         friend class LLIntOffsetsExtractor;
    233         friend class MarkedSpace;
    234         friend class MarkedAllocator;
    235         friend class MarkedBlock;
    236         friend class CopiedSpace;
    237         friend class CopyVisitor;
    238         friend class RecursiveAllocationScope;
    239         friend class SlotVisitor;
    240         friend class SuperRegion;
    241         friend class IncrementalSweeper;
    242         friend class HeapStatistics;
    243         friend class VM;
    244         friend class WeakSet;
    245         template<typename T> friend void* allocateCell(Heap&);
    246         template<typename T> friend void* allocateCell(Heap&, size_t);
    247 
    248         void* allocateWithImmortalStructureDestructor(size_t); // For use with special objects whose Structures never die.
    249         void* allocateWithNormalDestructor(size_t); // For use with objects that inherit directly or indirectly from JSDestructibleObject.
    250         void* allocateWithoutDestructor(size_t); // For use with objects without destructors.
    251 
    252         static const size_t minExtraCost = 256;
    253         static const size_t maxExtraCost = 1024 * 1024;
    254        
    255         class FinalizerOwner : public WeakHandleOwner {
    256             virtual void finalize(Handle<Unknown>, void* context) override;
    257         };
    258 
    259         JS_EXPORT_PRIVATE bool isValidAllocation(size_t);
    260         JS_EXPORT_PRIVATE void reportExtraMemoryCostSlowCase(size_t);
    261 
    262         void suspendCompilerThreads();
    263         void willStartCollection(HeapOperation collectionType);
    264         void deleteOldCode(double gcStartTime);
    265         void flushOldStructureIDTables();
    266         void flushWriteBarrierBuffer();
    267         void stopAllocation();
    268 
    269         void markRoots();
    270         void gatherStackRoots(ConservativeRoots&, void** dummy);
    271         void gatherJSStackRoots(ConservativeRoots&);
    272         void gatherScratchBufferRoots(ConservativeRoots&);
    273         void clearLivenessData();
    274         void visitSmallStrings();
    275         void visitConservativeRoots(ConservativeRoots&);
    276         void visitCompilerWorklists();
    277         void visitProtectedObjects(HeapRootVisitor&);
    278         void visitTempSortVectors(HeapRootVisitor&);
    279         void visitArgumentBuffers(HeapRootVisitor&);
    280         void visitException(HeapRootVisitor&);
    281         void visitStrongHandles(HeapRootVisitor&);
    282         void visitHandleStack(HeapRootVisitor&);
    283         void traceCodeBlocksAndJITStubRoutines();
    284         void converge();
    285         void visitWeakHandles(HeapRootVisitor&);
    286         void clearRememberedSet(Vector<const JSCell*>&);
    287         void updateObjectCounts();
    288         void resetVisitors();
    289 
    290         void reapWeakHandles();
    291         void sweepArrayBuffers();
    292         void snapshotMarkedSpace();
    293         void deleteSourceProviderCaches();
    294         void notifyIncrementalSweeper();
    295         void rememberCurrentlyExecutingCodeBlocks();
    296         void resetAllocators();
    297         void copyBackingStores();
    298         void harvestWeakReferences();
    299         void finalizeUnconditionalFinalizers();
    300         void deleteUnmarkedCompiledCode();
    301         void updateAllocationLimits();
    302         void didFinishCollection(double gcStartTime);
    303         void resumeCompilerThreads();
    304         void zombifyDeadObjects();
    305         void markDeadObjects();
    306 
    307         bool shouldDoFullCollection(HeapOperation requestedCollectionType) const;
    308         size_t sizeAfterCollect();
    309 
    310         JSStack& stack();
    311        
    312         void incrementDeferralDepth();
    313         void decrementDeferralDepth();
    314         void decrementDeferralDepthAndGCIfNeeded();
    315 
    316         const HeapType m_heapType;
    317         const size_t m_ramSize;
    318         const size_t m_minBytesPerCycle;
    319         size_t m_sizeAfterLastCollect;
    320         size_t m_sizeAfterLastFullCollect;
    321         size_t m_sizeBeforeLastFullCollect;
    322         size_t m_sizeAfterLastEdenCollect;
    323         size_t m_sizeBeforeLastEdenCollect;
    324 
    325         size_t m_bytesAllocatedThisCycle;
    326         size_t m_bytesAbandonedSinceLastFullCollect;
    327         size_t m_maxEdenSize;
    328         size_t m_maxHeapSize;
    329         bool m_shouldDoFullCollection;
    330         size_t m_totalBytesVisited;
    331         size_t m_totalBytesCopied;
    332        
    333         HeapOperation m_operationInProgress;
    334         BlockAllocator m_blockAllocator;
    335         StructureIDTable m_structureIDTable;
    336         MarkedSpace m_objectSpace;
    337         CopiedSpace m_storageSpace;
    338         GCIncomingRefCountedSet<ArrayBuffer> m_arrayBuffers;
    339         size_t m_extraMemoryUsage;
    340 
    341         HashSet<const JSCell*> m_copyingRememberedSet;
    342 
    343         ProtectCountSet m_protectedValues;
    344         Vector<Vector<ValueStringPair, 0, UnsafeVectorOverflow>*> m_tempSortingVectors;
    345         OwnPtr<HashSet<MarkedArgumentBuffer*>> m_markListSet;
    346 
    347         MachineThreads m_machineThreads;
    348        
    349         GCThreadSharedData m_sharedData;
    350         SlotVisitor m_slotVisitor;
    351         CopyVisitor m_copyVisitor;
    352 
    353         HandleSet m_handleSet;
    354         HandleStack m_handleStack;
    355         CodeBlockSet m_codeBlocks;
    356         JITStubRoutineSet m_jitStubRoutines;
    357         FinalizerOwner m_finalizerOwner;
    358        
    359         bool m_isSafeToCollect;
    360 
    361         WriteBarrierBuffer m_writeBarrierBuffer;
    362 
    363         VM* m_vm;
    364         double m_lastFullGCLength;
    365         double m_lastEdenGCLength;
    366         double m_lastCodeDiscardTime;
    367 
    368         DoublyLinkedList<ExecutableBase> m_compiledCode;
    369        
    370         RefPtr<GCActivityCallback> m_fullActivityCallback;
    371         RefPtr<GCActivityCallback> m_edenActivityCallback;
    372         OwnPtr<IncrementalSweeper> m_sweeper;
    373         Vector<MarkedBlock*> m_blockSnapshot;
    374        
    375         unsigned m_deferralDepth;
     217    void removeCodeBlock(CodeBlock* cb) { m_codeBlocks.remove(cb); }
     218
     219private:
     220    friend class CodeBlock;
     221    friend class CopiedBlock;
     222    friend class DeferGC;
     223    friend class DeferGCForAWhile;
     224    friend class DelayedReleaseScope;
     225    friend class GCAwareJITStubRoutine;
     226    friend class HandleSet;
     227    friend class JITStubRoutine;
     228    friend class LLIntOffsetsExtractor;
     229    friend class MarkedSpace;
     230    friend class MarkedAllocator;
     231    friend class MarkedBlock;
     232    friend class CopiedSpace;
     233    friend class CopyVisitor;
     234    friend class RecursiveAllocationScope;
     235    friend class SlotVisitor;
     236    friend class SuperRegion;
     237    friend class IncrementalSweeper;
     238    friend class HeapStatistics;
     239    friend class VM;
     240    friend class WeakSet;
     241    template<typename T> friend void* allocateCell(Heap&);
     242    template<typename T> friend void* allocateCell(Heap&, size_t);
     243
     244    void* allocateWithImmortalStructureDestructor(size_t); // For use with special objects whose Structures never die.
     245    void* allocateWithNormalDestructor(size_t); // For use with objects that inherit directly or indirectly from JSDestructibleObject.
     246    void* allocateWithoutDestructor(size_t); // For use with objects without destructors.
     247
     248    static const size_t minExtraCost = 256;
     249    static const size_t maxExtraCost = 1024 * 1024;
     250   
     251    class FinalizerOwner : public WeakHandleOwner {
     252        virtual void finalize(Handle<Unknown>, void* context) override;
    376253    };
    377254
    378     struct MarkedBlockSnapshotFunctor : public MarkedBlock::VoidFunctor {
    379         MarkedBlockSnapshotFunctor(Vector<MarkedBlock*>& blocks)
    380             : m_index(0)
    381             , m_blocks(blocks)
    382         {
    383         }
    384    
    385         void operator()(MarkedBlock* block) { m_blocks[m_index++] = block; }
    386    
    387         size_t m_index;
    388         Vector<MarkedBlock*>& m_blocks;
    389     };
    390 
    391     inline bool Heap::shouldCollect()
    392     {
    393         if (isDeferred())
    394             return false;
    395         if (Options::gcMaxHeapSize())
    396             return m_bytesAllocatedThisCycle > Options::gcMaxHeapSize() && m_isSafeToCollect && m_operationInProgress == NoOperation;
    397         return m_bytesAllocatedThisCycle > m_maxEdenSize && m_isSafeToCollect && m_operationInProgress == NoOperation;
    398     }
    399 
    400     bool Heap::isBusy()
    401     {
    402         return m_operationInProgress != NoOperation;
    403     }
    404 
    405     bool Heap::isCollecting()
    406     {
    407         return m_operationInProgress == FullCollection || m_operationInProgress == EdenCollection;
    408     }
    409 
    410     inline Heap* Heap::heap(const JSCell* cell)
    411     {
    412         return MarkedBlock::blockFor(cell)->heap();
    413     }
    414 
    415     inline Heap* Heap::heap(const JSValue v)
    416     {
    417         if (!v.isCell())
    418             return 0;
    419         return heap(v.asCell());
    420     }
    421 
    422     inline bool Heap::isLive(const void* cell)
    423     {
    424         return MarkedBlock::blockFor(cell)->isLiveCell(cell);
    425     }
    426 
    427     inline bool Heap::isMarked(const void* cell)
    428     {
    429         return MarkedBlock::blockFor(cell)->isMarked(cell);
    430     }
    431 
    432     inline bool Heap::testAndSetMarked(const void* cell)
    433     {
    434         return MarkedBlock::blockFor(cell)->testAndSetMarked(cell);
    435     }
    436 
    437     inline void Heap::setMarked(const void* cell)
    438     {
    439         MarkedBlock::blockFor(cell)->setMarked(cell);
    440     }
    441 
    442     inline bool Heap::isWriteBarrierEnabled()
    443     {
    444 #if ENABLE(WRITE_BARRIER_PROFILING) || ENABLE(GGC)
    445         return true;
    446 #else
    447         return false;
    448 #endif
    449     }
    450 
    451     inline void Heap::writeBarrier(const JSCell* from, JSValue to)
    452     {
    453 #if ENABLE(WRITE_BARRIER_PROFILING)
    454         WriteBarrierCounters::countWriteBarrier();
    455 #endif
    456         if (!to.isCell())
    457             return;
    458         writeBarrier(from, to.asCell());
    459     }
    460 
    461     inline void Heap::reportExtraMemoryCost(size_t cost)
    462     {
    463         if (cost > minExtraCost)
    464             reportExtraMemoryCostSlowCase(cost);
    465     }
    466 
    467     template<typename Functor> inline typename Functor::ReturnType Heap::forEachProtectedCell(Functor& functor)
    468     {
    469         for (auto& pair : m_protectedValues)
    470             functor(pair.key);
    471         m_handleSet.forEachStrongHandle(functor, m_protectedValues);
    472 
    473         return functor.returnValue();
    474     }
    475 
    476     template<typename Functor> inline typename Functor::ReturnType Heap::forEachProtectedCell()
    477     {
    478         Functor functor;
    479         return forEachProtectedCell(functor);
    480     }
    481 
    482     template<typename Functor> inline void Heap::forEachCodeBlock(Functor& functor)
    483     {
    484         return m_codeBlocks.iterate<Functor>(functor);
    485     }
    486 
    487     inline void* Heap::allocateWithNormalDestructor(size_t bytes)
    488     {
    489 #if ENABLE(ALLOCATION_LOGGING)
    490         dataLogF("JSC GC allocating %lu bytes with normal destructor.\n", bytes);
    491 #endif
    492         ASSERT(isValidAllocation(bytes));
    493         return m_objectSpace.allocateWithNormalDestructor(bytes);
    494     }
    495    
    496     inline void* Heap::allocateWithImmortalStructureDestructor(size_t bytes)
    497     {
    498 #if ENABLE(ALLOCATION_LOGGING)
    499         dataLogF("JSC GC allocating %lu bytes with immortal structure destructor.\n", bytes);
    500 #endif
    501         ASSERT(isValidAllocation(bytes));
    502         return m_objectSpace.allocateWithImmortalStructureDestructor(bytes);
    503     }
    504    
    505     inline void* Heap::allocateWithoutDestructor(size_t bytes)
    506     {
    507 #if ENABLE(ALLOCATION_LOGGING)
    508         dataLogF("JSC GC allocating %lu bytes without destructor.\n", bytes);
    509 #endif
    510         ASSERT(isValidAllocation(bytes));
    511         return m_objectSpace.allocateWithoutDestructor(bytes);
    512     }
    513    
    514     inline CheckedBoolean Heap::tryAllocateStorage(JSCell* intendedOwner, size_t bytes, void** outPtr)
    515     {
    516         CheckedBoolean result = m_storageSpace.tryAllocate(bytes, outPtr);
    517 #if ENABLE(ALLOCATION_LOGGING)
    518         dataLogF("JSC GC allocating %lu bytes of storage for %p: %p.\n", bytes, intendedOwner, *outPtr);
    519 #else
    520         UNUSED_PARAM(intendedOwner);
    521 #endif
    522         return result;
    523     }
    524    
    525     inline CheckedBoolean Heap::tryReallocateStorage(JSCell* intendedOwner, void** ptr, size_t oldSize, size_t newSize)
    526     {
    527 #if ENABLE(ALLOCATION_LOGGING)
    528         void* oldPtr = *ptr;
    529 #endif
    530         CheckedBoolean result = m_storageSpace.tryReallocate(ptr, oldSize, newSize);
    531 #if ENABLE(ALLOCATION_LOGGING)
    532         dataLogF("JSC GC reallocating %lu -> %lu bytes of storage for %p: %p -> %p.\n", oldSize, newSize, intendedOwner, oldPtr, *ptr);
    533 #else
    534         UNUSED_PARAM(intendedOwner);
    535 #endif
    536         return result;
    537     }
    538 
    539     inline void Heap::ascribeOwner(JSCell* intendedOwner, void* storage)
    540     {
    541 #if ENABLE(ALLOCATION_LOGGING)
    542         dataLogF("JSC GC ascribing %p as owner of storage %p.\n", intendedOwner, storage);
    543 #else
    544         UNUSED_PARAM(intendedOwner);
    545         UNUSED_PARAM(storage);
    546 #endif
    547     }
    548 
    549     inline BlockAllocator& Heap::blockAllocator()
    550     {
    551         return m_blockAllocator;
    552     }
    553 
    554 #if USE(CF)
    555     template <typename T>
    556     inline void Heap::releaseSoon(RetainPtr<T>&& object)
    557     {
    558         m_objectSpace.releaseSoon(std::move(object));
    559     }
    560 #endif
    561 
    562 
    563 inline void Heap::incrementDeferralDepth()
    564 {
    565     RELEASE_ASSERT(m_deferralDepth < 100); // Sanity check to make sure this doesn't get ridiculous.
    566     m_deferralDepth++;
    567 }
    568 
    569 inline void Heap::decrementDeferralDepth()
    570 {
    571     RELEASE_ASSERT(m_deferralDepth >= 1);
    572     m_deferralDepth--;
    573 }
    574 
    575 inline bool Heap::collectIfNecessaryOrDefer()
    576 {
    577     if (isDeferred())
    578         return false;
    579 
    580     if (!shouldCollect())
    581         return false;
    582 
    583     collect();
    584     return true;
    585 }
    586 
    587 inline void Heap::decrementDeferralDepthAndGCIfNeeded()
    588 {
    589     decrementDeferralDepth();
    590     collectIfNecessaryOrDefer();
    591 }
     255    JS_EXPORT_PRIVATE bool isValidAllocation(size_t);
     256    JS_EXPORT_PRIVATE void reportExtraMemoryCostSlowCase(size_t);
     257
     258    void suspendCompilerThreads();
     259    void willStartCollection(HeapOperation collectionType);
     260    void deleteOldCode(double gcStartTime);
     261    void flushOldStructureIDTables();
     262    void flushWriteBarrierBuffer();
     263    void stopAllocation();
     264
     265    void markRoots();
     266    void gatherStackRoots(ConservativeRoots&, void** dummy);
     267    void gatherJSStackRoots(ConservativeRoots&);
     268    void gatherScratchBufferRoots(ConservativeRoots&);
     269    void clearLivenessData();
     270    void visitSmallStrings();
     271    void visitConservativeRoots(ConservativeRoots&);
     272    void visitCompilerWorklists();
     273    void visitProtectedObjects(HeapRootVisitor&);
     274    void visitTempSortVectors(HeapRootVisitor&);
     275    void visitArgumentBuffers(HeapRootVisitor&);
     276    void visitException(HeapRootVisitor&);
     277    void visitStrongHandles(HeapRootVisitor&);
     278    void visitHandleStack(HeapRootVisitor&);
     279    void traceCodeBlocksAndJITStubRoutines();
     280    void converge();
     281    void visitWeakHandles(HeapRootVisitor&);
     282    void clearRememberedSet(Vector<const JSCell*>&);
     283    void updateObjectCounts();
     284    void resetVisitors();
     285
     286    void reapWeakHandles();
     287    void sweepArrayBuffers();
     288    void snapshotMarkedSpace();
     289    void deleteSourceProviderCaches();
     290    void notifyIncrementalSweeper();
     291    void rememberCurrentlyExecutingCodeBlocks();
     292    void resetAllocators();
     293    void copyBackingStores();
     294    void harvestWeakReferences();
     295    void finalizeUnconditionalFinalizers();
     296    void deleteUnmarkedCompiledCode();
     297    void updateAllocationLimits();
     298    void didFinishCollection(double gcStartTime);
     299    void resumeCompilerThreads();
     300    void zombifyDeadObjects();
     301    void markDeadObjects();
     302
     303    bool shouldDoFullCollection(HeapOperation requestedCollectionType) const;
     304    size_t sizeAfterCollect();
     305
     306    JSStack& stack();
     307   
     308    void incrementDeferralDepth();
     309    void decrementDeferralDepth();
     310    void decrementDeferralDepthAndGCIfNeeded();
     311
     312    const HeapType m_heapType;
     313    const size_t m_ramSize;
     314    const size_t m_minBytesPerCycle;
     315    size_t m_sizeAfterLastCollect;
     316    size_t m_sizeAfterLastFullCollect;
     317    size_t m_sizeBeforeLastFullCollect;
     318    size_t m_sizeAfterLastEdenCollect;
     319    size_t m_sizeBeforeLastEdenCollect;
     320
     321    size_t m_bytesAllocatedThisCycle;
     322    size_t m_bytesAbandonedSinceLastFullCollect;
     323    size_t m_maxEdenSize;
     324    size_t m_maxHeapSize;
     325    bool m_shouldDoFullCollection;
     326    size_t m_totalBytesVisited;
     327    size_t m_totalBytesCopied;
     328   
     329    HeapOperation m_operationInProgress;
     330    BlockAllocator m_blockAllocator;
     331    StructureIDTable m_structureIDTable;
     332    MarkedSpace m_objectSpace;
     333    CopiedSpace m_storageSpace;
     334    GCIncomingRefCountedSet<ArrayBuffer> m_arrayBuffers;
     335    size_t m_extraMemoryUsage;
     336
     337    HashSet<const JSCell*> m_copyingRememberedSet;
     338
     339    ProtectCountSet m_protectedValues;
     340    Vector<Vector<ValueStringPair, 0, UnsafeVectorOverflow>*> m_tempSortingVectors;
     341    OwnPtr<HashSet<MarkedArgumentBuffer*>> m_markListSet;
     342
     343    MachineThreads m_machineThreads;
     344   
     345    GCThreadSharedData m_sharedData;
     346    SlotVisitor m_slotVisitor;
     347    CopyVisitor m_copyVisitor;
     348
     349    HandleSet m_handleSet;
     350    HandleStack m_handleStack;
     351    CodeBlockSet m_codeBlocks;
     352    JITStubRoutineSet m_jitStubRoutines;
     353    FinalizerOwner m_finalizerOwner;
     354   
     355    bool m_isSafeToCollect;
     356
     357    WriteBarrierBuffer m_writeBarrierBuffer;
     358
     359    VM* m_vm;
     360    double m_lastFullGCLength;
     361    double m_lastEdenGCLength;
     362    double m_lastCodeDiscardTime;
     363
     364    DoublyLinkedList<ExecutableBase> m_compiledCode;
     365   
     366    RefPtr<GCActivityCallback> m_fullActivityCallback;
     367    RefPtr<GCActivityCallback> m_edenActivityCallback;
     368    OwnPtr<IncrementalSweeper> m_sweeper;
     369    Vector<MarkedBlock*> m_blockSnapshot;
     370   
     371    unsigned m_deferralDepth;
     372};
    592373
    593374} // namespace JSC

  • trunk/Source/JavaScriptCore/llint/LLIntEntrypoint.cpp

    r163027 r166278  
    3030
    3131#include "CodeBlock.h"
     32#include "HeapInlines.h"
    3233#include "JITCode.h"
    3334#include "JSObject.h"

  • trunk/Source/JavaScriptCore/runtime/JSCInlines.h

    r165982 r166278  
    4141#include "ExceptionHelpers.h"
    4242#include "GCIncomingRefCountedInlines.h"
     43#include "HeapInlines.h"
    4344#include "IdentifierInlines.h"
    4445#include "Interpreter.h"

  • trunk/Source/JavaScriptCore/runtime/JSObject.h

    r165603 r166278  
    3434#include "DeferGC.h"
    3535#include "Heap.h"
     36#include "HeapInlines.h"
    3637#include "IndexingHeaderInlines.h"
    3738#include "JSCell.h"
Note: See TracChangeset for help on using the changeset viewer.