Changeset 126354 in webkit


Ignore:
Timestamp:
Aug 22, 2012 2:49:16 PM (12 years ago)
Author:
mhahnenberg@apple.com
Message:

Separate MarkStackThreadSharedData from MarkStack
​https://bugs.webkit.org/show_bug.cgi?id=94294

Reviewed by Filip Pizlo.

MarkStackThreadSharedData is soon going to have data to allow for a parallel copying
mode too, so to separate our concerns we should split it out into its own set of files
and rename it to GCThreadSharedData. For now this is purely a cosmetic refactoring.

  • CMakeLists.txt:
  • GNUmakefile.list.am:
  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • Target.pri:
  • heap/GCThreadSharedData.cpp: Added.

(JSC):
(JSC::GCThreadSharedData::resetChildren):
(JSC::GCThreadSharedData::childVisitCount):
(JSC::GCThreadSharedData::markingThreadMain):
(JSC::GCThreadSharedData::markingThreadStartFunc):
(JSC::GCThreadSharedData::GCThreadSharedData):
(JSC::GCThreadSharedData::~GCThreadSharedData):
(JSC::GCThreadSharedData::reset):

  • heap/GCThreadSharedData.h: Added.

(JSC):
(GCThreadSharedData):

  • heap/Heap.h:

(Heap):

  • heap/ListableHandler.h:

(ListableHandler):

  • heap/MarkStack.cpp:

(JSC::MarkStack::MarkStack):
(JSC::MarkStack::~MarkStack):

  • heap/MarkStack.h:

(JSC):
(MarkStack):
(JSC::MarkStack::sharedData):

  • heap/MarkStackInlineMethods.h: Added.

(JSC):
(JSC::MarkStack::append):
(JSC::MarkStack::appendUnbarrieredPointer):
(JSC::MarkStack::appendUnbarrieredValue):
(JSC::MarkStack::internalAppend):
(JSC::MarkStack::addWeakReferenceHarvester):
(JSC::MarkStack::addUnconditionalFinalizer):
(JSC::MarkStack::addOpaqueRoot):
(JSC::MarkStack::containsOpaqueRoot):
(JSC::MarkStack::opaqueRootCount):

  • heap/SlotVisitor.h:

(JSC):
(SlotVisitor):
(JSC::SlotVisitor::SlotVisitor):

