Changeset 82866 in webkit

Timestamp:

Apr 4, 2011 1:40:35 PM (13 years ago)

Author:

ggaren@apple.com

Message:

2011-04-04 Geoffrey Garen <​ggaren@apple.com>

Reviewed by Oliver Hunt.

Renamed Finalizer => WeakHandleOwner (in preparation for adding a reachability callback)
​https://bugs.webkit.org/show_bug.cgi?id=57775

Also renamed noFinalizer => emptyWeakOwner, since this is really an
optimization for a weak owner with empty callbacks.

• collector/handles/HandleHeap.cpp: (JSC::HandleHeap::clearWeakPointers): Updated for renames. Removed redundant initialization of m_nextToFinalize. Moved deletion check inside weak owner check, since the weak owner can't delete the node if there is no weak owner!

• collector/handles/HandleHeap.h: (JSC::WeakHandleOwner::~WeakHandleOwner): (JSC::HandleHeap::makeWeak): Updated for renames.

(JSC::HandleHeap::hasWeakOwner): Changed getFinalizer to hasWeakOwner,
to clarify this function's role in assertions.

(JSC::HandleHeap::Node::Node):
(JSC::HandleHeap::Node::makeWeak):
(JSC::HandleHeap::Node::isWeak):
(JSC::HandleHeap::Node::weakOwner):
(JSC::HandleHeap::Node::weakOwnerContext):
(JSC::HandleHeap::Node::emptyWeakOwner):

• interpreter/RegisterFile.cpp: (JSC::RegisterFile::globalObjectCollectedNotifier):
• interpreter/RegisterFile.h:
• runtime/WeakGCMap.h:
• runtime/WeakGCPtr.h: (JSC::WeakGCPtr::WeakGCPtr): (JSC::WeakGCPtr::set): Updated for renames.

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• collector/handles/HandleHeap.cpp (modified) (1 diff)
• collector/handles/HandleHeap.h (modified) (10 diffs)
• interpreter/RegisterFile.cpp (modified) (2 diffs)
• interpreter/RegisterFile.h (modified) (1 diff)
• runtime/WeakGCMap.h (modified) (1 diff)
• runtime/WeakGCPtr.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2011-04-04  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Oliver Hunt.
+
+        Renamed Finalizer => WeakHandleOwner (in preparation for adding a reachability callback)
+        https://bugs.webkit.org/show_bug.cgi?id=57775
+        
+        Also renamed noFinalizer => emptyWeakOwner, since this is really an
+        optimization for a weak owner with empty callbacks.
+
+        * collector/handles/HandleHeap.cpp:
+        (JSC::HandleHeap::clearWeakPointers): Updated for renames. Removed
+        redundant initialization of m_nextToFinalize. Moved deletion check inside
+        weak owner check, since the weak owner can't delete the node if there is
+        no weak owner!
+
+        * collector/handles/HandleHeap.h:
+        (JSC::WeakHandleOwner::~WeakHandleOwner):
+        (JSC::HandleHeap::makeWeak): Updated for renames.
+
+        (JSC::HandleHeap::hasWeakOwner): Changed getFinalizer to hasWeakOwner,
+        to clarify this function's role in assertions.
+
+        (JSC::HandleHeap::Node::Node):
+        (JSC::HandleHeap::Node::makeWeak):
+        (JSC::HandleHeap::Node::isWeak):
+        (JSC::HandleHeap::Node::weakOwner):
+        (JSC::HandleHeap::Node::weakOwnerContext):
+        (JSC::HandleHeap::Node::emptyWeakOwner):
+        * interpreter/RegisterFile.cpp:
+        (JSC::RegisterFile::globalObjectCollectedNotifier):
+        * interpreter/RegisterFile.h:
+        * runtime/WeakGCMap.h:
+        * runtime/WeakGCPtr.h:
+        (JSC::WeakGCPtr::WeakGCPtr):
+        (JSC::WeakGCPtr::set): Updated for renames.
+
 2011-04-04  Oliver Hunt  <oliver@apple.com>
 

trunk/Source/JavaScriptCore/collector/handles/HandleHeap.cpp

@@ -87 +87 @@
             continue;
 
-        m_nextToFinalize = node->next();
-        if (Finalizer* finalizer = node->finalizer())
-            finalizer->finalize(Handle<Unknown>::wrapSlot(node->slot()), node->finalizerContext());
-
-        if (m_nextToFinalize != node->next()) // Finalizer deallocated node.
-            continue;
+        if (WeakHandleOwner* weakOwner = node->weakOwner()) {
+            weakOwner->finalize(Handle<Unknown>::wrapSlot(node->slot()), node->weakOwnerContext());
+            if (m_nextToFinalize != node->next()) // Owner deallocated node.
+                continue;
+        }
 
         *node->slot() = JSValue();

