Changeset 179192 in webkit for trunk/Source/JavaScriptCore/heap/CopiedBlock.h

Timestamp:

Jan 27, 2015, 10:29:29 AM (10 years ago)

Author:

[email protected]

Message:

Use FastMalloc (bmalloc) instead of BlockAllocator for GC pages
​https://bugs.webkit.org/show_bug.cgi?id=140900

Reviewed by Mark Hahnenberg.

Source/JavaScriptCore:

Removes some more custom allocation code.

Looks like a speedup. (See results attached to bugzilla.)

Will hopefully reduce memory use by improving sharing between the GC and
malloc heaps.

• API/JSBase.cpp:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
• JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
• JavaScriptCore.xcodeproj/project.pbxproj: Feed the compiler.

• heap/BlockAllocator.cpp: Removed.
• heap/BlockAllocator.h: Removed. No need for a custom allocator anymore.

• heap/CodeBlockSet.cpp:

(JSC::CodeBlockSet::CodeBlockSet):

• heap/CodeBlockSet.h: Feed the compiler.

• heap/CopiedBlock.h:

(JSC::CopiedBlock::createNoZeroFill):
(JSC::CopiedBlock::create):
(JSC::CopiedBlock::CopiedBlock):
(JSC::CopiedBlock::isOversize):
(JSC::CopiedBlock::payloadEnd):
(JSC::CopiedBlock::capacity):

• heap/CopiedBlockInlines.h:

(JSC::CopiedBlock::reportLiveBytes): Each copied block now tracks its
own size, since we can't rely on Region to tell us our size anymore.

• heap/CopiedSpace.cpp:

(JSC::CopiedSpace::~CopiedSpace):
(JSC::CopiedSpace::tryAllocateOversize):
(JSC::CopiedSpace::tryReallocateOversize):

• heap/CopiedSpaceInlines.h:

(JSC::CopiedSpace::recycleEvacuatedBlock):
(JSC::CopiedSpace::recycleBorrowedBlock):
(JSC::CopiedSpace::allocateBlockForCopyingPhase):
(JSC::CopiedSpace::allocateBlock):
(JSC::CopiedSpace::startedCopying): Deallocate blocks directly, rather
than pushing them onto the block allocator's free list; the block
allocator doesn't exist anymore.

• heap/CopyWorkList.h:

(JSC::CopyWorkListSegment::create):
(JSC::CopyWorkListSegment::CopyWorkListSegment):
(JSC::CopyWorkList::~CopyWorkList):
(JSC::CopyWorkList::append):
(JSC::CopyWorkList::CopyWorkList): Deleted.

• heap/GCSegmentedArray.h:

(JSC::GCArraySegment::GCArraySegment):

• heap/GCSegmentedArrayInlines.h:

(JSC::GCSegmentedArray<T>::GCSegmentedArray):
(JSC::GCSegmentedArray<T>::~GCSegmentedArray):
(JSC::GCSegmentedArray<T>::clear):
(JSC::GCSegmentedArray<T>::expand):
(JSC::GCSegmentedArray<T>::refill):
(JSC::GCArraySegment<T>::create):

• heap/GCThreadSharedData.cpp:

(JSC::GCThreadSharedData::GCThreadSharedData):

• heap/GCThreadSharedData.h: Feed the compiler.

• heap/HandleBlock.h:
• heap/HandleBlockInlines.h:

(JSC::HandleBlock::create):
(JSC::HandleBlock::HandleBlock):
(JSC::HandleBlock::payloadEnd):

• heap/HandleSet.cpp:

(JSC::HandleSet::~HandleSet):
(JSC::HandleSet::grow): Same as above.

• heap/Heap.cpp:

(JSC::Heap::Heap):

• heap/Heap.h: Removed the block allocator since it is unused now.

• heap/HeapBlock.h:

(JSC::HeapBlock::destroy):
(JSC::HeapBlock::HeapBlock):
(JSC::HeapBlock::region): Deleted. Removed the Region pointer from each
HeapBlock since a HeapBlock is just a normal allocation now.

• heap/HeapInlines.h:

(JSC::Heap::blockAllocator): Deleted.

• heap/HeapTimer.cpp:
• heap/MarkStack.cpp:

(JSC::MarkStackArray::MarkStackArray):

• heap/MarkStack.h: Feed the compiler.

• heap/MarkedAllocator.cpp:

(JSC::MarkedAllocator::allocateBlock): No need to use a custom code path
based on size, since we use a general purpose allocator now.

• heap/MarkedBlock.cpp:

(JSC::MarkedBlock::create):
(JSC::MarkedBlock::destroy):
(JSC::MarkedBlock::MarkedBlock):

