Changeset 95450 in webkit


Ignore:
Timestamp:
Sep 19, 2011 11:54:33 AM (13 years ago)
Author:
oliver@apple.com
Message:

Rename NewSpace to MarkedSpace
https://bugs.webkit.org/show_bug.cgi?id=68375

Reviewed by Gavin Barraclough.

Rename NewSpace to a more accurate name, and update all uses.
This patch doesn't rename the files themselves as that will
just make the patch appear bigger than it is.

(JSC::CountFunctor::TakeIfEmpty::TakeIfEmpty):
(JSC::CountFunctor::TakeIfEmpty::operator()):
(JSC::Heap::Heap):
(JSC::Heap::reportExtraMemoryCostSlowCase):
(JSC::Heap::tryAllocate):
(JSC::Heap::allocateSlowCase):
(JSC::Heap::collect):
(JSC::Heap::canonicalizeBlocks):
(JSC::Heap::resetAllocator):
(JSC::Heap::isValidAllocation):
(JSC::Heap::shrink):

  • heap/Heap.h:

(JSC::Heap::markedSpace):
(JSC::Heap::sizeClassFor):
(JSC::Heap::allocate):

  • heap/NewSpace.cpp:

(JSC::MarkedSpace::MarkedSpace):
(JSC::MarkedSpace::addBlock):
(JSC::MarkedSpace::removeBlock):
(JSC::MarkedSpace::resetAllocator):
(JSC::MarkedSpace::canonicalizeBlocks):

  • heap/NewSpace.h:

(JSC::MarkedSpace::waterMark):
(JSC::MarkedSpace::highWaterMark):
(JSC::MarkedSpace::setHighWaterMark):
(JSC::MarkedSpace::sizeClassFor):
(JSC::MarkedSpace::allocate):
(JSC::MarkedSpace::forEachBlock):
(JSC::MarkedSpace::SizeClass::SizeClass):
(JSC::MarkedSpace::SizeClass::resetAllocator):
(JSC::MarkedSpace::SizeClass::canonicalizeBlock):

  • jit/JITInlineMethods.h:

(JSC::JIT::emitAllocateBasicJSObject):