Location:
trunk/Source/JavaScriptCore
Files:
3 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/CMakeLists.txt

    r126228 r126354  
    108108    heap/ConservativeRoots.cpp
    109109    heap/DFGCodeBlocks.cpp
     110    heap/GCThreadSharedData.cpp
    110111    heap/HandleSet.cpp
    111112    heap/HandleStack.cpp

  • trunk/Source/JavaScriptCore/ChangeLog

    r126294 r126354  
     12012-08-22  Mark Hahnenberg  <mhahnenberg@apple.com>
     2
     3        Separate MarkStackThreadSharedData from MarkStack
     4        https://bugs.webkit.org/show_bug.cgi?id=94294
     5
     6        Reviewed by Filip Pizlo.
     7
     8        MarkStackThreadSharedData is soon going to have data to allow for a parallel copying
     9        mode too, so to separate our concerns we should split it out into its own set of files
     10        and rename it to GCThreadSharedData. For now this is purely a cosmetic refactoring.
     11
     12        * CMakeLists.txt:
     13        * GNUmakefile.list.am:
     14        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
     15        * JavaScriptCore.xcodeproj/project.pbxproj:
     16        * Target.pri:
     17        * heap/GCThreadSharedData.cpp: Added.
     18        (JSC):
     19        (JSC::GCThreadSharedData::resetChildren):
     20        (JSC::GCThreadSharedData::childVisitCount):
     21        (JSC::GCThreadSharedData::markingThreadMain):
     22        (JSC::GCThreadSharedData::markingThreadStartFunc):
     23        (JSC::GCThreadSharedData::GCThreadSharedData):
     24        (JSC::GCThreadSharedData::~GCThreadSharedData):
     25        (JSC::GCThreadSharedData::reset):
     26        * heap/GCThreadSharedData.h: Added.
     27        (JSC):
     28        (GCThreadSharedData):
     29        * heap/Heap.h:
     30        (Heap):
     31        * heap/ListableHandler.h:
     32        (ListableHandler):
     33        * heap/MarkStack.cpp:
     34        (JSC::MarkStack::MarkStack):
     35        (JSC::MarkStack::~MarkStack):
     36        * heap/MarkStack.h:
     37        (JSC):
     38        (MarkStack):
     39        (JSC::MarkStack::sharedData):
     40        * heap/MarkStackInlineMethods.h: Added.
     41        (JSC):
     42        (JSC::MarkStack::append):
     43        (JSC::MarkStack::appendUnbarrieredPointer):
     44        (JSC::MarkStack::appendUnbarrieredValue):
     45        (JSC::MarkStack::internalAppend):
     46        (JSC::MarkStack::addWeakReferenceHarvester):
     47        (JSC::MarkStack::addUnconditionalFinalizer):
     48        (JSC::MarkStack::addOpaqueRoot):
     49        (JSC::MarkStack::containsOpaqueRoot):
     50        (JSC::MarkStack::opaqueRootCount):
     51        * heap/SlotVisitor.h:
     52        (JSC):
     53        (SlotVisitor):
     54        (JSC::SlotVisitor::SlotVisitor):
     55
    1562012-08-22  Gabor Ballabas  <gaborb@inf.u-szeged.hu>
    257

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

    r126228 r126354  
    274274        Source/JavaScriptCore/heap/BlockAllocator.cpp \
    275275        Source/JavaScriptCore/heap/BlockAllocator.h \
     276    Source/JavaScriptCore/heap/GCThreadSharedData.cpp \
     277    Source/JavaScriptCore/heap/GCThreadSharedData.h \
    276278        Source/JavaScriptCore/heap/Heap.cpp \
    277279        Source/JavaScriptCore/heap/Heap.h \
    … …  
    285287        Source/JavaScriptCore/heap/MarkStack.cpp \
    286288        Source/JavaScriptCore/heap/MarkStack.h \
     289    Source/JavaScriptCore/heap/MarkStackInlineMethods.h \
    287290        Source/JavaScriptCore/heap/HeapRootVisitor.h \
    288291        Source/JavaScriptCore/heap/MarkedAllocator.cpp \

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj

    r126228 r126354  
    23272327                        </File>
    23282328                        <File
     2329                                RelativePath="..\..\heap\GCThreadSharedData.cpp"
     2330                                >
     2331                        </File>
     2332                        <File
     2333                        RelativePath="..\..\heap\GCThreadSharedData.h"
     2334                        >
     2335                        </File>
     2336                        <File
    23292337                                RelativePath="..\..\heap\Heap.cpp"
    23302338                                >
    … …  
    23882396                        <File
    23892397                                RelativePath="..\..\heap\MarkStack.h"
     2398                                >
     2399                        </File>
     2400                        <File
     2401                                RelativePath="..\..\heap\MarkStackInlineMethods.h"
    23902402                                >
    23912403                        </File>

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

    r126228 r126354  
    691691                BCFD8C920EEB2EE700283848 /* JumpTable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCFD8C900EEB2EE700283848 /* JumpTable.cpp */; };
    692692                BCFD8C930EEB2EE700283848 /* JumpTable.h in Headers */ = {isa = PBXBuildFile; fileRef = BCFD8C910EEB2EE700283848 /* JumpTable.h */; };
     693                C21122E115DD9AB300790E3A /* GCThreadSharedData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C21122DE15DD9AB300790E3A /* GCThreadSharedData.cpp */; };
     694                C21122E215DD9AB300790E3A /* GCThreadSharedData.h in Headers */ = {isa = PBXBuildFile; fileRef = C21122DF15DD9AB300790E3A /* GCThreadSharedData.h */; settings = {ATTRIBUTES = (Private, ); }; };
     695                C21122E315DD9AB300790E3A /* MarkStackInlineMethods.h in Headers */ = {isa = PBXBuildFile; fileRef = C21122E015DD9AB300790E3A /* MarkStackInlineMethods.h */; settings = {ATTRIBUTES = (Private, ); }; };
    693696                C22B31B9140577D700DB475A /* SamplingCounter.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F77008E1402FDD60078EB39 /* SamplingCounter.h */; settings = {ATTRIBUTES = (Private, ); }; };
    694697                C240305514B404E60079EB64 /* CopiedSpace.cpp in Sources */ = {isa = PBXBuildFile; fileRef = C240305314B404C90079EB64 /* CopiedSpace.cpp */; };
    … …  
    14481451                BCFD8C900EEB2EE700283848 /* JumpTable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JumpTable.cpp; sourceTree = "<group>"; };
    14491452                BCFD8C910EEB2EE700283848 /* JumpTable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JumpTable.h; sourceTree = "<group>"; };
     1453                C21122DE15DD9AB300790E3A /* GCThreadSharedData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GCThreadSharedData.cpp; sourceTree = "<group>"; };
     1454                C21122DF15DD9AB300790E3A /* GCThreadSharedData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GCThreadSharedData.h; sourceTree = "<group>"; };
     1455                C21122E015DD9AB300790E3A /* MarkStackInlineMethods.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MarkStackInlineMethods.h; sourceTree = "<group>"; };
    14501456                C240305314B404C90079EB64 /* CopiedSpace.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CopiedSpace.cpp; sourceTree = "<group>"; };
    14511457                C25F8BCB157544A900245B71 /* IncrementalSweeper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IncrementalSweeper.cpp; sourceTree = "<group>"; };
    … …  
    17731779                        isa = PBXGroup;
    17741780                        children = (
     1781                                C21122DE15DD9AB300790E3A /* GCThreadSharedData.cpp */,
     1782                                C21122DF15DD9AB300790E3A /* GCThreadSharedData.h */,
     1783                                C21122E015DD9AB300790E3A /* MarkStackInlineMethods.h */,
    17751784                                C2E526BB1590EF000054E48D /* HeapTimer.cpp */,
    17761785                                C2E526BC1590EF000054E48D /* HeapTimer.h */,
    … …  
    25142523                                C2EAD2FC14F0249800A4B159 /* CopiedAllocator.h in Headers */,
    25152524                                C2B916C214DA014E00CBAC86 /* MarkedAllocator.h in Headers */,
     2525                                C21122E215DD9AB300790E3A /* GCThreadSharedData.h in Headers */,
    25162526                                C2E526BE1590EF000054E48D /* HeapTimer.h in Headers */,
     2527                                C21122E315DD9AB300790E3A /* MarkStackInlineMethods.h in Headers */,
    25172528                                C25F8BCE157544A900245B71 /* IncrementalSweeper.h in Headers */,
    25182529                                BC18C3E60E16F5CD00B34460 /* ArrayConstructor.h in Headers */,
    … …  
    34863497                                0F63944015C75F1D006A597C /* DFGStructureCheckHoistingPhase.cpp in Sources */,
    34873498                                0F63945415D07055006A597C /* ArrayProfile.cpp in Sources */,
     3499                                C21122E115DD9AB300790E3A /* GCThreadSharedData.cpp in Sources */,
    34883500                        );
    34893501                        runOnlyForDeploymentPostprocessing = 0;

  • trunk/Source/JavaScriptCore/Target.pri

    r125873 r126354  
    8080    heap/HandleStack.cpp \
    8181    heap/BlockAllocator.cpp \
     82    heap/GCThreadSharedData.cpp \
    8283    heap/Heap.cpp \
    8384    heap/HeapTimer.cpp \

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

    r124265 r126354  
    2525#include "BlockAllocator.h"
    2626#include "DFGCodeBlocks.h"
     27#include "GCThreadSharedData.h"
    2728#include "HandleSet.h"
    2829#include "HandleStack.h"
    … …  
    7576    public:
    7677        friend class JIT;
    77         friend class MarkStackThreadSharedData;
     78        friend class GCThreadSharedData;
    7879        static Heap* heap(const JSValue); // 0 for immediate values
    7980        static Heap* heap(const JSCell*);
    … …  
    232233        MachineThreads m_machineThreads;
    233234       
    234         MarkStackThreadSharedData m_sharedData;
     235        GCThreadSharedData m_sharedData;
    235236        SlotVisitor m_slotVisitor;
    236237

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

    r120151 r126354  
    5353    // Allow these classes to use ListableHandler::List.
    5454    friend class MarkStack;
    55     friend class MarkStackThreadSharedData;
     55    friend class GCThreadSharedData;
    5656    friend class SlotVisitor;
    5757   

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

    r123690 r126354  
    2626#include "config.h"
    2727#include "MarkStack.h"
     28#include "MarkStackInlineMethods.h"
    2829
    2930#include "CopiedSpace.h"
    … …  
    224225}
    225226
    226 #if ENABLE(PARALLEL_GC)
    227 void MarkStackThreadSharedData::resetChildren()
    228 {
    229     for (unsigned i = 0; i < m_markingThreadsMarkStack.size(); ++i)
    230         m_markingThreadsMarkStack[i]->reset();
    231 }
    232 
    233 size_t MarkStackThreadSharedData::childVisitCount()
    234 {       
    235     unsigned long result = 0;
    236     for (unsigned i = 0; i < m_markingThreadsMarkStack.size(); ++i)
    237         result += m_markingThreadsMarkStack[i]->visitCount();
    238     return result;
    239 }
    240 
    241 void MarkStackThreadSharedData::markingThreadMain(SlotVisitor* slotVisitor)
    242 {
    243     WTF::registerGCThread();
    244     {
    245         ParallelModeEnabler enabler(*slotVisitor);
    246         slotVisitor->drainFromShared(SlotVisitor::SlaveDrain);
    247     }
    248     delete slotVisitor;
    249 }
    250 
    251 void MarkStackThreadSharedData::markingThreadStartFunc(void* myVisitor)
    252 {               
    253     SlotVisitor* slotVisitor = static_cast<SlotVisitor*>(myVisitor);
    254 
    255     slotVisitor->sharedData().markingThreadMain(slotVisitor);
    256 }
    257 #endif
    258 
    259 MarkStackThreadSharedData::MarkStackThreadSharedData(JSGlobalData* globalData)
    260     : m_globalData(globalData)
    261     , m_copiedSpace(&globalData->heap.m_storageSpace)
     227MarkStack::MarkStack(GCThreadSharedData& shared)
     228    : m_stack(shared.m_segmentAllocator)
     229#if !ASSERT_DISABLED
     230    , m_isCheckingForDefaultMarkViolation(false)
     231    , m_isDraining(false)
     232#endif
     233    , m_visitCount(0)
     234    , m_isInParallelMode(false)
     235    , m_shared(shared)
    262236    , m_shouldHashConst(false)
    263     , m_sharedMarkStack(m_segmentAllocator)
    264     , m_numberOfActiveParallelMarkers(0)
    265     , m_parallelMarkersShouldExit(false)
    266 {
    267 #if ENABLE(PARALLEL_GC)
    268     for (unsigned i = 1; i < Options::numberOfGCMarkers(); ++i) {
    269         SlotVisitor* slotVisitor = new SlotVisitor(*this);
    270         m_markingThreadsMarkStack.append(slotVisitor);
    271         m_markingThreads.append(createThread(markingThreadStartFunc, slotVisitor, "JavaScriptCore::Marking"));
    272         ASSERT(m_markingThreads.last());
    273     }
    274 #endif
    275 }
    276 
    277 MarkStackThreadSharedData::~MarkStackThreadSharedData()
    278 {
    279 #if ENABLE(PARALLEL_GC)   
    280     // Destroy our marking threads.
    281     {
    282         MutexLocker locker(m_markingLock);
    283         m_parallelMarkersShouldExit = true;
    284         m_markingCondition.broadcast();
    285     }
    286     for (unsigned i = 0; i < m_markingThreads.size(); ++i)
    287         waitForThreadCompletion(m_markingThreads[i]);
    288 #endif
    289 }
    290    
    291 void MarkStackThreadSharedData::reset()
    292 {
    293     ASSERT(!m_numberOfActiveParallelMarkers);
    294     ASSERT(!m_parallelMarkersShouldExit);
    295     ASSERT(m_sharedMarkStack.isEmpty());
    296    
    297 #if ENABLE(PARALLEL_GC)
    298     m_segmentAllocator.shrinkReserve();
    299     m_opaqueRoots.clear();
    300 #else
    301     ASSERT(m_opaqueRoots.isEmpty());
    302 #endif
    303     m_weakReferenceHarvesters.removeAll();
    304 
    305     if (m_shouldHashConst) {
    306         m_globalData->resetNewStringsSinceLastHashConst();
    307         m_shouldHashConst = false;
    308     }
     237{
     238}
     239
     240MarkStack::~MarkStack()
     241{
     242    ASSERT(m_stack.isEmpty());
    309243}
    310244

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

    r123690 r126354  
    7575    class JSGlobalData;
    7676    class MarkStack;
     77    class GCThreadSharedData;
    7778    class ParallelModeEnabler;
    7879    class Register;
    … …  
    193194    };
    194195
    195     class MarkStackThreadSharedData {
    196     public:
    197         MarkStackThreadSharedData(JSGlobalData*);
    198         ~MarkStackThreadSharedData();
    199        
    200         void reset();
    201 
    202 #if ENABLE(PARALLEL_GC)
    203         void resetChildren();
    204         size_t childVisitCount();
    205         size_t childDupStrings();
    206 #endif
    207    
    208     private:
    209         friend class MarkStack;
    210         friend class SlotVisitor;
    211 
    212 #if ENABLE(PARALLEL_GC)
    213         void markingThreadMain(SlotVisitor*);
    214         static void markingThreadStartFunc(void* heap);
    215 #endif
    216 
    217         JSGlobalData* m_globalData;
    218         CopiedSpace* m_copiedSpace;
    219        
    220         MarkStackSegmentAllocator m_segmentAllocator;
    221        
    222         bool m_shouldHashConst;
    223 
    224         Vector<ThreadIdentifier> m_markingThreads;
    225         Vector<MarkStack*> m_markingThreadsMarkStack;
    226        
    227         Mutex m_markingLock;
    228         ThreadCondition m_markingCondition;
    229         MarkStackArray m_sharedMarkStack;
    230         unsigned m_numberOfActiveParallelMarkers;
    231         bool m_parallelMarkersShouldExit;
    232 
    233         Mutex m_opaqueRootsLock;
    234         HashSet<void*> m_opaqueRoots;
    235 
    236         ListableHandler<WeakReferenceHarvester>::List m_weakReferenceHarvesters;
    237         ListableHandler<UnconditionalFinalizer>::List m_unconditionalFinalizers;
    238     };
    239 
    240196    class MarkStack {
    241197        WTF_MAKE_NONCOPYABLE(MarkStack);
    … …  
    243199
    244200    public:
    245         MarkStack(MarkStackThreadSharedData&);
     201        MarkStack(GCThreadSharedData&);
    246202        ~MarkStack();
    247203
    … …  
    260216        int opaqueRootCount();
    261217
    262         MarkStackThreadSharedData& sharedData() { return m_shared; }
     218        GCThreadSharedData& sharedData() { return m_shared; }
    263219        bool isEmpty() { return m_stack.isEmpty(); }
    264220
    … …  
    272228#endif
    273229
    274         void addWeakReferenceHarvester(WeakReferenceHarvester* weakReferenceHarvester)
    275         {
    276             m_shared.m_weakReferenceHarvesters.addThreadSafe(weakReferenceHarvester);
    277         }
    278        
    279         void addUnconditionalFinalizer(UnconditionalFinalizer* unconditionalFinalizer)
    280         {
    281             m_shared.m_unconditionalFinalizers.addThreadSafe(unconditionalFinalizer);
    282         }
     230        void addWeakReferenceHarvester(WeakReferenceHarvester*);
     231        void addUnconditionalFinalizer(UnconditionalFinalizer*);
    283232
    284233#if ENABLE(OBJECT_MARK_LOGGING)
    … …  
    329278        bool m_isInParallelMode;
    330279       
    331         MarkStackThreadSharedData& m_shared;
     280        GCThreadSharedData& m_shared;
    332281
    333282        bool m_shouldHashConst; // Local per-thread copy of shared flag for performance reasons
    … …  
    339288#endif
    340289    };
    341 
    342     inline MarkStack::MarkStack(MarkStackThreadSharedData& shared)
    343         : m_stack(shared.m_segmentAllocator)
    344 #if !ASSERT_DISABLED
    345         , m_isCheckingForDefaultMarkViolation(false)
    346         , m_isDraining(false)
    347 #endif
    348         , m_visitCount(0)
    349         , m_isInParallelMode(false)
    350         , m_shared(shared)
    351         , m_shouldHashConst(false)
    352     {
    353     }
    354 
    355     inline MarkStack::~MarkStack()
    356     {
    357         ASSERT(m_stack.isEmpty());
    358     }
    359 
    360     inline void MarkStack::addOpaqueRoot(void* root)
    361     {
    362 #if ENABLE(PARALLEL_GC)
    363         if (Options::numberOfGCMarkers() == 1) {
    364             // Put directly into the shared HashSet.
    365             m_shared.m_opaqueRoots.add(root);
    366             return;
    367         }
    368         // Put into the local set, but merge with the shared one every once in
    369         // a while to make sure that the local sets don't grow too large.
    370         mergeOpaqueRootsIfProfitable();
    371         m_opaqueRoots.add(root);
    372 #else
    373         m_opaqueRoots.add(root);
    374 #endif
    375     }
    376 
    377     inline bool MarkStack::containsOpaqueRoot(void* root)
    378     {
    379         ASSERT(!m_isInParallelMode);
    380 #if ENABLE(PARALLEL_GC)
    381         ASSERT(m_opaqueRoots.isEmpty());
    382         return m_shared.m_opaqueRoots.contains(root);
    383 #else
    384         return m_opaqueRoots.contains(root);
    385 #endif
    386     }
    387 
    388     inline int MarkStack::opaqueRootCount()
    389     {
    390         ASSERT(!m_isInParallelMode);
    391 #if ENABLE(PARALLEL_GC)
    392         ASSERT(m_opaqueRoots.isEmpty());
    393         return m_shared.m_opaqueRoots.size();
    394 #else
    395         return m_opaqueRoots.size();
    396 #endif
    397     }
    398290
    399291    inline void MarkStackArray::append(const JSCell* cell)
    … …  
    430322    }
    431323
    432     ALWAYS_INLINE void MarkStack::append(JSValue* slot, size_t count)
    433     {
    434         for (size_t i = 0; i < count; ++i) {
    435             JSValue& value = slot[i];
    436             if (!value)
    437                 continue;
    438             internalAppend(value);
    439         }
    440     }
    441 
    442     template<typename T>
    443     inline void MarkStack::appendUnbarrieredPointer(T** slot)
    444     {
    445         ASSERT(slot);
    446         JSCell* cell = *slot;
    447         if (cell)
    448             internalAppend(cell);
    449     }
    450    
    451     ALWAYS_INLINE void MarkStack::append(JSValue* slot)
    452     {
    453         ASSERT(slot);
    454         internalAppend(*slot);
    455     }
    456 
    457     ALWAYS_INLINE void MarkStack::appendUnbarrieredValue(JSValue* slot)
    458     {
    459         ASSERT(slot);
    460         internalAppend(*slot);
    461     }
    462 
    463     ALWAYS_INLINE void MarkStack::append(JSCell** slot)
    464     {
    465         ASSERT(slot);
    466         internalAppend(*slot);
    467     }
    468 
    469     ALWAYS_INLINE void MarkStack::internalAppend(JSValue value)
    470     {
    471         ASSERT(value);
    472         if (!value.isCell())
    473             return;
    474         internalAppend(value.asCell());
    475     }
    476 
    477324    class ParallelModeEnabler {
    478325    public:

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

    r123690 r126354  
    2929#include "CopiedSpace.h"
    3030#include "MarkStack.h"
     31#include "MarkStackInlineMethods.h"
    3132
    3233namespace JSC {
    3334
    3435class Heap;
     36class GCThreadSharedData;
    3537
    3638class SlotVisitor : public MarkStack {
    3739    friend class HeapRootVisitor;
    3840public:
    39     SlotVisitor(MarkStackThreadSharedData&);
     41    SlotVisitor(GCThreadSharedData&);
    4042
    4143    void donate()
    … …  
    8688};
    8789
    88 inline SlotVisitor::SlotVisitor(MarkStackThreadSharedData& shared)
     90inline SlotVisitor::SlotVisitor(GCThreadSharedData& shared)
    8991    : MarkStack(shared)
    9092{
Note: See TracChangeset for help on using the changeset viewer.