• heap/MarkedBlock.h:

(JSC::MarkedBlock::capacity): Track block size explicitly, like CopiedBlock.

• heap/MarkedSpace.cpp:

(JSC::MarkedSpace::freeBlock):

• heap/MarkedSpace.h:

• heap/Region.h: Removed.

• heap/SlotVisitor.cpp:

(JSC::SlotVisitor::SlotVisitor): Removed reference to block allocator.

• heap/SuperRegion.cpp: Removed.
• heap/SuperRegion.h: Removed.

• heap/WeakBlock.cpp:

(JSC::WeakBlock::create):
(JSC::WeakBlock::WeakBlock):

• heap/WeakBlock.h:
• heap/WeakSet.cpp:

(JSC::WeakSet::~WeakSet):
(JSC::WeakSet::addAllocator):
(JSC::WeakSet::removeAllocator): Removed reference to block allocator.

Source/WebCore:

• platform/cocoa/MemoryPressureHandlerCocoa.mm:

(WebCore::MemoryPressureHandler::install): Be sure to release other
memory after GC and not before, since GC might contribute to free
malloc pages now.

Source/WTF:

New interface for aligned allocation: fastAlignedMalloc / fastAlignedFree.
We require a special function call on free because Windows.

• wtf/FastMalloc.cpp:

(WTF::fastAlignedMalloc):
(WTF::fastAlignedFree): Do it.

(WTF::do_memalign): Un-ifdef this, since we use it now.

• wtf/FastMalloc.h: Make our new function names visible like the rest

of fastMalloc.

File:

• trunk/Source/JavaScriptCore/heap/CopiedBlock.h (modified) (10 diffs)

trunk/Source/JavaScriptCore/heap/CopiedBlock.h

@@ -27 +27 @@
 #define CopiedBlock_h
 
-#include "BlockAllocator.h"
 #include "CopyWorkList.h"
 #include "HeapBlock.h"
@@ -33 +32 @@
 #include "Options.h"
 #include <wtf/Atomics.h>
+#include <wtf/TCSpinLock.h>
 
 namespace JSC {
@@ -42 +42 @@
     friend class CopiedAllocator;
 public:
-    static CopiedBlock* create(DeadBlock*);
-    static CopiedBlock* createNoZeroFill(DeadBlock*);
+    static CopiedBlock* create(size_t);
+    static CopiedBlock* createNoZeroFill(size_t);
 
     void pin();
@@ -87 +87 @@
 
 private:
-    CopiedBlock(Region*);
+    CopiedBlock(size_t);
     void zeroFillWilderness(); // Can be called at any time to zero-fill to the end of the block.
 
@@ -95 +95 @@
     std::unique_ptr<CopyWorkList> m_workList;
 
+    size_t m_blockSize;
     size_t m_remaining;
     bool m_isPinned : 1;
@@ -104 +105 @@
 };
 
-inline CopiedBlock* CopiedBlock::createNoZeroFill(DeadBlock* block)
-{
-    Region* region = block->region();
-    return new(NotNull, block) CopiedBlock(region);
-}
-
-inline CopiedBlock* CopiedBlock::create(DeadBlock* block)
-{
-    CopiedBlock* newBlock = createNoZeroFill(block);
+inline CopiedBlock* CopiedBlock::createNoZeroFill(size_t blockSize)
+{
+    return new(NotNull, fastAlignedMalloc(CopiedBlock::blockSize, blockSize)) CopiedBlock(blockSize);
+}
+
+inline CopiedBlock* CopiedBlock::create(size_t blockSize)
+{
+    CopiedBlock* newBlock = createNoZeroFill(blockSize);
     newBlock->zeroFillWilderness();
     return newBlock;
@@ -129 +129 @@
 }
 
-inline CopiedBlock::CopiedBlock(Region* region)
-    : HeapBlock<CopiedBlock>(region)
+inline CopiedBlock::CopiedBlock(size_t blockSize)
+    : HeapBlock<CopiedBlock>()
+    , m_blockSize(blockSize)
     , m_remaining(payloadCapacity())
     , m_isPinned(false)
@@ -204 +205 @@
 inline bool CopiedBlock::isOversize()
 {
-    return region()->isCustomSize();
+    return m_blockSize != blockSize;
 }
 
@@ -220 +221 @@
 inline char* CopiedBlock::payloadEnd()
 {
-    return reinterpret_cast<char*>(this) + region()->blockSize();
+    return reinterpret_cast<char*>(this) + m_blockSize;
 }
 
@@ -265 +266 @@
 inline size_t CopiedBlock::capacity()
 {
-    return region()->blockSize();
+    return m_blockSize;
 }