Changeset 87441 in webkit

Timestamp:

May 26, 2011 3:43:07 PM (13 years ago)

Author:

ggaren@apple.com

Message:

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

Reviewed by Oliver Hunt.

Moved Heap-related functions out of JSCell.h and into respective header files
​https://bugs.webkit.org/show_bug.cgi?id=61567

• heap/Heap.h: (JSC::Heap::allocate): (JSC::Heap::heap):
• heap/MarkedBlock.h: (JSC::MarkedBlock::allocate):
• heap/MarkedSpace.h: (JSC::MarkedSpace::sizeClassFor): (JSC::MarkedSpace::allocate):
• runtime/JSCell.h: (JSC::JSCell::destructor):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• heap/Heap.h (modified) (1 diff)
• heap/MarkedBlock.h (modified) (2 diffs)
• heap/MarkedSpace.h (modified) (1 diff)
• runtime/JSCell.h (modified) (3 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2011-05-26  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Oliver Hunt.
+
+        Moved Heap-related functions out of JSCell.h and into respective header files
+        https://bugs.webkit.org/show_bug.cgi?id=61567
+
+        * heap/Heap.h:
+        (JSC::Heap::allocate):
+        (JSC::Heap::heap):
+        * heap/MarkedBlock.h:
+        (JSC::MarkedBlock::allocate):
+        * heap/MarkedSpace.h:
+        (JSC::MarkedSpace::sizeClassFor):
+        (JSC::MarkedSpace::allocate):
+        * runtime/JSCell.h:
+        (JSC::JSCell::destructor):
+
 2011-05-26  Geoffrey Garen  <ggaren@apple.com>
 

trunk/Source/JavaScriptCore/heap/Heap.h

@@ -194 +194 @@
     }
 
+    inline void* Heap::allocate(size_t bytes)
+    {
+        ASSERT(isValidAllocation(bytes));
+
+        m_operationInProgress = Allocation;
+        void* result = m_markedSpace.allocate(bytes);
+        m_operationInProgress = NoOperation;
+        if (result)
+            return result;
+
+        return allocateSlowCase(bytes);
+    }
+
+    inline Heap* Heap::heap(JSValue v)
+    {
+        if (!v.isCell())
+            return 0;
+        return heap(v.asCell());
+    }
+
+    inline Heap* Heap::heap(JSCell* c)
+    {
+        return MarkedSpace::heap(c);
+    }
+
 } // namespace JSC
 

trunk/Source/JavaScriptCore/heap/MarkedBlock.h

@@ -37 +37 @@
 
     static const size_t KB = 1024;
+    
+    void destructor(JSCell*); // Defined in JSCell.h.
 
     class MarkedBlock : public DoublyLinkedListNode<MarkedBlock> {
@@ -198 +200 @@
     }
 
+    inline void* MarkedBlock::allocate()
+    {
+        while (m_nextAtom < m_endAtom) {
+            if (!m_marks.testAndSet(m_nextAtom)) {
+                JSCell* cell = reinterpret_cast<JSCell*>(&atoms()[m_nextAtom]);
+                m_nextAtom += m_atomsPerCell;
+                destructor(cell);
+                return cell;
+            }
+            m_nextAtom += m_atomsPerCell;
+        }
+
+        return 0;
+    }
+    
 } // namespace JSC
 

trunk/Source/JavaScriptCore/heap/MarkedSpace.h

@@ -173 +173 @@
     }
 
+    inline MarkedSpace::SizeClass& MarkedSpace::sizeClassFor(size_t bytes)
+    {
+        ASSERT(bytes && bytes < maxCellSize);
+        if (bytes < preciseCutoff)
+            return m_preciseSizeClasses[(bytes - 1) / preciseStep];
+        return m_impreciseSizeClasses[(bytes - 1) / impreciseStep];
+    }
+
+    inline void* MarkedSpace::allocate(size_t bytes)
+    {
+        SizeClass& sizeClass = sizeClassFor(bytes);
+        return allocateFromSizeClass(sizeClass);
+    }
+    
     inline MarkedSpace::SizeClass::SizeClass()
         : nextBlock(0)

trunk/Source/JavaScriptCore/runtime/JSCell.h

@@ -73 +73 @@
         friend class StructureChain;
         friend class RegExp;
+        friend void destructor(JSCell*);
+
         enum CreatingEarlyCellTag { CreatingEarlyCell };
 
@@ -346 +348 @@
     }
 
-    inline Heap* Heap::heap(JSValue v)
-    {
-        if (!v.isCell())
-            return 0;
-        return heap(v.asCell());
-    }
-
-    inline Heap* Heap::heap(JSCell* c)
-    {
-        return MarkedSpace::heap(c);
-    }
-
 #if ENABLE(JSC_ZOMBIES)
     inline bool JSValue::isZombie() const
@@ -365 +355 @@
 #endif
 
-    inline void* MarkedBlock::allocate()
-    {
-        while (m_nextAtom < m_endAtom) {
-            if (!m_marks.testAndSet(m_nextAtom)) {
-                JSCell* cell = reinterpret_cast<JSCell*>(&atoms()[m_nextAtom]);
-                m_nextAtom += m_atomsPerCell;
-                cell->~JSCell();
-                return cell;
-            }
-            m_nextAtom += m_atomsPerCell;
-        }
-
-        return 0;
+    inline void* JSCell::operator new(size_t size, JSGlobalData* globalData)
+    {
+        return globalData->heap.allocate(size);
+    }
+
+    inline void* JSCell::operator new(size_t size, ExecState* exec)
+    {
+        return exec->heap()->allocate(size);
     }
     
-    inline MarkedSpace::SizeClass& MarkedSpace::sizeClassFor(size_t bytes)
-    {
-        ASSERT(bytes && bytes < maxCellSize);
-        if (bytes < preciseCutoff)
-            return m_preciseSizeClasses[(bytes - 1) / preciseStep];
-        return m_impreciseSizeClasses[(bytes - 1) / impreciseStep];
-    }
-
-    inline void* MarkedSpace::allocate(size_t bytes)
-    {
-        SizeClass& sizeClass = sizeClassFor(bytes);
-        return allocateFromSizeClass(sizeClass);
-    }
-    
-    inline void* Heap::allocate(size_t bytes)
-    {
-        ASSERT(isValidAllocation(bytes));
-
-        m_operationInProgress = Allocation;
-        void* result = m_markedSpace.allocate(bytes);
-        m_operationInProgress = NoOperation;
-        if (result)
-            return result;
-
-        return allocateSlowCase(bytes);
-    }
-
-    inline void* JSCell::operator new(size_t size, JSGlobalData* globalData)
-    {
-        return globalData->heap.allocate(size);
-    }
-
-    inline void* JSCell::operator new(size_t size, ExecState* exec)
-    {
-        return exec->heap()->allocate(size);
+    inline void destructor(JSCell* cell)
+    {
+        cell->~JSCell();
     }