Changeset 162017 in webkit for trunk/Source/JavaScriptCore/heap/CopiedBlockInlines.h

Timestamp:

Jan 14, 2014, 3:03:01 PM (11 years ago)

Author:

[email protected]

Message:

Copying should be generational
​https://bugs.webkit.org/show_bug.cgi?id=126555

Reviewed by Geoffrey Garen.

This patch adds support for copying to our generational collector. Eden collections
always trigger copying. Full collections use our normal fragmentation-based heuristics.

The way this works is that the CopiedSpace now has the notion of an old generation set of CopiedBlocks
and a new generation of CopiedBlocks. During each mutator cycle new CopiedSpace allocations reside
in the new generation. When a collection occurs, those blocks are moved to the old generation.

One key thing to remember is that both new and old generation objects in the MarkedSpace can
refer to old or new generation allocations in CopiedSpace. This is why we must fire write barriers
when assigning to an old (MarkedSpace) object's Butterfly.

• heap/CopiedAllocator.h:

(JSC::CopiedAllocator::tryAllocateDuringCopying):

• heap/CopiedBlock.h:

(JSC::CopiedBlock::CopiedBlock):
(JSC::CopiedBlock::didEvacuateBytes):
(JSC::CopiedBlock::isOld):
(JSC::CopiedBlock::didPromote):

• heap/CopiedBlockInlines.h:

(JSC::CopiedBlock::reportLiveBytes):
(JSC::CopiedBlock::reportLiveBytesDuringCopying):

• heap/CopiedSpace.cpp:

(JSC::CopiedSpace::CopiedSpace):
(JSC::CopiedSpace::~CopiedSpace):
(JSC::CopiedSpace::init):
(JSC::CopiedSpace::tryAllocateOversize):
(JSC::CopiedSpace::tryReallocateOversize):
(JSC::CopiedSpace::doneFillingBlock):
(JSC::CopiedSpace::didStartFullCollection):
(JSC::CopiedSpace::doneCopying):
(JSC::CopiedSpace::size):
(JSC::CopiedSpace::capacity):
(JSC::CopiedSpace::isPagedOut):

• heap/CopiedSpace.h:

(JSC::CopiedSpace::CopiedGeneration::CopiedGeneration):

• heap/CopiedSpaceInlines.h:

(JSC::CopiedSpace::contains):
(JSC::CopiedSpace::recycleEvacuatedBlock):
(JSC::CopiedSpace::allocateBlock):
(JSC::CopiedSpace::startedCopying):

• heap/CopyVisitor.cpp:

(JSC::CopyVisitor::copyFromShared):

• heap/CopyVisitorInlines.h:

(JSC::CopyVisitor::allocateNewSpace):
(JSC::CopyVisitor::allocateNewSpaceSlow):

• heap/GCThreadSharedData.cpp:

(JSC::GCThreadSharedData::didStartCopying):

• heap/Heap.cpp:

(JSC::Heap::copyBackingStores):

• heap/SlotVisitorInlines.h:

(JSC::SlotVisitor::copyLater):

• heap/TinyBloomFilter.h:

(JSC::TinyBloomFilter::add):

File:

• trunk/Source/JavaScriptCore/heap/CopiedBlockInlines.h (modified) (2 diffs)

trunk/Source/JavaScriptCore/heap/CopiedBlockInlines.h

@@ -27 +27 @@
 #define CopiedBlockInlines_h
 
+#include "ClassInfo.h"
 #include "CopiedBlock.h"
 #include "Heap.h"
+#include "MarkedBlock.h"
 
 namespace JSC {
     
-inline void CopiedBlock::reportLiveBytes(JSCell* owner, CopyToken token, unsigned bytes)
+inline bool CopiedBlock::shouldReportLiveBytes(SpinLockHolder&, JSCell* owner)
 {
-#if ENABLE(PARALLEL_GC)
-    SpinLockHolder locker(&m_workListLock);
-#endif
+    // We want to add to live bytes if the owner isn't part of the remembered set or
+    // if this block was allocated during the last cycle. 
+    // If we always added live bytes we would double count for elements in the remembered
+    // set across collections. 
+    // If we didn't always add live bytes to new blocks, we'd get too few.
+    bool ownerIsRemembered = MarkedBlock::blockFor(owner)->isRemembered(owner);
+    return !ownerIsRemembered || !m_isOld;
+}
+
+inline void CopiedBlock::reportLiveBytes(SpinLockHolder&, JSCell* owner, CopyToken token, unsigned bytes)
+{
+    checkConsistency();
 #ifndef NDEBUG
-    checkConsistency();
     m_liveObjects++;
 #endif
     m_liveBytes += bytes;
+    checkConsistency();
+    ASSERT(m_liveBytes <= CopiedBlock::blockSize);
 
     if (isPinned())
@@ -57 +69 @@
 }
 
+inline void CopiedBlock::reportLiveBytesDuringCopying(unsigned bytes)
+{
+    checkConsistency();
+    // This doesn't need to be locked because the thread that calls this function owns the current block.
+    m_isOld = true;
+#ifndef NDEBUG
+    m_liveObjects++;
+#endif
+    m_liveBytes += bytes;
+    checkConsistency();
+    ASSERT(m_liveBytes <= CopiedBlock::blockSize);
+}
+
 } // namespace JSC