Changeset 146734 in webkit for trunk/Source/JavaScriptCore/heap/HandleSet.h

Timestamp:

Mar 24, 2013, 3:45:36 PM (12 years ago)

Author:

[email protected]

Message:

HandleSet should use HeapBlocks for storing handles
​https://bugs.webkit.org/show_bug.cgi?id=113145

Reviewed by Geoffrey Garen.

• GNUmakefile.list.am: Build project changes.
• JavaScriptCore.gypi: Ditto.
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: Ditto.
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj: Ditto.
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters: Ditto.
• JavaScriptCore.xcodeproj/project.pbxproj: Ditto.
• heap/BlockAllocator.cpp: Rename the RegionSet to m_fourKBBlockRegionSet because there are

too many block types to include them all in the name now.
(JSC::BlockAllocator::BlockAllocator):

• heap/BlockAllocator.h:

(BlockAllocator): Add the appropriate override for regionSetFor.
(JSC::WeakBlock):
(JSC::MarkStackSegment):
(JSC::HandleBlock):

• heap/HandleBlock.h: Added.

(HandleBlock): New class for HandleBlocks.
(JSC::HandleBlock::blockFor): Static method to get the block of the given HandleNode pointer. Allows
us to quickly figure out which HandleSet the HandleNode belongs to without storing the pointer to it
in the HandleNode.
(JSC::HandleBlock::handleSet): Getter.

• heap/HandleBlockInlines.h: Added.

(JSC::HandleBlock::create):
(JSC::HandleBlock::HandleBlock):
(JSC::HandleBlock::payloadEnd):
(JSC::HandleBlock::payload):
(JSC::HandleBlock::nodes):
(JSC::HandleBlock::nodeAtIndex):
(JSC::HandleBlock::nodeCapacity):

• heap/HandleSet.cpp:

(JSC::HandleSet::~HandleSet):
(JSC::HandleSet::grow):

• heap/HandleSet.h:

(HandleNode): Move the internal Node class from HandleSet to be its own public class so it can be
used by HandleBlock.
(HandleSet): Add a typedef so that Node refers to the new HandleNode class.
(JSC::HandleSet::toHandle):
(JSC::HandleSet::toNode):
(JSC::HandleSet::allocate):
(JSC::HandleSet::deallocate):
(JSC::HandleNode::HandleNode):
(JSC::HandleNode::slot):
(JSC::HandleNode::handleSet): Use the new blockFor static function to get the right HandleBlock and lookup
the HandleSet.
(JSC::HandleNode::setPrev):
(JSC::HandleNode::prev):
(JSC::HandleNode::setNext):
(JSC::HandleNode::next):
(JSC::HandleSet::forEachStrongHandle):

• heap/Heap.h: Friend HandleSet so that it can access the BlockAllocator when allocating HandleBlocks.

File:

• trunk/Source/JavaScriptCore/heap/HandleSet.h (modified) (11 diffs)

trunk/Source/JavaScriptCore/heap/HandleSet.h

@@ -27 +27 @@
 #define HandleSet_h
 
-#include <wtf/BlockStack.h>
 #include "Handle.h"
+#include "HandleBlock.h"
+#include <wtf/DoublyLinkedList.h>
 #include <wtf/HashCountedSet.h>
 #include <wtf/SentinelLinkedList.h>