trunk/Source/JavaScriptCore/collector/handles/HandleHeap.h

@@ -39 +39 @@
 class HeapRootMarker;
 
-class Finalizer {
+class WeakHandleOwner {
 public:
     virtual void finalize(Handle<Unknown>, void*) = 0;
-    virtual ~Finalizer() {}
+    virtual ~WeakHandleOwner() {}
 };
 
@@ -54 +54 @@
     void deallocate(HandleSlot);
 
-    void makeWeak(HandleSlot, Finalizer* = 0, void* context = 0);
+    void makeWeak(HandleSlot, WeakHandleOwner* = 0, void* context = 0);
 
     void markStrongHandles(HeapRootMarker&);
@@ -65 +65 @@
 
 #if !ASSERT_DISABLED
-    Finalizer* getFinalizer(HandleSlot handle)
-    {
-        return toNode(handle)->finalizer();
-    }
+    bool hasWeakOwner(HandleSlot, WeakHandleOwner*);
 #endif
 
@@ -82 +79 @@
         HandleHeap* handleHeap();
 
-        void makeWeak(Finalizer*, void* context);
+        void makeWeak(WeakHandleOwner*, void* context);
         bool isWeak();
         
-        Finalizer* finalizer();
-        void* finalizerContext();
+        WeakHandleOwner* weakOwner();
+        void* weakOwnerContext();
 
         void setPrev(Node*);
@@ -95 +92 @@
 
     private:
-        Finalizer* noFinalizer();
+        WeakHandleOwner* emptyWeakOwner();
 
         JSValue m_value;
         HandleHeap* m_handleHeap;
-        Finalizer* m_finalizer;
-        void* m_finalizerContext;
+        WeakHandleOwner* m_weakOwner;
+        void* m_weakOwnerContext;
         Node* m_prev;
         Node* m_next;
@@ -161 +158 @@
 }
 
-inline void HandleHeap::makeWeak(HandleSlot handle, Finalizer* finalizer, void* context)
+inline void HandleHeap::makeWeak(HandleSlot handle, WeakHandleOwner* weakOwner, void* context)
 {
     Node* node = toNode(handle);
     SentinelLinkedList<Node>::remove(node);
-    node->makeWeak(finalizer, context);
+    node->makeWeak(weakOwner, context);
     if (handle->isCell() && *handle)
         m_weakList.push(node);
@@ -172 +169 @@
 }
 
+#if !ASSERT_DISABLED
+inline bool HandleHeap::hasWeakOwner(HandleSlot handle, WeakHandleOwner* weakOwner)
+{
+    return toNode(handle)->weakOwner() == weakOwner;
+}
+#endif
+
 inline HandleHeap::Node::Node(HandleHeap* handleHeap)
     : m_handleHeap(handleHeap)
-    , m_finalizer(0)
-    , m_finalizerContext(0)
+    , m_weakOwner(0)
+    , m_weakOwnerContext(0)
 {
 }
@@ -181 +185 @@
 inline HandleHeap::Node::Node(WTF::SentinelTag)
     : m_handleHeap(0)
-    , m_finalizer(0)
-    , m_finalizerContext(0)
+    , m_weakOwner(0)
+    , m_weakOwnerContext(0)
 {
 }
@@ -196 +200 @@
 }
 
-inline void HandleHeap::Node::makeWeak(Finalizer* finalizer, void* context)
-{
-    m_finalizer = finalizer ? finalizer : noFinalizer();
-    m_finalizerContext = context;
+inline void HandleHeap::Node::makeWeak(WeakHandleOwner* weakOwner, void* context)
+{
+    m_weakOwner = weakOwner ? weakOwner : emptyWeakOwner();
+    m_weakOwnerContext = context;
 }
 
 inline bool HandleHeap::Node::isWeak()
 {
-    return m_finalizer; // True for noFinalizer().
-}
-
-inline Finalizer* HandleHeap::Node::finalizer()
-{
-    return m_finalizer == noFinalizer() ? 0 : m_finalizer;
-}
-
-inline void* HandleHeap::Node::finalizerContext()
-{
-    ASSERT(finalizer());
-    return m_finalizerContext;
+    return m_weakOwner; // True for emptyWeakOwner().
+}
+
+inline WeakHandleOwner* HandleHeap::Node::weakOwner()
+{
+    return m_weakOwner == emptyWeakOwner() ? 0 : m_weakOwner; // 0 for emptyWeakOwner().
+}
+
+inline void* HandleHeap::Node::weakOwnerContext()
+{
+    ASSERT(weakOwner());
+    return m_weakOwnerContext;
 }
 
@@ -238 +242 @@
 }
 
