Changeset 133812 in webkit

Timestamp:

Nov 7, 2012, 3:34:30 PM (13 years ago)

Author:

[email protected]

Message:

WeakBlocks should be HeapBlocks
​https://bugs.webkit.org/show_bug.cgi?id=101411

Reviewed by Oliver Hunt.

Currently WeakBlocks use fastMalloc memory. They are very similar to the other HeapBlocks, however,
so we should change them to being allocated with the BlockAllocator.

• heap/BlockAllocator.cpp:

(JSC::BlockAllocator::BlockAllocator):

• heap/BlockAllocator.h: Added a new RegionSet for WeakBlocks.

(JSC):
(BlockAllocator):
(JSC::WeakBlock):

• heap/Heap.h: Friended WeakSet to allow access to the BlockAllocator.

(Heap):

• heap/WeakBlock.cpp:

(JSC::WeakBlock::create): Refactored to use HeapBlocks rather than fastMalloc.
(JSC::WeakBlock::WeakBlock):

• heap/WeakBlock.h: Changed the WeakBlock size to 4 KB so that it divides evenly into the Region size.

(JSC):
(WeakBlock):

• heap/WeakSet.cpp:

(JSC::WeakSet::~WeakSet):
(JSC::WeakSet::addAllocator):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• heap/BlockAllocator.cpp (modified) (2 diffs)
• heap/BlockAllocator.h (modified) (4 diffs)
• heap/Heap.h (modified) (1 diff)
• heap/WeakBlock.cpp (modified) (1 diff)
• heap/WeakBlock.h (modified) (4 diffs)
• heap/WeakSet.cpp (modified) (2 diffs)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2012-11-07  Mark Hahnenberg  <[email protected]>
+
+        WeakBlocks should be HeapBlocks
+        https://bugs.webkit.org/show_bug.cgi?id=101411
+
+        Reviewed by Oliver Hunt.
+
+        Currently WeakBlocks use fastMalloc memory. They are very similar to the other HeapBlocks, however, 
+        so we should change them to being allocated with the BlockAllocator.
+
+        * heap/BlockAllocator.cpp:
+        (JSC::BlockAllocator::BlockAllocator):
+        * heap/BlockAllocator.h: Added a new RegionSet for WeakBlocks.
+        (JSC):
+        (BlockAllocator):
+        (JSC::WeakBlock):
+        * heap/Heap.h: Friended WeakSet to allow access to the BlockAllocator.
+        (Heap):
+        * heap/WeakBlock.cpp:
+        (JSC::WeakBlock::create): Refactored to use HeapBlocks rather than fastMalloc.
+        (JSC::WeakBlock::WeakBlock):
+        * heap/WeakBlock.h: Changed the WeakBlock size to 4 KB so that it divides evenly into the Region size.
+        (JSC):
+        (WeakBlock):
+        * heap/WeakSet.cpp:
+        (JSC::WeakSet::~WeakSet):
+        (JSC::WeakSet::addAllocator):
+
 2012-11-07  Filip Pizlo  <[email protected]>
 

trunk/Source/JavaScriptCore/heap/BlockAllocator.cpp

@@ -29 +29 @@
 #include "CopiedBlock.h"
 #include "MarkedBlock.h"
+#include "WeakBlock.h"
 #include <wtf/CurrentTime.h>
 
@@ -36 +37 @@
     : m_copiedRegionSet(CopiedBlock::blockSize)
     , m_markedRegionSet(MarkedBlock::blockSize)
+    , m_weakRegionSet(WeakBlock::blockSize)
     , m_numberOfEmptyRegions(0)
     , m_isCurrentlyAllocating(false)

trunk/Source/JavaScriptCore/heap/BlockAllocator.h

@@ -40 +40 @@
 class MarkedBlock;
 class Region;
+class WeakBlock;
 
 // Simple allocator to reduce VM cost by holding onto blocks of memory for
@@ -185 +186 @@
     RegionSet m_copiedRegionSet;
     RegionSet m_markedRegionSet;