@@ -35 +36 @@
 namespace JSC {
 
+class HandleBlock;
 class HandleSet;
 class HeapRootVisitor;
@@ -41 +43 @@
 class SlotVisitor;
 
+class HandleNode {
+public:
+    HandleNode(WTF::SentinelTag);
+    HandleNode();
+    
+    HandleSlot slot();
+    HandleSet* handleSet();
+
+    void setPrev(HandleNode*);
+    HandleNode* prev();
+
+    void setNext(HandleNode*);
+    HandleNode* next();
+
+private:
+    JSValue m_value;
+    HandleNode* m_prev;
+    HandleNode* m_next;
+};
+
 class HandleSet {
+    friend class HandleBlock;
 public:
     static HandleSet* heapFor(HandleSlot);
 
     HandleSet(JSGlobalData*);
-    
+    ~HandleSet();
+
     JSGlobalData* globalData();
 
@@ -61 +85 @@
 
 private:
-    class Node {
-    public:
-        Node(WTF::SentinelTag);
-        Node(HandleSet*);
-        
-        HandleSlot slot();
-        HandleSet* handleSet();
-
-        void setPrev(Node*);
-        Node* prev();
-
-        void setNext(Node*);
-        Node* next();
-
-    private:
-        JSValue m_value;
-        HandleSet* m_handleSet;
-        Node* m_prev;
-        Node* m_next;
-    };
-
+    typedef HandleNode Node;
     static HandleSlot toHandle(Node*);
     static Node* toNode(HandleSlot);
@@ -92 +96 @@
 
     JSGlobalData* m_globalData;
-    BlockStack<Node> m_blockStack;
+    DoublyLinkedList<HandleBlock> m_blockList;
 
     SentinelLinkedList<Node> m_strongList;
@@ -110 +114 @@
 }
 
-inline HandleSlot HandleSet::toHandle(Node* node)
+inline HandleSlot HandleSet::toHandle(HandleSet::Node* node)
 {
     return reinterpret_cast<HandleSlot>(node);
@@ -117 +121 @@
 inline HandleSet::Node* HandleSet::toNode(HandleSlot handle)
 {
-    return reinterpret_cast<Node*>(handle);
+    return reinterpret_cast<HandleSet::Node*>(handle);
 }
 
@@ -129 +133 @@
         grow();
 
-    Node* node = m_freeList.pop();
-    new (NotNull, node) Node(this);
+    HandleSet::Node* node = m_freeList.pop();
+    new (NotNull, node) HandleSet::Node();
     m_immediateList.push(node);
     return toHandle(node);
@@ -137 +141 @@
 inline void HandleSet::deallocate(HandleSlot handle)
 {
-    Node* node = toNode(handle);
+    HandleSet::Node* node = toNode(handle);
     if (node == m_nextToFinalize) {
         ASSERT(m_nextToFinalize->next());
@@ -143 +147 @@
     }
 
-    SentinelLinkedList<Node>::remove(node);
+    SentinelLinkedList<HandleSet::Node>::remove(node);
     m_freeList.push(node);
 }
 
-inline HandleSet::Node::Node(HandleSet* handleSet)
-    : m_handleSet(handleSet)
-    , m_prev(0)
+inline HandleNode::HandleNode()
+    : m_prev(0)
     , m_next(0)
 {
 }
 
-inline HandleSet::Node::Node(WTF::SentinelTag)
-    : m_handleSet(0)
-    , m_prev(0)
+inline HandleNode::HandleNode(WTF::SentinelTag)
+    : m_prev(0)
     , m_next(0)
 {
 }
 
-inline HandleSlot HandleSet::Node::slot()
+inline HandleSlot HandleNode::slot()
 {
     return &m_value;
 }
 
-inline HandleSet* HandleSet::Node::handleSet()
-{
-    return m_handleSet;
-}
-
-inline void HandleSet::Node::setPrev(Node* prev)
+inline HandleSet* HandleNode::handleSet()
+{
+    return HandleBlock::blockFor(this)->handleSet();
+}
+
+inline void HandleNode::setPrev(HandleNode* prev)
 {
     m_prev = prev;
 }
 
-inline HandleSet::Node* HandleSet::Node::prev()
+inline HandleNode* HandleNode::prev()
 {
     return m_prev;
 }
 
-inline void HandleSet::Node::setNext(Node* next)
+inline void HandleNode::setNext(HandleNode* next)
 {
     m_next = next;
 }
 
-inline HandleSet::Node* HandleSet::Node::next()
+inline HandleNode* HandleNode::next()
 {
     return m_next;
@@ -193 +195 @@
 template<typename Functor> void HandleSet::forEachStrongHandle(Functor& functor, const HashCountedSet<JSCell*>& skipSet)
 {
-    Node* end = m_strongList.end();
-    for (Node* node = m_strongList.begin(); node != end; node = node->next()) {
+    HandleSet::Node* end = m_strongList.end();
+    for (HandleSet::Node* node = m_strongList.begin(); node != end; node = node->next()) {
         JSValue value = *node->slot();
         if (!value || !value.isCell())