-inline Finalizer* HandleHeap::Node::noFinalizer()
-{
-    return reinterpret_cast<Finalizer*>(-1); // Sentinel to indicate a node is weak but has no real finalizer.
-}
-
-}
-
-#endif
+// Sentinel to indicate that a node is weak, but its owner has no meaningful
+// callbacks. This allows us to optimize by skipping such nodes.
+inline WeakHandleOwner* HandleHeap::Node::emptyWeakOwner()
+{
+    return reinterpret_cast<WeakHandleOwner*>(-1);
+}
+
+}
+
+#endif

trunk/Source/JavaScriptCore/interpreter/RegisterFile.cpp

@@ -76 +76 @@
 }
 
-class GlobalObjectNotifier : public Finalizer {
+class GlobalObjectNotifier : public WeakHandleOwner {
 public:
     void finalize(Handle<Unknown> value, void*)
@@ -85 +85 @@
 };
 
-Finalizer* RegisterFile::globalObjectCollectedNotifier()
+WeakHandleOwner* RegisterFile::globalObjectCollectedNotifier()
 {
     // This will leak alas, but we only create one of them, and it doesn't

trunk/Source/JavaScriptCore/interpreter/RegisterFile.h

@@ -136 +136 @@
         static void initializeThreading();
 
-        static Finalizer* globalObjectCollectedNotifier();
+        static WeakHandleOwner* globalObjectCollectedNotifier();
 
         Register* const * addressOfEnd() const

trunk/Source/JavaScriptCore/runtime/WeakGCMap.h

@@ -35 +35 @@
 // A HashMap for GC'd values that removes entries when the associated value
 // dies.
-template<typename KeyType, typename MappedType> class WeakGCMap : private Finalizer {
+template<typename KeyType, typename MappedType> class WeakGCMap : private WeakHandleOwner {
     WTF_MAKE_FAST_ALLOCATED;
     WTF_MAKE_NONCOPYABLE(WeakGCMap);

trunk/Source/JavaScriptCore/runtime/WeakGCPtr.h

@@ -44 +44 @@
     }
     
-    WeakGCPtr(JSGlobalData& globalData, Finalizer* finalizer = 0, void* context = 0)
+    WeakGCPtr(JSGlobalData& globalData, WeakHandleOwner* weakOwner = 0, void* context = 0)
         : m_slot(globalData.allocateGlobalHandle())
     {
-        HandleHeap::heapFor(m_slot)->makeWeak(m_slot, finalizer, context);
+        HandleHeap::heapFor(m_slot)->makeWeak(m_slot, weakOwner, context);
     }
     
-    WeakGCPtr(JSGlobalData& globalData, ExternalType value, Finalizer* finalizer = 0, void* context = 0)
+    WeakGCPtr(JSGlobalData& globalData, ExternalType value, WeakHandleOwner* weakOwner = 0, void* context = 0)
         : m_slot(globalData.allocateGlobalHandle())
     {
-        HandleHeap::heapFor(m_slot)->makeWeak(m_slot, finalizer, context);
+        HandleHeap::heapFor(m_slot)->makeWeak(m_slot, weakOwner, context);
         internalSet(value);
     }
@@ -78 +78 @@
     }
 
-    void set(JSGlobalData& globalData, ExternalType value, Finalizer* finalizer)
+    void set(JSGlobalData& globalData, ExternalType value, WeakHandleOwner* weakOwner)
     {
         if (!this->m_slot) {
             this->m_slot = globalData.allocateGlobalHandle();
-            HandleHeap::heapFor(this->m_slot)->makeWeak(this->m_slot, finalizer, 0);
-        } else
-            ASSERT(HandleHeap::heapFor(this->m_slot)->getFinalizer(this->m_slot) == finalizer);
+            HandleHeap::heapFor(this->m_slot)->makeWeak(this->m_slot, weakOwner);
+        }
+        ASSERT(HandleHeap::heapFor(this->m_slot)->hasWeakOwner(this->m_slot, weakOwner));
         this->internalSet(value);
     }