+    RegionSet m_weakRegionSet;
 
     DoublyLinkedList<Region> m_emptyRegions;
@@ -312 +314 @@
 
 template <>
+inline BlockAllocator::RegionSet& BlockAllocator::regionSetFor<WeakBlock>()
+{
+    return m_weakRegionSet;
+}
+
+template <>
 inline BlockAllocator::RegionSet& BlockAllocator::regionSetFor<HeapBlock<CopiedBlock> >()
 {
@@ -321 +329 @@
 {
     return m_markedRegionSet;
+}
+
+template <>
+inline BlockAllocator::RegionSet& BlockAllocator::regionSetFor<HeapBlock<WeakBlock> >()
+{
+    return m_weakRegionSet;
 }
 

trunk/Source/JavaScriptCore/heap/Heap.h

@@ -189 +189 @@
         friend class IncrementalSweeper;
         friend class HeapStatistics;
+        friend class WeakSet;
         template<typename T> friend void* allocateCell(Heap&);
         template<typename T> friend void* allocateCell(Heap&, size_t);

trunk/Source/JavaScriptCore/heap/WeakBlock.cpp

@@ -35 +35 @@
 namespace JSC {
 
-WeakBlock* WeakBlock::create()
+WeakBlock* WeakBlock::create(DeadBlock* block)
 {
-    void* allocation = fastMalloc(blockSize);
-    return new (NotNull, allocation) WeakBlock;
+    Region* region = block->region();
+    return new (NotNull, block) WeakBlock(region);
 }
 
-void WeakBlock::destroy(WeakBlock* block)
-{
-    fastFree(block);
-}
-
-WeakBlock::WeakBlock()
+WeakBlock::WeakBlock(Region* region)
+    : HeapBlock<WeakBlock>(region)
 {
     for (size_t i = 0; i < weakImplCount(); ++i) {

trunk/Source/JavaScriptCore/heap/WeakBlock.h

@@ -35 +35 @@
 namespace JSC {
 
+class DeadBlock;
 class HeapRootVisitor;
 class JSValue;
 class WeakHandleOwner;
 
-class WeakBlock : public DoublyLinkedListNode<WeakBlock> {
+class WeakBlock : public HeapBlock<WeakBlock> {
 public:
     friend class WTF::DoublyLinkedListNode<WeakBlock>;
-    static const size_t blockSize = 3 * KB; // 5% of MarkedBlock size
+    static const size_t blockSize = 4 * KB; // 5% of MarkedBlock size
 
     struct FreeCell {
@@ -56 +57 @@
     };
 
-    static WeakBlock* create();
-    static void destroy(WeakBlock*);
+    static WeakBlock* create(DeadBlock*);
 
     static WeakImpl* asWeakImpl(FreeCell*);
@@ -74 +74 @@
     static FreeCell* asFreeCell(WeakImpl*);
 
-    WeakBlock();
+    WeakBlock(Region*);
     WeakImpl* firstWeakImpl();
     void finalize(WeakImpl*);
@@ -81 +81 @@
     void addToFreeList(FreeCell**, WeakImpl*);
 
-    WeakBlock* m_prev;
-    WeakBlock* m_next;
     SweepResult m_sweepResult;
 };

trunk/Source/JavaScriptCore/heap/WeakSet.cpp

@@ -37 +37 @@
     for (WeakBlock* block = m_blocks.head(); block; block = next) {
         next = block->next();
-        WeakBlock::destroy(block);
+        heap()->blockAllocator().deallocate(WeakBlock::destroy(block));
     }
     m_blocks.clear();
@@ -74 +74 @@
 WeakBlock::FreeCell* WeakSet::addAllocator()
 {
-    WeakBlock* block = WeakBlock::create();
+    WeakBlock* block = WeakBlock::create(heap()->blockAllocator().allocate<WeakBlock>());
     heap()->didAllocate(WeakBlock::blockSize);
     m_blocks.append(block);