Location:
trunk/Source/JavaScriptCore
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r95449 r95450  
     12011-09-19  Oliver Hunt  <oliver@apple.com>
     2
     3        Rename NewSpace to MarkedSpace
     4        https://bugs.webkit.org/show_bug.cgi?id=68375
     5
     6        Reviewed by Gavin Barraclough.
     7
     8        Rename NewSpace to a more accurate name, and update all uses.
     9        This patch doesn't rename the files themselves as that will
     10        just make the patch appear bigger than it is.
     11
     12        * JavaScriptCore.exp:
     13        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
     14        * heap/Heap.cpp:
     15        (JSC::CountFunctor::TakeIfEmpty::TakeIfEmpty):
     16        (JSC::CountFunctor::TakeIfEmpty::operator()):
     17        (JSC::Heap::Heap):
     18        (JSC::Heap::reportExtraMemoryCostSlowCase):
     19        (JSC::Heap::tryAllocate):
     20        (JSC::Heap::allocateSlowCase):
     21        (JSC::Heap::collect):
     22        (JSC::Heap::canonicalizeBlocks):
     23        (JSC::Heap::resetAllocator):
     24        (JSC::Heap::isValidAllocation):
     25        (JSC::Heap::shrink):
     26        * heap/Heap.h:
     27        (JSC::Heap::markedSpace):
     28        (JSC::Heap::sizeClassFor):
     29        (JSC::Heap::allocate):
     30        * heap/NewSpace.cpp:
     31        (JSC::MarkedSpace::MarkedSpace):
     32        (JSC::MarkedSpace::addBlock):
     33        (JSC::MarkedSpace::removeBlock):
     34        (JSC::MarkedSpace::resetAllocator):
     35        (JSC::MarkedSpace::canonicalizeBlocks):
     36        * heap/NewSpace.h:
     37        (JSC::MarkedSpace::waterMark):
     38        (JSC::MarkedSpace::highWaterMark):
     39        (JSC::MarkedSpace::setHighWaterMark):
     40        (JSC::MarkedSpace::sizeClassFor):
     41        (JSC::MarkedSpace::allocate):
     42        (JSC::MarkedSpace::forEachBlock):
     43        (JSC::MarkedSpace::SizeClass::SizeClass):
     44        (JSC::MarkedSpace::SizeClass::resetAllocator):
     45        (JSC::MarkedSpace::SizeClass::canonicalizeBlock):
     46        * jit/JITInlineMethods.h:
     47        (JSC::JIT::emitAllocateBasicJSObject):
     48
    1492011-09-19  Peter Rybin  <peter.rybin@gmail.com>
    250
  • trunk/Source/JavaScriptCore/JavaScriptCore.exp

    r95318 r95450  
    234234__ZN3JSC4Heap11objectCountEv
    235235__ZN3JSC4Heap16activityCallbackEv
    236 __ZN3JSC4Heap16allocateSlowCaseERNS_8NewSpace9SizeClassE
     236__ZN3JSC4Heap16allocateSlowCaseERNS_11MarkedSpace9SizeClassE
    237237__ZN3JSC4Heap16objectTypeCountsEv
    238238__ZN3JSC4Heap17collectAllGarbageEv
  • trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def

    r95321 r95450  
    6060    ?addSlowCase@Identifier@JSC@@CA?AV?$PassRefPtr@VStringImpl@WTF@@@WTF@@PAVExecState@2@PAVStringImpl@4@@Z
    6161    ?addStaticGlobals@JSGlobalObject@JSC@@IAEXPAUGlobalPropertyInfo@12@H@Z
    62     ?allocate@Heap@JSC@@QAEPAXAAUSizeClass@NewSpace@2@@Z
     62    ?allocate@Heap@JSC@@QAEPAXAAUSizeClass@MarkedSpace@2@@Z
    6363    ?allocatePropertyStorage@JSObject@JSC@@QAEXAAVJSGlobalData@2@II@Z
    64     ?allocateSlowCase@Heap@JSC@@AAEPAXAAUSizeClass@NewSpace@2@@Z
     64    ?allocateSlowCase@Heap@JSC@@AAEPAXAAUSizeClass@MarkedSpace@2@@Z
    6565    ?append@StringBuilder@WTF@@QAEXPBDI@Z
    6666    ?append@StringBuilder@WTF@@QAEXPB_WI@Z
  • trunk/Source/JavaScriptCore/heap/Heap.cpp

    r95439 r95450  
    180180    typedef MarkedBlock* ReturnType;
    181181
    182     TakeIfEmpty(NewSpace*);
     182    TakeIfEmpty(MarkedSpace*);
    183183    void operator()(MarkedBlock*);
    184184    ReturnType returnValue();
    185185
    186186private:
    187     NewSpace* m_newSpace;
     187    MarkedSpace* m_markedSpace;
    188188    DoublyLinkedList<MarkedBlock> m_empties;
    189189};
    190190
    191 inline TakeIfEmpty::TakeIfEmpty(NewSpace* newSpace)
    192     : m_newSpace(newSpace)
     191inline TakeIfEmpty::TakeIfEmpty(MarkedSpace* newSpace)
     192    : m_markedSpace(newSpace)
    193193{
    194194}
     
    199199        return;
    200200
    201     m_newSpace->removeBlock(block);
     201    m_markedSpace->removeBlock(block);
    202202    m_empties.append(block);
    203203}
     
    250250    , m_minBytesPerCycle(heapSizeForHint(heapSize))
    251251    , m_operationInProgress(NoOperation)
    252     , m_newSpace(this)
     252    , m_markedSpace(this)
    253253    , m_extraCost(0)
    254254    , m_markListSet(0)
     
    260260    , m_globalData(globalData)
    261261{
    262     m_newSpace.setHighWaterMark(m_minBytesPerCycle);
     262    m_markedSpace.setHighWaterMark(m_minBytesPerCycle);
    263263    (*m_activityCallback)();
    264264#if ENABLE(LAZY_BLOCK_FREEING)
     
    402402    // collecting more frequently as long as it stays alive.
    403403
    404     if (m_extraCost > maxExtraCost && m_extraCost > m_newSpace.highWaterMark() / 2)
     404    if (m_extraCost > maxExtraCost && m_extraCost > m_markedSpace.highWaterMark() / 2)
    405405        collectAllGarbage();
    406406    m_extraCost += cost;
    407407}
    408408
    409 inline void* Heap::tryAllocate(NewSpace::SizeClass& sizeClass)
     409inline void* Heap::tryAllocate(MarkedSpace::SizeClass& sizeClass)
    410410{
    411411    m_operationInProgress = Allocation;
    412     void* result = m_newSpace.allocate(sizeClass);
     412    void* result = m_markedSpace.allocate(sizeClass);
    413413    m_operationInProgress = NoOperation;
    414414    return result;
    415415}
    416416
    417 void* Heap::allocateSlowCase(NewSpace::SizeClass& sizeClass)
     417void* Heap::allocateSlowCase(MarkedSpace::SizeClass& sizeClass)
    418418{
    419419#if COLLECT_ON_EVERY_ALLOCATION
     
    429429    AllocationEffort allocationEffort;
    430430   
    431     if (m_newSpace.waterMark() < m_newSpace.highWaterMark() || !m_isSafeToCollect)
     431    if (m_markedSpace.waterMark() < m_markedSpace.highWaterMark() || !m_isSafeToCollect)
    432432        allocationEffort = AllocationMustSucceed;
    433433    else
     
    436436    MarkedBlock* block = allocateBlock(sizeClass.cellSize, allocationEffort);
    437437    if (block) {
    438         m_newSpace.addBlock(sizeClass, block);
     438        m_markedSpace.addBlock(sizeClass, block);
    439439        void* result = tryAllocate(sizeClass);
    440440        ASSERT(result);
     
    449449        return result;
    450450   
    451     ASSERT(m_newSpace.waterMark() < m_newSpace.highWaterMark());
    452    
    453     m_newSpace.addBlock(sizeClass, allocateBlock(sizeClass.cellSize, AllocationMustSucceed));
     451    ASSERT(m_markedSpace.waterMark() < m_markedSpace.highWaterMark());
     452   
     453    m_markedSpace.addBlock(sizeClass, allocateBlock(sizeClass.cellSize, AllocationMustSucceed));
    454454   
    455455    result = tryAllocate(sizeClass);
     
    692692    // new bytes allocated) proportion, and seems to work well in benchmarks.
    693693    size_t proportionalBytes = 2 * size();
    694     m_newSpace.setHighWaterMark(max(proportionalBytes, m_minBytesPerCycle));
     694    m_markedSpace.setHighWaterMark(max(proportionalBytes, m_minBytesPerCycle));
    695695    JAVASCRIPTCORE_GC_END();
    696696
     
    700700void Heap::canonicalizeBlocks()
    701701{
    702     m_newSpace.canonicalizeBlocks();
     702    m_markedSpace.canonicalizeBlocks();
    703703}
    704704
     
    706706{
    707707    m_extraCost = 0;
    708     m_newSpace.resetAllocator();
     708    m_markedSpace.resetAllocator();
    709709}
    710710
     
    724724        return false;
    725725
    726     if (bytes > NewSpace::maxCellSize)
     726    if (bytes > MarkedSpace::maxCellSize)
    727727        return false;
    728728
     
    786786{
    787787    // We record a temporary list of empties to avoid modifying m_blocks while iterating it.
    788     TakeIfEmpty takeIfEmpty(&m_newSpace);
     788    TakeIfEmpty takeIfEmpty(&m_markedSpace);
    789789    freeBlocks(forEachBlock(takeIfEmpty));
    790790}
  • trunk/Source/JavaScriptCore/heap/Heap.h

    r95439 r95450  
    7777
    7878        JSGlobalData* globalData() const { return m_globalData; }
    79         NewSpace& markedSpace() { return m_newSpace; }
     79        MarkedSpace& markedSpace() { return m_markedSpace; }
    8080        MachineThreads& machineThreads() { return m_machineThreads; }
    8181
     
    8787
    8888        void* allocate(size_t);
    89         NewSpace::SizeClass& sizeClassFor(size_t);
    90         void* allocate(NewSpace::SizeClass&);
     89        MarkedSpace::SizeClass& sizeClassFor(size_t);
     90        void* allocate(MarkedSpace::SizeClass&);
    9191        void notifyIsSafeToCollect() { m_isSafeToCollect = true; }
    9292        void collectAllGarbage();
     
    152152        void harvestWeakReferences();
    153153
    154         void* tryAllocate(NewSpace::SizeClass&);
    155         void* allocateSlowCase(NewSpace::SizeClass&);
     154        void* tryAllocate(MarkedSpace::SizeClass&);
     155        void* allocateSlowCase(MarkedSpace::SizeClass&);
    156156       
    157157        enum SweepToggle { DoNotSweep, DoSweep };
     
    176176       
    177177        OperationInProgress m_operationInProgress;
    178         NewSpace m_newSpace;
     178        MarkedSpace m_markedSpace;
    179179        MarkedBlockSet m_blocks;
    180180
     
    337337    }
    338338   
    339     inline NewSpace::SizeClass& Heap::sizeClassFor(size_t bytes)
    340     {
    341         return m_newSpace.sizeClassFor(bytes);
    342     }
    343    
    344     inline void* Heap::allocate(NewSpace::SizeClass& sizeClass)
     339    inline MarkedSpace::SizeClass& Heap::sizeClassFor(size_t bytes)
     340    {
     341        return m_markedSpace.sizeClassFor(bytes);
     342    }
     343   
     344    inline void* Heap::allocate(MarkedSpace::SizeClass& sizeClass)
    345345    {
    346346        // This is a light-weight fast path to cover the most common case.
     
    356356    {
    357357        ASSERT(isValidAllocation(bytes));
    358         NewSpace::SizeClass& sizeClass = sizeClassFor(bytes);
     358        MarkedSpace::SizeClass& sizeClass = sizeClassFor(bytes);
    359359        return allocate(sizeClass);
    360360    }
  • trunk/Source/JavaScriptCore/heap/NewSpace.cpp

    r95439 r95450  
    3232class Structure;
    3333
    34 NewSpace::NewSpace(Heap* heap)
     34MarkedSpace::MarkedSpace(Heap* heap)
    3535    : m_waterMark(0)
    3636    , m_highWaterMark(0)
     
    4444}
    4545
    46 void NewSpace::addBlock(SizeClass& sizeClass, MarkedBlock* block)
     46void MarkedSpace::addBlock(SizeClass& sizeClass, MarkedBlock* block)
    4747{
    4848    block->setInNewSpace(true);
     
    5555}
    5656
    57 void NewSpace::removeBlock(MarkedBlock* block)
     57void MarkedSpace::removeBlock(MarkedBlock* block)
    5858{
    5959    block->setInNewSpace(false);
     
    6464}
    6565
    66 void NewSpace::resetAllocator()
     66void MarkedSpace::resetAllocator()
    6767{
    6868    m_waterMark = 0;
     
    7575}
    7676
    77 void NewSpace::canonicalizeBlocks()
     77void MarkedSpace::canonicalizeBlocks()
    7878{
    7979    for (size_t cellSize = preciseStep; cellSize < preciseCutoff; cellSize += preciseStep)
  • trunk/Source/JavaScriptCore/heap/NewSpace.h

    r95439 r95450  
    3333#include <wtf/Vector.h>
    3434
    35 #define ASSERT_CLASS_FITS_IN_CELL(class) COMPILE_ASSERT(sizeof(class) < NewSpace::maxCellSize, class_fits_in_cell)
     35#define ASSERT_CLASS_FITS_IN_CELL(class) COMPILE_ASSERT(sizeof(class) < MarkedSpace::maxCellSize, class_fits_in_cell)
    3636
    3737namespace JSC {
     
    4343    class SlotVisitor;
    4444
    45     class NewSpace {
    46         WTF_MAKE_NONCOPYABLE(NewSpace);
     45    class MarkedSpace {
     46        WTF_MAKE_NONCOPYABLE(MarkedSpace);
    4747    public:
    4848        static const size_t maxCellSize = 1024;
     
    6060        };
    6161
    62         NewSpace(Heap*);
     62        MarkedSpace(Heap*);
    6363
    6464        SizeClass& sizeClassFor(size_t);
     
    9898    };
    9999
    100     inline size_t NewSpace::waterMark()
     100    inline size_t MarkedSpace::waterMark()
    101101    {
    102102        return m_waterMark;
    103103    }
    104104
    105     inline size_t NewSpace::highWaterMark()
     105    inline size_t MarkedSpace::highWaterMark()
    106106    {
    107107        return m_highWaterMark;
    108108    }
    109109
    110     inline void NewSpace::setHighWaterMark(size_t highWaterMark)
     110    inline void MarkedSpace::setHighWaterMark(size_t highWaterMark)
    111111    {
    112112        m_highWaterMark = highWaterMark;
    113113    }
    114114
    115     inline NewSpace::SizeClass& NewSpace::sizeClassFor(size_t bytes)
     115    inline MarkedSpace::SizeClass& MarkedSpace::sizeClassFor(size_t bytes)
    116116    {
    117117        ASSERT(bytes && bytes < maxCellSize);
     
    121121    }
    122122
    123     inline void* NewSpace::allocate(SizeClass& sizeClass)
     123    inline void* MarkedSpace::allocate(SizeClass& sizeClass)
    124124    {
    125125        MarkedBlock::FreeCell* firstFreeCell = sizeClass.firstFreeCell;
     
    162162    }
    163163   
    164     template <typename Functor> inline typename Functor::ReturnType NewSpace::forEachBlock(Functor& functor)
     164    template <typename Functor> inline typename Functor::ReturnType MarkedSpace::forEachBlock(Functor& functor)
    165165    {
    166166        for (size_t i = 0; i < preciseCount; ++i) {
     
    185185    }
    186186
    187     template <typename Functor> inline typename Functor::ReturnType NewSpace::forEachBlock()
     187    template <typename Functor> inline typename Functor::ReturnType MarkedSpace::forEachBlock()
    188188    {
    189189        Functor functor;
     
    191191    }
    192192
    193     inline NewSpace::SizeClass::SizeClass()
     193    inline MarkedSpace::SizeClass::SizeClass()
    194194        : firstFreeCell(0)
    195195        , currentBlock(0)
     
    199199    }
    200200
    201     inline void NewSpace::SizeClass::resetAllocator()
     201    inline void MarkedSpace::SizeClass::resetAllocator()
    202202    {
    203203        nextBlock = blockList.head();
    204204    }
    205205   
    206     inline void NewSpace::SizeClass::canonicalizeBlock()
     206    inline void MarkedSpace::SizeClass::canonicalizeBlock()
    207207    {
    208208        if (currentBlock) {
  • trunk/Source/JavaScriptCore/jit/JITInlineMethods.h

    r95326 r95450  
    387387template <typename ClassType, typename StructureType> inline void JIT::emitAllocateBasicJSObject(StructureType structure, void* vtable, RegisterID result, RegisterID storagePtr)
    388388{
    389     NewSpace::SizeClass* sizeClass = &m_globalData->heap.sizeClassFor(sizeof(ClassType));
     389    MarkedSpace::SizeClass* sizeClass = &m_globalData->heap.sizeClassFor(sizeof(ClassType));
    390390    loadPtr(&sizeClass->firstFreeCell, result);
    391391    addSlowCase(branchTestPtr(Zero, result));
Note: See TracChangeset for help on using the changeset viewer.