Changeset 113508 in webkit for trunk/Source/JavaScriptCore/heap


Ignore:
Timestamp:
Apr 6, 2012, 3:35:55 PM (13 years ago)
Author:
[email protected]
Message:

Renamed

WeakHeap => WeakSet
HandleHeap => HandleSet

Reviewed by Sam Weinig.

These sets do have internal allocators, but it's confusing to call them
heaps because they're sub-objects of an object called "heap".

  • heap/HandleHeap.cpp: Removed.
  • heap/HandleHeap.h: Removed.
  • heap/HandleSet.cpp: Copied from JavaScriptCore/heap/HandleHeap.cpp.
  • heap/WeakHeap.cpp: Removed.
  • heap/WeakHeap.h: Removed.
  • heap/WeakSet.cpp: Copied from JavaScriptCore/heap/WeakHeap.cpp.
  • heap/WeakSet.h: Copied from JavaScriptCore/heap/WeakHeap.h.

Plus global rename using grep.

Location:
trunk/Source/JavaScriptCore/heap
Files:
7 edited
4 moved

Legend:

Unmodified
Added
Removed

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

    r113141 r113508  
    4949class HandleBase {
    5050    template <typename T> friend class Weak;
    51     friend class HandleHeap;
     51    friend class HandleSet;
    5252    friend struct JSCallbackObjectData;
    5353    template <typename KeyType, typename MappedType, typename FinalizerCallback, typename HashArg, typename KeyTraitsArg> friend class WeakGCMap;
    … …  
    134134   
    135135private:
    136     friend class HandleHeap;
     136    friend class HandleSet;
    137137    friend class WeakBlock;
    138138

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

    r113502 r113508  
    2525
    2626#include "config.h"
    27 #include "HandleHeap.h"
     27#include "HandleSet.h"
    2828
    2929#include "HeapRootVisitor.h"
    … …  
    3232namespace JSC {
    3333
    34 HandleHeap::HandleHeap(JSGlobalData* globalData)
     34HandleSet::HandleSet(JSGlobalData* globalData)
    3535    : m_globalData(globalData)
    3636    , m_nextToFinalize(0)
    … …  
    3939}
    4040
    41 void HandleHeap::grow()
     41void HandleSet::grow()
    4242{
    4343    Node* block = m_blockStack.grow();
    … …  
    4949}
    5050
    51 void HandleHeap::visitStrongHandles(HeapRootVisitor& heapRootVisitor)
     51void HandleSet::visitStrongHandles(HeapRootVisitor& heapRootVisitor)
    5252{
    5353    Node* end = m_strongList.end();
    … …  
    6161}
    6262
    63 void HandleHeap::writeBarrier(HandleSlot slot, const JSValue& value)
     63void HandleSet::writeBarrier(HandleSlot slot, const JSValue& value)
    6464{
    6565    // Forbid assignment to handles during the finalization phase, since it would violate many GC invariants.
    … …  
    8989}
    9090
    91 unsigned HandleHeap::protectedGlobalObjectCount()
     91unsigned HandleSet::protectedGlobalObjectCount()
    9292{
    9393    unsigned count = 0;
    … …  
    102102
    103103#if ENABLE(GC_VALIDATION) || !ASSERT_DISABLED
    104 bool HandleHeap::isLiveNode(Node* node)
     104bool HandleSet::isLiveNode(Node* node)
    105105{
    106106    if (node->prev()->next() != node)

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

    r113502 r113508  
    2424 */
    2525
    26 #ifndef HandleHeap_h
    27 #define HandleHeap_h
     26#ifndef HandleSet_h
     27#define HandleSet_h
    2828
    2929#include <wtf/BlockStack.h>
    … …  
    3535namespace JSC {
    3636
    37 class HandleHeap;
     37class HandleSet;
    3838class HeapRootVisitor;
    3939class JSGlobalData;
    … …  
    4141class SlotVisitor;
    4242
    43 class HandleHeap {
     43class HandleSet {
    4444public:
    45     static HandleHeap* heapFor(HandleSlot);
    46 
    47     HandleHeap(JSGlobalData*);
     45    static HandleSet* heapFor(HandleSlot);
     46
     47    HandleSet(JSGlobalData*);
    4848   
    4949    JSGlobalData* globalData();
    … …  
    6464    public:
    6565        Node(WTF::SentinelTag);
    66         Node(HandleHeap*);
     66        Node(HandleSet*);
    6767       
    6868        HandleSlot slot();
    69         HandleHeap* handleHeap();
     69        HandleSet* handleSet();
    7070
    7171        void setPrev(Node*);
    … …  
    7777    private:
    7878        JSValue m_value;
    79         HandleHeap* m_handleHeap;
     79        HandleSet* m_handleSet;
    8080        Node* m_prev;
    8181        Node* m_next;
    … …  
    100100};
    101101
    102 inline HandleHeap* HandleHeap::heapFor(HandleSlot handle)
    103 {
    104     return toNode(handle)->handleHeap();
    105 }
    106 
    107 inline JSGlobalData* HandleHeap::globalData()
     102inline HandleSet* HandleSet::heapFor(HandleSlot handle)
     103{
     104    return toNode(handle)->handleSet();
     105}
     106
     107inline JSGlobalData* HandleSet::globalData()
    108108{
    109109    return m_globalData;
    110110}
    111111
    112 inline HandleSlot HandleHeap::toHandle(Node* node)
     112inline HandleSlot HandleSet::toHandle(Node* node)
    113113{
    114114    return reinterpret_cast<HandleSlot>(node);
    115115}
    116116
    117 inline HandleHeap::Node* HandleHeap::toNode(HandleSlot handle)
     117inline HandleSet::Node* HandleSet::toNode(HandleSlot handle)
    118118{
    119119    return reinterpret_cast<Node*>(handle);
    120120}
    121121
    122 inline HandleSlot HandleHeap::allocate()
     122inline HandleSlot HandleSet::allocate()
    123123{
    124124    // Forbid assignment to handles during the finalization phase, since it would violate many GC invariants.
    … …  
    135135}
    136136
    137 inline void HandleHeap::deallocate(HandleSlot handle)
     137inline void HandleSet::deallocate(HandleSlot handle)
    138138{
    139139    Node* node = toNode(handle);
    … …  
    147147}
    148148
    149 inline HandleHeap::Node::Node(HandleHeap* handleHeap)
    150     : m_handleHeap(handleHeap)
     149inline HandleSet::Node::Node(HandleSet* handleSet)
     150    : m_handleSet(handleSet)
    151151    , m_prev(0)
    152152    , m_next(0)
    … …  
    154154}
    155155
    156 inline HandleHeap::Node::Node(WTF::SentinelTag)
    157     : m_handleHeap(0)
     156inline HandleSet::Node::Node(WTF::SentinelTag)
     157    : m_handleSet(0)
    158158    , m_prev(0)
    159159    , m_next(0)
    … …  
    161161}
    162162
    163 inline HandleSlot HandleHeap::Node::slot()
     163inline HandleSlot HandleSet::Node::slot()
    164164{
    165165    return &m_value;
    166166}
    167167
    168 inline HandleHeap* HandleHeap::Node::handleHeap()
    169 {
    170     return m_handleHeap;
    171 }
    172 
    173 inline void HandleHeap::Node::setPrev(Node* prev)
     168inline HandleSet* HandleSet::Node::handleSet()
     169{
     170    return m_handleSet;
     171}
     172
     173inline void HandleSet::Node::setPrev(Node* prev)
    174174{
    175175    m_prev = prev;
    176176}
    177177
    178 inline HandleHeap::Node* HandleHeap::Node::prev()
     178inline HandleSet::Node* HandleSet::Node::prev()
    179179{
    180180    return m_prev;
    181181}
    182182
    183 inline void HandleHeap::Node::setNext(Node* next)
     183inline void HandleSet::Node::setNext(Node* next)
    184184{
    185185    m_next = next;
    186186}
    187187
    188 inline HandleHeap::Node* HandleHeap::Node::next()
     188inline HandleSet::Node* HandleSet::Node::next()
    189189{
    190190    return m_next;
    191191}
    192192
    193 template<typename Functor> void HandleHeap::forEachStrongHandle(Functor& functor, const HashCountedSet<JSCell*>& skipSet)
     193template<typename Functor> void HandleSet::forEachStrongHandle(Functor& functor, const HashCountedSet<JSCell*>& skipSet)
    194194{
    195195    Node* end = m_strongList.end();

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

    r113445 r113508  
    324324    , m_sharedData(globalData)
    325325    , m_slotVisitor(m_sharedData)
    326     , m_weakHeap(this)
    327     , m_handleHeap(globalData)
     326    , m_weakSet(this)
     327    , m_handleSet(globalData)
    328328    , m_isSafeToCollect(false)
    329329    , m_globalData(globalData)
    … …  
    376376    clearMarks();
    377377
    378     m_weakHeap.finalizeAll();
     378    m_weakSet.finalizeAll();
    379379    m_globalData->smallStrings.finalizeSmallStrings();
    380380    shrink();
    … …  
    661661        {
    662662            GCPHASE(VisitStrongHandles);
    663             m_handleHeap.visitStrongHandles(heapRootVisitor);
     663            m_handleSet.visitStrongHandles(heapRootVisitor);
    664664            visitor.donateAndDrain();
    665665        }
    … …  
    690690        GCPHASE(VisitingLiveWeakHandles);
    691691        while (true) {
    692             m_weakHeap.visitLiveWeakImpls(heapRootVisitor);
     692            m_weakSet.visitLiveWeakImpls(heapRootVisitor);
    693693            harvestWeakReferences();
    694694            if (visitor.isEmpty())
    … …  
    706706    {
    707707        GCPHASE(VisitingDeadWeakHandles);
    708         m_weakHeap.visitDeadWeakImpls(heapRootVisitor);
     708        m_weakSet.visitDeadWeakImpls(heapRootVisitor);
    709709    }
    710710
    … …  
    819819    {
    820820        GCPHASE(FinalizeWeakHandles);
    821         m_weakHeap.sweep();
     821        m_weakSet.sweep();
    822822        m_globalData->smallStrings.finalizeSmallStrings();
    823823    }
    … …  
    867867{
    868868    m_objectSpace.resetAllocators();
    869     m_weakHeap.resetAllocator();
     869    m_weakSet.resetAllocator();
    870870}
    871871
    … …  
    928928void Heap::addFinalizer(JSCell* cell, Finalizer finalizer)
    929929{
    930     weakHeap()->allocate(cell, &m_finalizerOwner, reinterpret_cast<void*>(finalizer)); // Balanced by FinalizerOwner::finalize().
     930    weakSet()->allocate(cell, &m_finalizerOwner, reinterpret_cast<void*>(finalizer)); // Balanced by FinalizerOwner::finalize().
    931931}
    932932
    … …  
    936936    Finalizer finalizer = reinterpret_cast<Finalizer>(context);
    937937    finalizer(slot->asCell());
    938     WeakHeap::deallocate(WeakImpl::asWeakImpl(slot));
     938    WeakSet::deallocate(WeakImpl::asWeakImpl(slot));
    939939}
    940940

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

    r113445 r113508  
    2424
    2525#include "DFGCodeBlocks.h"
    26 #include "HandleHeap.h"
     26#include "HandleSet.h"
    2727#include "HandleStack.h"
    2828#include "MarkedAllocator.h"
    … …  
    3232#include "SlotVisitor.h"
    3333#include "WeakHandleOwner.h"
    34 #include "WeakHeap.h"
     34#include "WeakSet.h"
    3535#include "WriteBarrierSupport.h"
    3636#include <wtf/DoublyLinkedList.h>
    … …  
    139139        template<typename Functor> typename Functor::ReturnType forEachProtectedCell();
    140140
    141         WeakHeap* weakHeap() { return &m_weakHeap; }
    142         HandleHeap* handleHeap() { return &m_handleHeap; }
     141        WeakSet* weakSet() { return &m_weakSet; }
     142        HandleSet* handleSet() { return &m_handleSet; }
    143143        HandleStack* handleStack() { return &m_handleStack; }
    144144
    … …  
    238238        SlotVisitor m_slotVisitor;
    239239
    240         WeakHeap m_weakHeap;
    241         HandleHeap m_handleHeap;
     240        WeakSet m_weakSet;
     241        HandleSet m_handleSet;
    242242        HandleStack m_handleStack;
    243243        DFGCodeBlocks m_dfgCodeBlocks;
    … …  
    356356        for (ProtectCountSet::iterator it = m_protectedValues.begin(); it != end; ++it)
    357357            functor(it->first);
    358         m_handleHeap.forEachStrongHandle(functor, m_protectedValues);
     358        m_handleSet.forEachStrongHandle(functor, m_protectedValues);
    359359
    360360        return functor.returnValue();

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

    r113209 r113508  
    148148
    149149template<typename T> inline PassWeak<T>::PassWeak(JSGlobalData& globalData, typename PassWeak<T>::GetType getType, WeakHandleOwner* weakOwner, void* context)
    150     : m_impl(globalData.heap.weakHeap()->allocate(getType, weakOwner, context))
     150    : m_impl(globalData.heap.weakSet()->allocate(getType, weakOwner, context))
    151151{
    152152}
    … …  
    166166    if (!m_impl)
    167167        return;
    168     WeakHeap::deallocate(m_impl);
     168    WeakSet::deallocate(m_impl);
    169169}
    170170

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

    r113141 r113508  
    2929#include <wtf/Assertions.h>
    3030#include "Handle.h"
    31 #include "HandleHeap.h"
     31#include "HandleSet.h"
    3232
    3333namespace JSC {
    … …  
    5757        if (!other.slot())
    5858            return;
    59         setSlot(HandleHeap::heapFor(other.slot())->allocate());
     59        setSlot(HandleSet::heapFor(other.slot())->allocate());
    6060        set(other.get());
    6161    }
    … …  
    6666        if (!other.slot())
    6767            return;
    68         setSlot(HandleHeap::heapFor(other.slot())->allocate());
     68        setSlot(HandleSet::heapFor(other.slot())->allocate());
    6969        set(other.get());
    7070    }
    … …  
    104104        }
    105105
    106         set(*HandleHeap::heapFor(other.slot())->globalData(), other.get());
     106        set(*HandleSet::heapFor(other.slot())->globalData(), other.get());
    107107        return *this;
    108108    }
    … …  
    115115        }
    116116
    117         set(*HandleHeap::heapFor(other.slot())->globalData(), other.get());
     117        set(*HandleSet::heapFor(other.slot())->globalData(), other.get());
    118118        return *this;
    119119    }
    … …  
    123123        if (!slot())
    124124            return;
    125         HandleHeap::heapFor(slot())->deallocate(slot());
     125        HandleSet::heapFor(slot())->deallocate(slot());
    126126        setSlot(0);
    127127    }
    … …  
    134134        ASSERT(slot());
    135135        JSValue value = HandleTypes<T>::toJSValue(externalType);
    136         HandleHeap::heapFor(slot())->writeBarrier(slot(), value);
     136        HandleSet::heapFor(slot())->writeBarrier(slot(), value);
    137137        *slot() = value;
    138138    }

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

    r96465 r113508  
    3131template <typename T>
    3232inline Strong<T>::Strong(JSGlobalData& globalData, ExternalType value)
    33     : Handle<T>(globalData.heap.handleHeap()->allocate())
     33    : Handle<T>(globalData.heap.handleSet()->allocate())
    3434{
    3535    set(value);
    … …  
    3838template <typename T>
    3939inline Strong<T>::Strong(JSGlobalData& globalData, Handle<T> handle)
    40     : Handle<T>(globalData.heap.handleHeap()->allocate())
     40    : Handle<T>(globalData.heap.handleSet()->allocate())
    4141{
    4242    set(handle.get());
    … …  
    4747{
    4848    if (!slot())
    49         setSlot(globalData.heap.handleHeap()->allocate());
     49        setSlot(globalData.heap.handleSet()->allocate());
    5050    set(value);
    5151}

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

    r113141 r113508  
    8080
    8181template<typename T> inline Weak<T>::Weak(JSGlobalData& globalData, typename Weak<T>::GetType getType, WeakHandleOwner* weakOwner, void* context)
    82     : m_impl(globalData.heap.weakHeap()->allocate(getType, weakOwner, context))
     82    : m_impl(globalData.heap.weakSet()->allocate(getType, weakOwner, context))
    8383{
    8484}
    … …  
    142142    if (!m_impl)
    143143        return;
    144     WeakHeap::deallocate(m_impl);
     144    WeakSet::deallocate(m_impl);
    145145    m_impl = 0;
    146146}

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

    r113502 r113508  
    2525
    2626#include "config.h"
    27 #include "WeakHeap.h"
     27#include "WeakSet.h"
    2828
    2929#include "Heap.h"
    … …  
    3131namespace JSC {
    3232
    33 WeakHeap::~WeakHeap()
     33WeakSet::~WeakSet()
    3434{
    3535    WeakBlock* next = 0;
    … …  
    4141}
    4242
    43 void WeakHeap::finalizeAll()
     43void WeakSet::finalizeAll()
    4444{
    4545    for (WeakBlock* block = static_cast<WeakBlock*>(m_blocks.head()); block; block = static_cast<WeakBlock*>(block->next()))
    … …  
    4747}
    4848
    49 void WeakHeap::visitLiveWeakImpls(HeapRootVisitor& visitor)
     49void WeakSet::visitLiveWeakImpls(HeapRootVisitor& visitor)
    5050{
    5151    for (WeakBlock* block = static_cast<WeakBlock*>(m_blocks.head()); block; block = static_cast<WeakBlock*>(block->next()))
    … …  
    5353}
    5454
    55 void WeakHeap::visitDeadWeakImpls(HeapRootVisitor& visitor)
     55void WeakSet::visitDeadWeakImpls(HeapRootVisitor& visitor)
    5656{
    5757    for (WeakBlock* block = static_cast<WeakBlock*>(m_blocks.head()); block; block = static_cast<WeakBlock*>(block->next()))
    … …  
    5959}
    6060
    61 void WeakHeap::sweep()
     61void WeakSet::sweep()
    6262{
    6363    WeakBlock* next;
    … …  
    7474}
    7575
    76 void WeakHeap::resetAllocator()
     76void WeakSet::resetAllocator()
    7777{
    7878    m_allocator = 0;
    … …  
    8080}
    8181
    82 WeakBlock::FreeCell* WeakHeap::findAllocator()
     82WeakBlock::FreeCell* WeakSet::findAllocator()
    8383{
    8484    if (WeakBlock::FreeCell* allocator = tryFindAllocator())
    … …  
    9494}
    9595
    96 WeakBlock::FreeCell* WeakHeap::tryFindAllocator()
     96WeakBlock::FreeCell* WeakSet::tryFindAllocator()
    9797{
    9898    while (m_nextAllocator) {
    … …  
    109109}
    110110
    111 WeakBlock::FreeCell* WeakHeap::addAllocator()
     111WeakBlock::FreeCell* WeakSet::addAllocator()
    112112{
    113113    WeakBlock* block = WeakBlock::create();
    … …  
    118118}
    119119
    120 void WeakHeap::removeAllocator(WeakBlock* block)
     120void WeakSet::removeAllocator(WeakBlock* block)
    121121{
    122122    m_blocks.remove(block);

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

    r113502 r113508  
    2424 */
    2525
    26 #ifndef WeakHeap_h
    27 #define WeakHeap_h
     26#ifndef WeakSet_h
     27#define WeakSet_h
    2828
    2929#include "WeakBlock.h"
    … …  
    3434class WeakImpl;
    3535
    36 class WeakHeap {
     36class WeakSet {
    3737public:
    38     WeakHeap(Heap*);
     38    WeakSet(Heap*);
    3939    void finalizeAll();
    40     ~WeakHeap();
     40    ~WeakSet();
    4141
    4242    WeakImpl* allocate(JSValue, WeakHandleOwner* = 0, void* context = 0);
    … …  
    6161};
    6262
    63 inline WeakHeap::WeakHeap(Heap* heap)
     63inline WeakSet::WeakSet(Heap* heap)
    6464    : m_allocator(0)
    6565    , m_nextAllocator(0)
    … …  
    6868}
    6969
    70 inline WeakImpl* WeakHeap::allocate(JSValue jsValue, WeakHandleOwner* weakHandleOwner, void* context)
     70inline WeakImpl* WeakSet::allocate(JSValue jsValue, WeakHandleOwner* weakHandleOwner, void* context)
    7171{
    7272    WeakBlock::FreeCell* allocator = m_allocator;
    … …  
    7979}
    8080
    81 inline void WeakHeap::deallocate(WeakImpl* weakImpl)
     81inline void WeakSet::deallocate(WeakImpl* weakImpl)
    8282{
    8383    WeakBlock::blockFor(weakImpl)->deallocate(weakImpl);
    … …  
    8686} // namespace JSC
    8787
    88 #endif // WeakHeap_h
     88#endif // WeakSet_h
Note: See TracChangeset for help on using the changeset viewer.