Unreviewed, rolling out r161540.
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 9 Jan 2014 17:21:02 +0000 (17:21 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 9 Jan 2014 17:21:02 +0000 (17:21 +0000)
http://trac.webkit.org/changeset/161540
https://bugs.webkit.org/show_bug.cgi?id=126704

Caused assertion failures on multiple tests (Requested by ap
on #webkit).

Source/JavaScriptCore:

* bytecode/CodeBlock.cpp:
(JSC::CodeBlock::visitAggregate):
* bytecode/CodeBlock.h:
(JSC::CodeBlockSet::mark):
* dfg/DFGOperations.cpp:
* heap/CodeBlockSet.cpp:
(JSC::CodeBlockSet::add):
(JSC::CodeBlockSet::traceMarked):
* heap/CodeBlockSet.h:
* heap/CopiedBlockInlines.h:
(JSC::CopiedBlock::reportLiveBytes):
* heap/CopiedSpace.cpp:
* heap/CopiedSpace.h:
* heap/Heap.cpp:
(JSC::Heap::Heap):
(JSC::Heap::didAbandon):
(JSC::Heap::markRoots):
(JSC::Heap::copyBackingStores):
(JSC::Heap::collectAllGarbage):
(JSC::Heap::collect):
(JSC::Heap::didAllocate):
* heap/Heap.h:
(JSC::Heap::shouldCollect):
(JSC::Heap::isCollecting):
(JSC::Heap::isWriteBarrierEnabled):
(JSC::Heap::writeBarrier):
* heap/HeapOperation.h:
* heap/MarkStack.cpp:
(JSC::MarkStackArray::~MarkStackArray):
* heap/MarkStack.h:
* heap/MarkedAllocator.cpp:
(JSC::MarkedAllocator::isPagedOut):
(JSC::MarkedAllocator::tryAllocateHelper):
(JSC::MarkedAllocator::addBlock):
(JSC::MarkedAllocator::removeBlock):
* heap/MarkedAllocator.h:
(JSC::MarkedAllocator::MarkedAllocator):
(JSC::MarkedAllocator::reset):
* heap/MarkedBlock.cpp:
* heap/MarkedBlock.h:
(JSC::MarkedBlock::lastChanceToFinalize):
(JSC::MarkedBlock::didConsumeEmptyFreeList):
(JSC::MarkedBlock::clearMarks):
* heap/MarkedSpace.cpp:
(JSC::MarkedSpace::~MarkedSpace):
(JSC::MarkedSpace::resetAllocators):
(JSC::MarkedSpace::visitWeakSets):
(JSC::MarkedSpace::reapWeakSets):
* heap/MarkedSpace.h:
(JSC::ClearMarks::operator()):
(JSC::MarkedSpace::clearMarks):
* heap/SlotVisitor.cpp:
(JSC::SlotVisitor::~SlotVisitor):
* heap/SlotVisitor.h:
(JSC::SlotVisitor::sharedData):
* heap/SlotVisitorInlines.h:
(JSC::SlotVisitor::internalAppend):
(JSC::SlotVisitor::copyLater):
(JSC::SlotVisitor::reportExtraMemoryUsage):
* jit/Repatch.cpp:
* runtime/JSGenericTypedArrayViewInlines.h:
(JSC::JSGenericTypedArrayView<Adaptor>::visitChildren):
* runtime/JSPropertyNameIterator.h:
(JSC::StructureRareData::setEnumerationCache):
* runtime/JSString.cpp:
(JSC::JSString::visitChildren):
* runtime/StructureRareDataInlines.h:
(JSC::StructureRareData::setPreviousID):
(JSC::StructureRareData::setObjectToStringValue):
* runtime/WeakMapData.cpp:
(JSC::WeakMapData::visitChildren):

Source/WTF:

* wtf/Bitmap.h:
(WTF::WordType>::count):

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@161557 268f45cc-cd09-0410-ab3c-d52691b4dbfc

31 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/bytecode/CodeBlock.cpp
Source/JavaScriptCore/bytecode/CodeBlock.h
Source/JavaScriptCore/dfg/DFGOperations.cpp
Source/JavaScriptCore/heap/CodeBlockSet.cpp
Source/JavaScriptCore/heap/CodeBlockSet.h
Source/JavaScriptCore/heap/CopiedBlockInlines.h
Source/JavaScriptCore/heap/CopiedSpace.cpp
Source/JavaScriptCore/heap/CopiedSpace.h
Source/JavaScriptCore/heap/Heap.cpp
Source/JavaScriptCore/heap/Heap.h
Source/JavaScriptCore/heap/HeapOperation.h
Source/JavaScriptCore/heap/MarkStack.cpp
Source/JavaScriptCore/heap/MarkStack.h
Source/JavaScriptCore/heap/MarkedAllocator.cpp
Source/JavaScriptCore/heap/MarkedAllocator.h
Source/JavaScriptCore/heap/MarkedBlock.cpp
Source/JavaScriptCore/heap/MarkedBlock.h
Source/JavaScriptCore/heap/MarkedSpace.cpp
Source/JavaScriptCore/heap/MarkedSpace.h
Source/JavaScriptCore/heap/SlotVisitor.cpp
Source/JavaScriptCore/heap/SlotVisitor.h
Source/JavaScriptCore/heap/SlotVisitorInlines.h
Source/JavaScriptCore/jit/Repatch.cpp
Source/JavaScriptCore/runtime/JSGenericTypedArrayViewInlines.h
Source/JavaScriptCore/runtime/JSPropertyNameIterator.h
Source/JavaScriptCore/runtime/JSString.cpp
Source/JavaScriptCore/runtime/StructureRareDataInlines.h
Source/JavaScriptCore/runtime/WeakMapData.cpp
Source/WTF/ChangeLog
Source/WTF/wtf/Bitmap.h

index ab128c2..b4b2357 100644 (file)
@@ -1,3 +1,84 @@
+2014-01-09  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r161540.
+        http://trac.webkit.org/changeset/161540
+        https://bugs.webkit.org/show_bug.cgi?id=126704
+
+        Caused assertion failures on multiple tests (Requested by ap
+        on #webkit).
+
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::visitAggregate):
+        * bytecode/CodeBlock.h:
+        (JSC::CodeBlockSet::mark):
+        * dfg/DFGOperations.cpp:
+        * heap/CodeBlockSet.cpp:
+        (JSC::CodeBlockSet::add):
+        (JSC::CodeBlockSet::traceMarked):
+        * heap/CodeBlockSet.h:
+        * heap/CopiedBlockInlines.h:
+        (JSC::CopiedBlock::reportLiveBytes):
+        * heap/CopiedSpace.cpp:
+        * heap/CopiedSpace.h:
+        * heap/Heap.cpp:
+        (JSC::Heap::Heap):
+        (JSC::Heap::didAbandon):
+        (JSC::Heap::markRoots):
+        (JSC::Heap::copyBackingStores):
+        (JSC::Heap::collectAllGarbage):
+        (JSC::Heap::collect):
+        (JSC::Heap::didAllocate):
+        * heap/Heap.h:
+        (JSC::Heap::shouldCollect):
+        (JSC::Heap::isCollecting):
+        (JSC::Heap::isWriteBarrierEnabled):
+        (JSC::Heap::writeBarrier):
+        * heap/HeapOperation.h:
+        * heap/MarkStack.cpp:
+        (JSC::MarkStackArray::~MarkStackArray):
+        * heap/MarkStack.h:
+        * heap/MarkedAllocator.cpp:
+        (JSC::MarkedAllocator::isPagedOut):
+        (JSC::MarkedAllocator::tryAllocateHelper):
+        (JSC::MarkedAllocator::addBlock):
+        (JSC::MarkedAllocator::removeBlock):
+        * heap/MarkedAllocator.h:
+        (JSC::MarkedAllocator::MarkedAllocator):
+        (JSC::MarkedAllocator::reset):
+        * heap/MarkedBlock.cpp:
+        * heap/MarkedBlock.h:
+        (JSC::MarkedBlock::lastChanceToFinalize):
+        (JSC::MarkedBlock::didConsumeEmptyFreeList):
+        (JSC::MarkedBlock::clearMarks):
+        * heap/MarkedSpace.cpp:
+        (JSC::MarkedSpace::~MarkedSpace):
+        (JSC::MarkedSpace::resetAllocators):
+        (JSC::MarkedSpace::visitWeakSets):
+        (JSC::MarkedSpace::reapWeakSets):
+        * heap/MarkedSpace.h:
+        (JSC::ClearMarks::operator()):
+        (JSC::MarkedSpace::clearMarks):
+        * heap/SlotVisitor.cpp:
+        (JSC::SlotVisitor::~SlotVisitor):
+        * heap/SlotVisitor.h:
+        (JSC::SlotVisitor::sharedData):
+        * heap/SlotVisitorInlines.h:
+        (JSC::SlotVisitor::internalAppend):
+        (JSC::SlotVisitor::copyLater):
+        (JSC::SlotVisitor::reportExtraMemoryUsage):
+        * jit/Repatch.cpp:
+        * runtime/JSGenericTypedArrayViewInlines.h:
+        (JSC::JSGenericTypedArrayView<Adaptor>::visitChildren):
+        * runtime/JSPropertyNameIterator.h:
+        (JSC::StructureRareData::setEnumerationCache):
+        * runtime/JSString.cpp:
+        (JSC::JSString::visitChildren):
+        * runtime/StructureRareDataInlines.h:
+        (JSC::StructureRareData::setPreviousID):
+        (JSC::StructureRareData::setObjectToStringValue):
+        * runtime/WeakMapData.cpp:
+        (JSC::WeakMapData::visitChildren):
+
 2014-01-09  Andreas Kling  <akling@apple.com>
 
         Shrink WatchpointSet.
index 462c062..a2aaa1d 100644 (file)
@@ -1954,15 +1954,15 @@ void CodeBlock::visitAggregate(SlotVisitor& visitor)
     if (CodeBlock* otherBlock = specialOSREntryBlockOrNull())
         otherBlock->visitAggregate(visitor);
 
-    visitor.reportExtraMemoryUsage(ownerExecutable(), sizeof(CodeBlock));
+    visitor.reportExtraMemoryUsage(sizeof(CodeBlock));
     if (m_jitCode)
-        visitor.reportExtraMemoryUsage(ownerExecutable(), m_jitCode->size());
+        visitor.reportExtraMemoryUsage(m_jitCode->size());
     if (m_instructions.size()) {
         // Divide by refCount() because m_instructions points to something that is shared
         // by multiple CodeBlocks, and we only want to count it towards the heap size once.
         // Having each CodeBlock report only its proportional share of the size is one way
         // of accomplishing this.
-        visitor.reportExtraMemoryUsage(ownerExecutable(), m_instructions.size() * sizeof(Instruction) / m_instructions.refCount());
+        visitor.reportExtraMemoryUsage(m_instructions.size() * sizeof(Instruction) / m_instructions.refCount());
     }
 
     visitor.append(&m_unlinkedCode);
index 5edadbf..2ff11a9 100644 (file)
@@ -1269,7 +1269,6 @@ inline void CodeBlockSet::mark(void* candidateCodeBlock)
         return;
     
     (*iter)->m_mayBeExecuting = true;
-    m_currentlyExecuting.append(static_cast<CodeBlock*>(candidateCodeBlock));
 }
 
 } // namespace JSC
index b31b6fc..eb63aee 100644 (file)
@@ -850,7 +850,6 @@ char* JIT_OPERATION operationReallocateButterflyToHavePropertyStorageWithInitial
     NativeCallFrameTracer tracer(&vm, exec);
 
     ASSERT(!object->structure()->outOfLineCapacity());
-    DeferGC deferGC(vm.heap);
     Butterfly* result = object->growOutOfLineStorage(vm, 0, initialOutOfLineCapacity);
     object->setButterflyWithoutChangingStructure(vm, result);
     return reinterpret_cast<char*>(result);
@@ -861,7 +860,6 @@ char* JIT_OPERATION operationReallocateButterflyToGrowPropertyStorage(ExecState*
     VM& vm = exec->vm();
     NativeCallFrameTracer tracer(&vm, exec);
 
-    DeferGC deferGC(vm.heap);
     Butterfly* result = object->growOutOfLineStorage(vm, object->structure()->outOfLineCapacity(), newSize);
     object->setButterflyWithoutChangingStructure(vm, result);
     return reinterpret_cast<char*>(result);
index f596872..ae27480 100644 (file)
@@ -45,8 +45,7 @@ CodeBlockSet::~CodeBlockSet()
 
 void CodeBlockSet::add(PassRefPtr<CodeBlock> codeBlock)
 {
-    CodeBlock* block = codeBlock.leakRef();
-    bool isNewEntry = m_set.add(block).isNewEntry;
+    bool isNewEntry = m_set.add(codeBlock.leakRef()).isNewEntry;
     ASSERT_UNUSED(isNewEntry, isNewEntry);
 }
 
@@ -102,16 +101,9 @@ void CodeBlockSet::traceMarked(SlotVisitor& visitor)
         CodeBlock* codeBlock = *iter;
         if (!codeBlock->m_mayBeExecuting)
             continue;
-        codeBlock->ownerExecutable()->visitChildren(codeBlock->ownerExecutable(), visitor);
+        codeBlock->visitAggregate(visitor);
     }
 }
 
-void CodeBlockSet::rememberCurrentlyExecutingCodeBlocks(Heap* heap)
-{
-    for (size_t i = 0; i < m_currentlyExecuting.size(); ++i)
-        heap->addToRememberedSet(m_currentlyExecuting[i]->ownerExecutable());
-    m_currentlyExecuting.clear();
-}
-
 } // namespace JSC
 
index bb786f0..2e4e606 100644 (file)
 #include <wtf/Noncopyable.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
-#include <wtf/Vector.h>
 
 namespace JSC {
 
 class CodeBlock;
-class Heap;
 class SlotVisitor;
 
 // CodeBlockSet tracks all CodeBlocks. Every CodeBlock starts out with one
@@ -67,16 +65,11 @@ public:
     // mayBeExecuting.
     void traceMarked(SlotVisitor&);
 
-    // Add all currently executing CodeBlocks to the remembered set to be 
-    // re-scanned during the next collection.
-    void rememberCurrentlyExecutingCodeBlocks(Heap*);
-
 private:
     // This is not a set of RefPtr<CodeBlock> because we need to be able to find
     // arbitrary bogus pointers. I could have written a thingy that had peek types
     // and all, but that seemed like overkill.
     HashSet<CodeBlock* > m_set;
-    Vector<CodeBlock*> m_currentlyExecuting;
 };
 
 } // namespace JSC
index 150b4c7..61996ce 100644 (file)
@@ -42,9 +42,6 @@ inline void CopiedBlock::reportLiveBytes(JSCell* owner, CopyToken token, unsigne
 #endif
     m_liveBytes += bytes;
 
-    if (isPinned())
-        return;
-
     if (!shouldEvacuate()) {
         pin();
         return;
index 9601634..f0e7722 100644 (file)
@@ -316,17 +316,4 @@ bool CopiedSpace::isPagedOut(double deadline)
         || isBlockListPagedOut(deadline, &m_oversizeBlocks);
 }
 
-void CopiedSpace::didStartFullCollection()
-{
-    ASSERT(heap()->operationInProgress() == FullCollection);
-
-    ASSERT(m_fromSpace->isEmpty());
-
-    for (CopiedBlock* block = m_toSpace->head(); block; block = block->next())
-        block->didSurviveGC();
-
-    for (CopiedBlock* block = m_oversizeBlocks.head(); block; block = block->next())
-        block->didSurviveGC();
-}
-
 } // namespace JSC
index 5fca45a..65ca04e 100644 (file)
@@ -60,8 +60,6 @@ public:
     
     CopiedAllocator& allocator() { return m_allocator; }
 
-    void didStartFullCollection();
-
     void startedCopying();
     void doneCopying();
     bool isInCopyPhase() { return m_inCopyingPhase; }
@@ -82,8 +80,6 @@ public:
 
     static CopiedBlock* blockFor(void*);
 
-    Heap* heap() const { return m_heap; }
-
 private:
     static bool isOversize(size_t);
 
index ceb5709..307c30c 100644 (file)
@@ -253,11 +253,9 @@ Heap::Heap(VM* vm, HeapType heapType)
     , m_ramSize(ramSize())
     , m_minBytesPerCycle(minHeapSize(m_heapType, m_ramSize))
     , m_sizeAfterLastCollect(0)
-    , m_bytesAllocatedThisCycle(0)
-    , m_bytesAbandonedThisCycle(0)
-    , m_maxEdenSize(m_minBytesPerCycle)
-    , m_maxHeapSize(m_minBytesPerCycle)
-    , m_shouldDoFullCollection(false)
+    , m_bytesAllocatedLimit(m_minBytesPerCycle)
+    , m_bytesAllocated(0)
+    , m_bytesAbandoned(0)
     , m_totalBytesVisited(0)
     , m_totalBytesCopied(0)
     , m_operationInProgress(NoOperation)
@@ -271,7 +269,7 @@ Heap::Heap(VM* vm, HeapType heapType)
     , m_copyVisitor(m_sharedData)
     , m_handleSet(vm)
     , m_isSafeToCollect(false)
-    , m_writeBarrierBuffer(256)
+    , m_writeBarrierBuffer(128)
     , m_vm(vm)
     , m_lastGCLength(0)
     , m_lastCodeDiscardTime(WTF::monotonicallyIncreasingTime())
@@ -334,8 +332,8 @@ void Heap::reportAbandonedObjectGraph()
 void Heap::didAbandon(size_t bytes)
 {
     if (m_activityCallback)
-        m_activityCallback->didAllocate(m_bytesAllocatedThisCycle + m_bytesAbandonedThisCycle);
-    m_bytesAbandonedThisCycle += bytes;
+        m_activityCallback->didAllocate(m_bytesAllocated + m_bytesAbandoned);
+    m_bytesAbandoned += bytes;
 }
 
 void Heap::protect(JSValue k)
@@ -489,9 +487,6 @@ void Heap::markRoots()
     visitor.setup();
     HeapRootVisitor heapRootVisitor(visitor);
 
-    Vector<const JSCell*> rememberedSet(m_slotVisitor.markStack().size());
-    m_slotVisitor.markStack().fillVector(rememberedSet);
-
     {
         ParallelModeEnabler enabler(visitor);
 
@@ -595,14 +590,6 @@ void Heap::markRoots()
         }
     }
 
-    {
-        GCPHASE(ClearRememberedSet);
-        for (unsigned i = 0; i < rememberedSet.size(); ++i) {
-            const JSCell* cell = rememberedSet[i];
-            MarkedBlock::blockFor(cell)->clearRemembered(cell);
-        }
-    }
-
     GCCOUNTER(VisitedValueCount, visitor.visitCount());
 
     m_sharedData.didFinishMarking();
@@ -614,14 +601,8 @@ void Heap::markRoots()
     MARK_LOG_MESSAGE2("\nNumber of live Objects after full GC %lu, took %.6f secs\n", visitCount, WTF::monotonicallyIncreasingTime() - gcStartTime);
 #endif
 
-    if (m_operationInProgress == EdenCollection) {
-        m_totalBytesVisited += visitor.bytesVisited();
-        m_totalBytesCopied += visitor.bytesCopied();
-    } else {
-        ASSERT(m_operationInProgress == FullCollection);
-        m_totalBytesVisited = visitor.bytesVisited();
-        m_totalBytesCopied = visitor.bytesCopied();
-    }
+    m_totalBytesVisited = visitor.bytesVisited();
+    m_totalBytesCopied = visitor.bytesCopied();
 #if ENABLE(PARALLEL_GC)
     m_totalBytesVisited += m_sharedData.childBytesVisited();
     m_totalBytesCopied += m_sharedData.childBytesCopied();
@@ -634,12 +615,8 @@ void Heap::markRoots()
     m_sharedData.reset();
 }
 
-template <HeapOperation collectionType>
 void Heap::copyBackingStores()
 {
-    if (collectionType == EdenCollection)
-        return;
-
     m_storageSpace.startedCopying();
     if (m_storageSpace.shouldDoCopyPhase()) {
         m_sharedData.didStartCopying();
@@ -650,7 +627,7 @@ void Heap::copyBackingStores()
         // before signaling that the phase is complete.
         m_storageSpace.doneCopying();
         m_sharedData.didFinishCopying();
-    } else
+    } else 
         m_storageSpace.doneCopying();
 }
 
@@ -746,23 +723,11 @@ void Heap::deleteUnmarkedCompiledCode()
     m_jitStubRoutines.deleteUnmarkedJettisonedStubRoutines();
 }
 
-void Heap::addToRememberedSet(const JSCell* cell)
-{
-    ASSERT(cell);
-    ASSERT(!Options::enableConcurrentJIT() || !isCompilationThread());
-    ASSERT(isMarked(cell));
-    if (isInRememberedSet(cell))
-        return;
-    MarkedBlock::blockFor(cell)->setRemembered(cell);
-    m_slotVisitor.unconditionallyAppend(const_cast<JSCell*>(cell));
-}
-
 void Heap::collectAllGarbage()
 {
     if (!m_isSafeToCollect)
         return;
 
-    m_shouldDoFullCollection = true;
     collect();
 
     SamplingRegion samplingRegion("Garbage Collection: Sweeping");
@@ -799,28 +764,9 @@ void Heap::collect()
         RecursiveAllocationScope scope(*this);
         m_vm->prepareToDiscardCode();
     }
-
-    bool isFullCollection = m_shouldDoFullCollection;
-    if (isFullCollection) {
-        m_operationInProgress = FullCollection;
-        m_slotVisitor.clearMarkStack();
-        m_shouldDoFullCollection = false;
-        if (Options::logGC())
-            dataLog("FullCollection, ");
-    } else {
-#if ENABLE(GGC)
-        m_operationInProgress = EdenCollection;
-        if (Options::logGC())
-            dataLog("EdenCollection, ");
-#else
-        m_operationInProgress = FullCollection;
-        m_slotVisitor.clearMarkStack();
-        if (Options::logGC())
-            dataLog("FullCollection, ");
-#endif
-    }
-    if (m_operationInProgress == FullCollection)
-        m_extraMemoryUsage = 0;
+    
+    m_operationInProgress = Collection;
+    m_extraMemoryUsage = 0;
 
     if (m_activityCallback)
         m_activityCallback->willCollect();
@@ -834,16 +780,6 @@ void Heap::collect()
     {
         GCPHASE(StopAllocation);
         m_objectSpace.stopAllocating();
-        if (m_operationInProgress == FullCollection)
-            m_storageSpace.didStartFullCollection();
-    }
-
-    {
-        GCPHASE(FlushWriteBarrierBuffer);
-        if (m_operationInProgress == EdenCollection)
-            m_writeBarrierBuffer.flush(*this);
-        else
-            m_writeBarrierBuffer.reset();
     }
 
     markRoots();
@@ -860,16 +796,13 @@ void Heap::collect()
         m_arrayBuffers.sweep();
     }
 
-    if (m_operationInProgress == FullCollection) {
+    {
         m_blockSnapshot.resize(m_objectSpace.blocks().set().size());
         MarkedBlockSnapshotFunctor functor(m_blockSnapshot);
         m_objectSpace.forEachBlock(functor);
     }
 
-    if (m_operationInProgress == FullCollection)
-        copyBackingStores<FullCollection>();
-    else
-        copyBackingStores<EdenCollection>();
+    copyBackingStores();
 
     {
         GCPHASE(FinalizeUnconditionalFinalizers);
@@ -886,15 +819,8 @@ void Heap::collect()
         m_vm->clearSourceProviderCaches();
     }
 
-    if (m_operationInProgress == FullCollection)
-        m_sweeper->startSweeping(m_blockSnapshot);
-
-    {
-        GCPHASE(AddCurrentlyExecutingCodeBlocksToRememberedSet);
-        m_codeBlocks.rememberCurrentlyExecutingCodeBlocks(this);
-    }
-
-    m_bytesAbandonedThisCycle = 0;
+    m_sweeper->startSweeping(m_blockSnapshot);
+    m_bytesAbandoned = 0;
 
     {
         GCPHASE(ResetAllocators);
@@ -905,32 +831,21 @@ void Heap::collect()
     if (Options::gcMaxHeapSize() && currentHeapSize > Options::gcMaxHeapSize())
         HeapStatistics::exitWithFailure();
 
-    if (m_operationInProgress == FullCollection) {
-        // To avoid pathological GC churn in very small and very large heaps, we set
-        // the new allocation limit based on the current size of the heap, with a
-        // fixed minimum.
-        m_maxHeapSize = max(minHeapSize(m_heapType, m_ramSize), proportionalHeapSize(currentHeapSize, m_ramSize));
-        m_maxEdenSize = m_maxHeapSize - currentHeapSize;
-    } else {
-        ASSERT(currentHeapSize >= m_sizeAfterLastCollect);
-        m_maxEdenSize = m_maxHeapSize - currentHeapSize;
-        double edenToOldGenerationRatio = (double)m_maxEdenSize / (double)m_maxHeapSize;
-        double minEdenToOldGenerationRatio = 1.0 / 3.0;
-        if (edenToOldGenerationRatio < minEdenToOldGenerationRatio)
-            m_shouldDoFullCollection = true;
-        m_maxHeapSize += currentHeapSize - m_sizeAfterLastCollect;
-        m_maxEdenSize = m_maxHeapSize - currentHeapSize;
-    }
-
     m_sizeAfterLastCollect = currentHeapSize;
 
-    m_bytesAllocatedThisCycle = 0;
+    // To avoid pathological GC churn in very small and very large heaps, we set
+    // the new allocation limit based on the current size of the heap, with a
+    // fixed minimum.
+    size_t maxHeapSize = max(minHeapSize(m_heapType, m_ramSize), proportionalHeapSize(currentHeapSize, m_ramSize));
+    m_bytesAllocatedLimit = maxHeapSize - currentHeapSize;
+
+    m_bytesAllocated = 0;
     double lastGCEndTime = WTF::monotonicallyIncreasingTime();
     m_lastGCLength = lastGCEndTime - lastGCStartTime;
 
     if (Options::recordGCPauseTimes())
         HeapStatistics::recordGCPauseTime(lastGCStartTime, lastGCEndTime);
-    RELEASE_ASSERT(m_operationInProgress == EdenCollection || m_operationInProgress == FullCollection);
+    RELEASE_ASSERT(m_operationInProgress == Collection);
 
     m_operationInProgress = NoOperation;
     JAVASCRIPTCORE_GC_END();
@@ -948,6 +863,10 @@ void Heap::collect()
         double after = currentTimeMS();
         dataLog(after - before, " ms, ", currentHeapSize / 1024, " kb]\n");
     }
+
+#if ENABLE(ALLOCATION_LOGGING)
+    dataLogF("JSC GC finishing collection.\n");
+#endif
 }
 
 bool Heap::collectIfNecessaryOrDefer()
@@ -997,8 +916,8 @@ void Heap::setGarbageCollectionTimerEnabled(bool enable)
 void Heap::didAllocate(size_t bytes)
 {
     if (m_activityCallback)
-        m_activityCallback->didAllocate(m_bytesAllocatedThisCycle + m_bytesAbandonedThisCycle);
-    m_bytesAllocatedThisCycle += bytes;
+        m_activityCallback->didAllocate(m_bytesAllocated + m_bytesAbandoned);
+    m_bytesAllocated += bytes;
 }
 
 bool Heap::isValidAllocation(size_t)
@@ -1075,15 +994,6 @@ void Heap::decrementDeferralDepthAndGCIfNeeded()
     collectIfNecessaryOrDefer();
 }
 
-void Heap::writeBarrier(const JSCell* from)
-{
-    ASSERT_GC_OBJECT_LOOKS_VALID(const_cast<JSCell*>(from));
-    if (!from || !isMarked(from))
-        return;
-    Heap* heap = Heap::heap(from);
-    heap->addToRememberedSet(from);
-}
-
 void Heap::flushWriteBarrierBuffer(JSCell* cell)
 {
 #if ENABLE(GGC)
index ab580aa..ba4e801 100644 (file)
@@ -94,17 +94,11 @@ namespace JSC {
         static bool testAndSetMarked(const void*);
         static void setMarked(const void*);
 
-        JS_EXPORT_PRIVATE void addToRememberedSet(const JSCell*);
-        bool isInRememberedSet(const JSCell* cell) const
-        {
-            ASSERT(cell);
-            ASSERT(!Options::enableConcurrentJIT() || !isCompilationThread());
-            return MarkedBlock::blockFor(cell)->isRemembered(cell);
-        }
         static bool isWriteBarrierEnabled();
-        JS_EXPORT_PRIVATE static void writeBarrier(const JSCell*);
+        static void writeBarrier(const JSCell*);
         static void writeBarrier(const JSCell*, JSValue);
         static void writeBarrier(const JSCell*, JSCell*);
+        static uint8_t* addressOfCardFor(JSCell*);
 
         WriteBarrierBuffer& writeBarrierBuffer() { return m_writeBarrierBuffer; }
         void flushWriteBarrierBuffer(JSCell*);
@@ -126,7 +120,6 @@ namespace JSC {
 
         // true if collection is in progress
         inline bool isCollecting();
-        inline HeapOperation operationInProgress() { return m_operationInProgress; }
         // true if an allocation or collection is in progress
         inline bool isBusy();
         
@@ -243,7 +236,6 @@ namespace JSC {
         void markRoots();
         void markProtectedObjects(HeapRootVisitor&);
         void markTempSortVectors(HeapRootVisitor&);
-        template <HeapOperation collectionType>
         void copyBackingStores();
         void harvestWeakReferences();
         void finalizeUnconditionalFinalizers();
@@ -265,11 +257,10 @@ namespace JSC {
         const size_t m_minBytesPerCycle;
         size_t m_sizeAfterLastCollect;
 
-        size_t m_bytesAllocatedThisCycle;
-        size_t m_bytesAbandonedThisCycle;
-        size_t m_maxEdenSize;
-        size_t m_maxHeapSize;
-        bool m_shouldDoFullCollection;
+        size_t m_bytesAllocatedLimit;
+        size_t m_bytesAllocated;
+        size_t m_bytesAbandoned;
+
         size_t m_totalBytesVisited;
         size_t m_totalBytesCopied;
         
@@ -280,8 +271,6 @@ namespace JSC {
         GCIncomingRefCountedSet<ArrayBuffer> m_arrayBuffers;
         size_t m_extraMemoryUsage;
 
-        HashSet<const JSCell*> m_copyingRememberedSet;
-
         ProtectCountSet m_protectedValues;
         Vector<Vector<ValueStringPair, 0, UnsafeVectorOverflow>* > m_tempSortingVectors;
         OwnPtr<HashSet<MarkedArgumentBuffer*>> m_markListSet;
@@ -333,8 +322,8 @@ namespace JSC {
         if (isDeferred())
             return false;
         if (Options::gcMaxHeapSize())
-            return m_bytesAllocatedThisCycle > Options::gcMaxHeapSize() && m_isSafeToCollect && m_operationInProgress == NoOperation;
-        return m_bytesAllocatedThisCycle > m_maxEdenSize && m_isSafeToCollect && m_operationInProgress == NoOperation;
+            return m_bytesAllocated > Options::gcMaxHeapSize() && m_isSafeToCollect && m_operationInProgress == NoOperation;
+        return m_bytesAllocated > m_bytesAllocatedLimit && m_isSafeToCollect && m_operationInProgress == NoOperation;
     }
 
     bool Heap::isBusy()
@@ -344,7 +333,7 @@ namespace JSC {
 
     bool Heap::isCollecting()
     {
-        return m_operationInProgress == FullCollection || m_operationInProgress == EdenCollection;
+        return m_operationInProgress == Collection;
     }
 
     inline Heap* Heap::heap(const JSCell* cell)
@@ -381,33 +370,26 @@ namespace JSC {
 
     inline bool Heap::isWriteBarrierEnabled()
     {
-#if ENABLE(WRITE_BARRIER_PROFILING) || ENABLE(GGC)
+#if ENABLE(WRITE_BARRIER_PROFILING)
         return true;
 #else
         return false;
 #endif
     }
 
-    inline void Heap::writeBarrier(const JSCell* from, JSCell* to)
+    inline void Heap::writeBarrier(const JSCell*)
     {
-#if ENABLE(WRITE_BARRIER_PROFILING)
         WriteBarrierCounters::countWriteBarrier();
-#endif
-        if (!from || !isMarked(from))
-            return;
-        if (!to || isMarked(to))
-            return;
-        Heap::heap(from)->addToRememberedSet(from);
     }
 
-    inline void Heap::writeBarrier(const JSCell* from, JSValue to)
+    inline void Heap::writeBarrier(const JSCell*, JSCell*)
+    {
+        WriteBarrierCounters::countWriteBarrier();
+    }
+
+    inline void Heap::writeBarrier(const JSCell*, JSValue)
     {
-#if ENABLE(WRITE_BARRIER_PROFILING)
         WriteBarrierCounters::countWriteBarrier();
-#endif
-        if (!to.isCell())
-            return;
-        writeBarrier(from, to.asCell());
     }
 
     inline void Heap::reportExtraMemoryCost(size_t cost)
index 769127e..8f0a023 100644 (file)
@@ -28,7 +28,7 @@
 
 namespace JSC {
 
-enum HeapOperation { NoOperation, Allocation, FullCollection, EdenCollection };
+enum HeapOperation { NoOperation, Allocation, Collection };
 
 } // namespace JSC
 
index 688de42..39907c7 100644 (file)
@@ -57,29 +57,8 @@ MarkStackArray::MarkStackArray(BlockAllocator& blockAllocator)
 
 MarkStackArray::~MarkStackArray()
 {
-    ASSERT(m_numberOfSegments == 1);
-    ASSERT(m_segments.size() == 1);
+    ASSERT(m_numberOfSegments == 1 && m_segments.size() == 1);
     m_blockAllocator.deallocate(MarkStackSegment::destroy(m_segments.removeHead()));
-    m_numberOfSegments--;
-    ASSERT(!m_numberOfSegments);
-    ASSERT(!m_segments.size());
-}
-
-void MarkStackArray::clear()
-{
-    if (!m_segments.head())
-        return;
-    MarkStackSegment* next;
-    for (MarkStackSegment* current = m_segments.head(); current->next(); current = next) {
-        next = current->next();
-        m_segments.remove(current);
-        m_blockAllocator.deallocate(MarkStackSegment::destroy(current));
-    }
-    m_top = 0;
-    m_numberOfSegments = 1;
-#if !ASSERT_DISABLED
-    m_segments.head()->m_top = 0;
-#endif
 }
 
 void MarkStackArray::expand()
@@ -188,28 +167,4 @@ void MarkStackArray::stealSomeCellsFrom(MarkStackArray& other, size_t idleThread
         append(other.removeLast());
 }
 
-void MarkStackArray::fillVector(Vector<const JSCell*>& vector)
-{
-    ASSERT(vector.size() == size());
-
-    MarkStackSegment* currentSegment = m_segments.head();
-    if (!currentSegment)
-        return;
-
-    unsigned count = 0;
-    for (unsigned i = 0; i < m_top; ++i) {
-        ASSERT(currentSegment->data()[i]);
-        vector[count++] = currentSegment->data()[i];
-    }
-
-    currentSegment = currentSegment->next();
-    while (currentSegment) {
-        for (unsigned i = 0; i < s_segmentCapacity; ++i) {
-            ASSERT(currentSegment->data()[i]);
-            vector[count++] = currentSegment->data()[i];
-        }
-        currentSegment = currentSegment->next();
-    }
-}
-
 } // namespace JSC
index 6729bad..c97b6a7 100644 (file)
@@ -52,7 +52,6 @@
 
 #include "HeapBlock.h"
 #include <wtf/StdLibExtras.h>
-#include <wtf/Vector.h>
 
 namespace JSC {
 
@@ -101,9 +100,6 @@ public:
     size_t size();
     bool isEmpty();
 
-    void fillVector(Vector<const JSCell*>&);
-    void clear();
-
 private:
     template <size_t size> struct CapacityFromSize {
         static const size_t value = (size - sizeof(MarkStackSegment)) / sizeof(const JSCell*);
index c2b0f72..7440208 100644 (file)
 
 namespace JSC {
 
-static bool isListPagedOut(double deadline, DoublyLinkedList<MarkedBlock>& list)
+bool MarkedAllocator::isPagedOut(double deadline)
 {
     unsigned itersSinceLastTimeCheck = 0;
-    MarkedBlock* block = list.head();
+    MarkedBlock* block = m_blockList.head();
     while (block) {
         block = block->next();
         ++itersSinceLastTimeCheck;
@@ -24,13 +24,7 @@ static bool isListPagedOut(double deadline, DoublyLinkedList<MarkedBlock>& list)
             itersSinceLastTimeCheck = 0;
         }
     }
-    return false;
-}
 
-bool MarkedAllocator::isPagedOut(double deadline)
-{
-    if (isListPagedOut(deadline, m_blockList))
-        return true;
     return false;
 }
 
@@ -42,23 +36,15 @@ inline void* MarkedAllocator::tryAllocateHelper(size_t bytes)
     while (!m_freeList.head) {
         DelayedReleaseScope delayedReleaseScope(*m_markedSpace);
         if (m_currentBlock) {
-            ASSERT(m_currentBlock == m_nextBlockToSweep);
+            ASSERT(m_currentBlock == m_blocksToSweep);
             m_currentBlock->didConsumeFreeList();
-            m_nextBlockToSweep = m_currentBlock->next();
+            m_blocksToSweep = m_currentBlock->next();
         }
 
-        MarkedBlock* next;
-        for (MarkedBlock*& block = m_nextBlockToSweep; block; block = next) {
-            next = block->next();
-
+        for (MarkedBlock*& block = m_blocksToSweep; block; block = block->next()) {
             MarkedBlock::FreeList freeList = block->sweep(MarkedBlock::SweepToFreeList);
-            
             if (!freeList.head) {
                 block->didConsumeEmptyFreeList();
-                m_blockList.remove(block);
-                m_blockList.push(block);
-                if (!m_lastFullBlock)
-                    m_lastFullBlock = block;
                 continue;
             }
 
@@ -82,7 +68,6 @@ inline void* MarkedAllocator::tryAllocateHelper(size_t bytes)
     MarkedBlock::FreeCell* head = m_freeList.head;
     m_freeList.head = head->next;
     ASSERT(head);
-    m_markedSpace->didAllocateInBlock(m_currentBlock);
     return head;
 }
     
@@ -151,7 +136,7 @@ void MarkedAllocator::addBlock(MarkedBlock* block)
     ASSERT(!m_freeList.head);
     
     m_blockList.append(block);
-    m_nextBlockToSweep = m_currentBlock = block;
+    m_blocksToSweep = m_currentBlock = block;
     m_freeList = block->sweep(MarkedBlock::SweepToFreeList);
     m_markedSpace->didAddBlock(block);
 }
@@ -162,27 +147,9 @@ void MarkedAllocator::removeBlock(MarkedBlock* block)
         m_currentBlock = m_currentBlock->next();
         m_freeList = MarkedBlock::FreeList();
     }
-    if (m_nextBlockToSweep == block)
-        m_nextBlockToSweep = m_nextBlockToSweep->next();
-
-    if (block == m_lastFullBlock)
-        m_lastFullBlock = m_lastFullBlock->prev();
-    
+    if (m_blocksToSweep == block)
+        m_blocksToSweep = m_blocksToSweep->next();
     m_blockList.remove(block);
 }
 
-void MarkedAllocator::reset()
-{
-    m_lastActiveBlock = 0;
-    m_currentBlock = 0;
-    m_freeList = MarkedBlock::FreeList();
-    if (m_heap->operationInProgress() == FullCollection)
-        m_lastFullBlock = 0;
-
-    if (m_lastFullBlock)
-        m_nextBlockToSweep = m_lastFullBlock->next() ? m_lastFullBlock->next() : m_lastFullBlock;
-    else
-        m_nextBlockToSweep = m_blockList.head();
-}
-
 } // namespace JSC
index e0d3e89..3a629c3 100644 (file)
@@ -52,8 +52,7 @@ private:
     MarkedBlock::FreeList m_freeList;
     MarkedBlock* m_currentBlock;
     MarkedBlock* m_lastActiveBlock;
-    MarkedBlock* m_nextBlockToSweep;
-    MarkedBlock* m_lastFullBlock;
+    MarkedBlock* m_blocksToSweep;
     DoublyLinkedList<MarkedBlock> m_blockList;
     size_t m_cellSize;
     MarkedBlock::DestructorType m_destructorType;
@@ -69,8 +68,7 @@ inline ptrdiff_t MarkedAllocator::offsetOfFreeListHead()
 inline MarkedAllocator::MarkedAllocator()
     : m_currentBlock(0)
     , m_lastActiveBlock(0)
-    , m_nextBlockToSweep(0)
-    , m_lastFullBlock(0)
+    , m_blocksToSweep(0)
     , m_cellSize(0)
     , m_destructorType(MarkedBlock::None)
     , m_heap(0)
@@ -104,6 +102,14 @@ inline void* MarkedAllocator::allocate(size_t bytes)
     return head;
 }
 
+inline void MarkedAllocator::reset()
+{
+    m_lastActiveBlock = 0;
+    m_currentBlock = 0;
+    m_freeList = MarkedBlock::FreeList();
+    m_blocksToSweep = m_blockList.head();
+}
+
 inline void MarkedAllocator::stopAllocating()
 {
     ASSERT(!m_lastActiveBlock);
index 34a0931..1085804 100644 (file)
@@ -197,45 +197,6 @@ void MarkedBlock::stopAllocating(const FreeList& freeList)
     m_state = Marked;
 }
 
-void MarkedBlock::clearMarks()
-{
-    if (heap()->operationInProgress() == JSC::EdenCollection)
-        this->clearMarksWithCollectionType<EdenCollection>();
-    else
-        this->clearMarksWithCollectionType<FullCollection>();
-}
-
-void MarkedBlock::clearRememberedSet()
-{
-    m_rememberedSet.clearAll();
-}
-
-template <HeapOperation collectionType>
-void MarkedBlock::clearMarksWithCollectionType()
-{
-    ASSERT(collectionType == FullCollection || collectionType == EdenCollection);
-    HEAP_LOG_BLOCK_STATE_TRANSITION(this);
-
-    ASSERT(m_state != New && m_state != FreeListed);
-    if (collectionType == FullCollection) {
-        m_marks.clearAll();
-        m_rememberedSet.clearAll();
-    }
-
-    // This will become true at the end of the mark phase. We set it now to
-    // avoid an extra pass to do so later.
-    m_state = Marked;
-}
-
-void MarkedBlock::lastChanceToFinalize()
-{
-    m_weakSet.lastChanceToFinalize();
-
-    clearNewlyAllocated();
-    clearMarksWithCollectionType<FullCollection>();
-    sweep();
-}
-
 MarkedBlock::FreeList MarkedBlock::resumeAllocating()
 {
     HEAP_LOG_BLOCK_STATE_TRANSITION(this);
index 73f56cd..2f1bfbd 100644 (file)
@@ -25,7 +25,6 @@
 #include "BlockAllocator.h"
 #include "HeapBlock.h"
 
-#include "HeapOperation.h"
 #include "WeakSet.h"
 #include <wtf/Bitmap.h>
 #include <wtf/DataLog.h>
@@ -73,7 +72,7 @@ namespace JSC {
         friend class LLIntOffsetsExtractor;
 
     public:
-        static const size_t atomSize = 16; // bytes
+        static const size_t atomSize = 8; // bytes
         static const size_t atomShiftAmount = 4; // log_2(atomSize) FIXME: Change atomSize to 16.
         static const size_t blockSize = 64 * KB;
         static const size_t blockMask = ~(blockSize - 1); // blockSize must be a power of two.
@@ -141,16 +140,11 @@ namespace JSC {
         void stopAllocating(const FreeList&);
         FreeList resumeAllocating(); // Call this if you canonicalized a block for some non-collection related purpose.
         void didConsumeEmptyFreeList(); // Call this if you sweep a block, but the returned FreeList is empty.
-        void didSweepToNoAvail(); // Call this if you sweep a block and get an empty free list back.
 
         // Returns true if the "newly allocated" bitmap was non-null 
         // and was successfully cleared and false otherwise.
         bool clearNewlyAllocated();
         void clearMarks();
-        void clearRememberedSet();
-        template <HeapOperation collectionType>
-        void clearMarksWithCollectionType();
-
         size_t markCount();
         bool isEmpty();
 
@@ -167,11 +161,6 @@ namespace JSC {
         void setMarked(const void*);
         void clearMarked(const void*);
 
-        void setRemembered(const void*);
-        void clearRemembered(const void*);
-        void atomicClearRemembered(const void*);
-        bool isRemembered(const void*);
-
         bool isNewlyAllocated(const void*);
         void setNewlyAllocated(const void*);
         void clearNewlyAllocated(const void*);
@@ -201,11 +190,9 @@ namespace JSC {
         size_t m_atomsPerCell;
         size_t m_endAtom; // This is a fuzzy end. Always test for < m_endAtom.
 #if ENABLE(PARALLEL_GC)
-        WTF::Bitmap<atomsPerBlock, WTF::BitmapAtomic, uint8_t> m_marks;
-        WTF::Bitmap<atomsPerBlock, WTF::BitmapAtomic, uint8_t> m_rememberedSet;
+        WTF::Bitmap<atomsPerBlock, WTF::BitmapAtomic> m_marks;
 #else
-        WTF::Bitmap<atomsPerBlock, WTF::BitmapNotAtomic, uint8_t> m_marks;
-        WTF::Bitmap<atomsPerBlock, WTF::BitmapNotAtomic, uint8_t> m_rememberedSet;
+        WTF::Bitmap<atomsPerBlock, WTF::BitmapNotAtomic> m_marks;
 #endif
         OwnPtr<WTF::Bitmap<atomsPerBlock>> m_newlyAllocated;
 
@@ -247,6 +234,15 @@ namespace JSC {
         return reinterpret_cast<MarkedBlock*>(reinterpret_cast<Bits>(p) & blockMask);
     }
 
+    inline void MarkedBlock::lastChanceToFinalize()
+    {
+        m_weakSet.lastChanceToFinalize();
+
+        clearNewlyAllocated();
+        clearMarks();
+        sweep();
+    }
+
     inline MarkedAllocator* MarkedBlock::allocator() const
     {
         return m_allocator;
@@ -295,10 +291,26 @@ namespace JSC {
         HEAP_LOG_BLOCK_STATE_TRANSITION(this);
 
         ASSERT(!m_newlyAllocated);
+#ifndef NDEBUG
+        for (size_t i = firstAtom(); i < m_endAtom; i += m_atomsPerCell)
+            ASSERT(m_marks.get(i));
+#endif
         ASSERT(m_state == FreeListed);
         m_state = Marked;
     }
 
+    inline void MarkedBlock::clearMarks()
+    {
+        HEAP_LOG_BLOCK_STATE_TRANSITION(this);
+
+        ASSERT(m_state != New && m_state != FreeListed);
+        m_marks.clearAll();
+
+        // This will become true at the end of the mark phase. We set it now to
+        // avoid an extra pass to do so later.
+        m_state = Marked;
+    }
+
     inline size_t MarkedBlock::markCount()
     {
         return m_marks.count();
@@ -334,26 +346,6 @@ namespace JSC {
         return (reinterpret_cast<Bits>(p) - reinterpret_cast<Bits>(this)) / atomSize;
     }
 
-    inline void MarkedBlock::setRemembered(const void* p)
-    {
-        m_rememberedSet.set(atomNumber(p));
-    }
-
-    inline void MarkedBlock::clearRemembered(const void* p)
-    {
-        m_rememberedSet.clear(atomNumber(p));
-    }
-
-    inline void MarkedBlock::atomicClearRemembered(const void* p)
-    {
-        m_rememberedSet.concurrentTestAndClear(atomNumber(p));
-    }
-
-    inline bool MarkedBlock::isRemembered(const void* p)
-    {
-        return m_rememberedSet.get(atomNumber(p));
-    }
-
     inline bool MarkedBlock::isMarked(const void* p)
     {
         return m_marks.get(atomNumber(p));
index 4deca13..48648d2 100644 (file)
@@ -105,7 +105,6 @@ MarkedSpace::~MarkedSpace()
 {
     Free free(Free::FreeAll, this);
     forEachBlock(free);
-    ASSERT(!m_blocks.set().size());
 }
 
 struct LastChanceToFinalize : MarkedBlock::VoidFunctor {
@@ -144,27 +143,17 @@ void MarkedSpace::resetAllocators()
     m_normalSpace.largeAllocator.reset();
     m_normalDestructorSpace.largeAllocator.reset();
     m_immortalStructureDestructorSpace.largeAllocator.reset();
-
-    m_blocksWithNewObjects.clear();
 }
 
 void MarkedSpace::visitWeakSets(HeapRootVisitor& heapRootVisitor)
 {
     VisitWeakSet visitWeakSet(heapRootVisitor);
-    if (m_heap->operationInProgress() == EdenCollection) {
-        for (unsigned i = 0; i < m_blocksWithNewObjects.size(); ++i)
-            visitWeakSet(m_blocksWithNewObjects[i]);
-    } else
-        forEachBlock(visitWeakSet);
+    forEachBlock(visitWeakSet);
 }
 
 void MarkedSpace::reapWeakSets()
 {
-    if (m_heap->operationInProgress() == EdenCollection) {
-        for (unsigned i = 0; i < m_blocksWithNewObjects.size(); ++i)
-            m_blocksWithNewObjects[i]->reapWeakSet();
-    } else
-        forEachBlock<ReapWeakSet>();
+    forEachBlock<ReapWeakSet>();
 }
 
 template <typename Functor>
@@ -316,24 +305,6 @@ void MarkedSpace::clearNewlyAllocated()
 #endif
 }
 
-#ifndef NDEBUG
-struct VerifyMarked : MarkedBlock::VoidFunctor {
-    void operator()(MarkedBlock* block) { ASSERT(block->needsSweeping()); }
-};
-#endif
-
-void MarkedSpace::clearMarks()
-{
-    if (m_heap->operationInProgress() == EdenCollection) {
-        for (unsigned i = 0; i < m_blocksWithNewObjects.size(); ++i)
-            m_blocksWithNewObjects[i]->clearMarks();
-    } else
-        forEachBlock<ClearMarks>();
-#ifndef NDEBUG
-    forEachBlock<VerifyMarked>();
-#endif
-}
-
 void MarkedSpace::willStartIterating()
 {
     ASSERT(!isIterating());
index 9c97fbd..9680670 100644 (file)
@@ -46,17 +46,7 @@ class WeakGCHandle;
 class SlotVisitor;
 
 struct ClearMarks : MarkedBlock::VoidFunctor {
-    void operator()(MarkedBlock* block)
-    {
-        block->clearMarks();
-    }
-};
-
-struct ClearRememberedSet : MarkedBlock::VoidFunctor {
-    void operator()(MarkedBlock* block)
-    {
-        block->clearRememberedSet();
-    }
+    void operator()(MarkedBlock* block) { block->clearMarks(); }
 };
 
 struct Sweep : MarkedBlock::VoidFunctor {
@@ -115,10 +105,8 @@ public:
 
     void didAddBlock(MarkedBlock*);
     void didConsumeFreeList(MarkedBlock*);
-    void didAllocateInBlock(MarkedBlock*);
 
     void clearMarks();
-    void clearRememberedSet();
     void clearNewlyAllocated();
     void sweep();
     size_t objectCount();
@@ -162,7 +150,6 @@ private:
     size_t m_capacity;
     bool m_isIterating;
     MarkedBlockSet m_blocks;
-    Vector<MarkedBlock*> m_blocksWithNewObjects;
 
     DelayedReleaseScope* m_currentDelayedReleaseScope;
 };
@@ -275,14 +262,9 @@ inline void MarkedSpace::didAddBlock(MarkedBlock* block)
     m_blocks.add(block);
 }
 
-inline void MarkedSpace::didAllocateInBlock(MarkedBlock* block)
-{
-    m_blocksWithNewObjects.append(block);
-}
-
-inline void MarkedSpace::clearRememberedSet()
+inline void MarkedSpace::clearMarks()
 {
-    forEachBlock<ClearRememberedSet>();
+    forEachBlock<ClearMarks>();
 }
 
 inline size_t MarkedSpace::objectCount()
index 05fb001..cda2b79 100644 (file)
@@ -33,7 +33,7 @@ SlotVisitor::SlotVisitor(GCThreadSharedData& shared)
 
 SlotVisitor::~SlotVisitor()
 {
-    clearMarkStack();
+    ASSERT(m_stack.isEmpty());
 }
 
 void SlotVisitor::setup()
@@ -63,11 +63,6 @@ void SlotVisitor::reset()
     }
 }
 
-void SlotVisitor::clearMarkStack()
-{
-    m_stack.clear();
-}
-
 void SlotVisitor::append(ConservativeRoots& conservativeRoots)
 {
     StackStats::probe();
index 4a8dc3e..a4aacdc 100644 (file)
@@ -49,10 +49,6 @@ public:
     SlotVisitor(GCThreadSharedData&);
     ~SlotVisitor();
 
-    MarkStackArray& markStack() { return m_stack; }
-
-    Heap* heap() const;
-
     void append(ConservativeRoots&);
     
     template<typename T> void append(JITWriteBarrier<T>*);
@@ -65,19 +61,17 @@ public:
     void appendUnbarrieredValue(JSValue*);
     template<typename T>
     void appendUnbarrieredWeak(Weak<T>*);
-    void unconditionallyAppend(JSCell*);
     
     void addOpaqueRoot(void*);
     bool containsOpaqueRoot(void*);
     TriState containsOpaqueRootTriState(void*);
     int opaqueRootCount();
 
-    GCThreadSharedData& sharedData() const { return m_shared; }
+    GCThreadSharedData& sharedData() { return m_shared; }
     bool isEmpty() { return m_stack.isEmpty(); }
 
     void setup();
     void reset();
-    void clearMarkStack();
 
     size_t bytesVisited() const { return m_bytesVisited; }
     size_t bytesCopied() const { return m_bytesCopied; }
@@ -95,7 +89,7 @@ public:
 
     void copyLater(JSCell*, CopyToken, void*, size_t);
     
-    void reportExtraMemoryUsage(JSCell* owner, size_t);
+    void reportExtraMemoryUsage(size_t size);
     
     void addWeakReferenceHarvester(WeakReferenceHarvester*);
     void addUnconditionalFinalizer(UnconditionalFinalizer*);
index cd63ab5..d503d1c 100644 (file)
@@ -105,14 +105,6 @@ ALWAYS_INLINE void SlotVisitor::internalAppend(void* from, JSCell* cell)
         
     MARK_LOG_CHILD(*this, cell);
 
-    unconditionallyAppend(cell);
-}
-
-ALWAYS_INLINE void SlotVisitor::unconditionallyAppend(JSCell* cell)
-{
-    ASSERT(Heap::isMarked(cell));
-    m_visitCount++;
-        
     // Should never attempt to mark something that is zapped.
     ASSERT(!cell->isZapped());
         
@@ -226,9 +218,6 @@ inline void SlotVisitor::donateAndDrain()
 inline void SlotVisitor::copyLater(JSCell* owner, CopyToken token, void* ptr, size_t bytes)
 {
     ASSERT(bytes);
-    // We don't do any copying during EdenCollections.
-    ASSERT(heap()->operationInProgress() != EdenCollection);
-
     m_bytesCopied += bytes;
 
     CopiedBlock* block = CopiedSpace::blockFor(ptr);
@@ -237,15 +226,14 @@ inline void SlotVisitor::copyLater(JSCell* owner, CopyToken token, void* ptr, si
         return;
     }
 
+    if (block->isPinned())
+        return;
+
     block->reportLiveBytes(owner, token, bytes);
 }
     
-inline void SlotVisitor::reportExtraMemoryUsage(JSCell* owner, size_t size)
+inline void SlotVisitor::reportExtraMemoryUsage(size_t size)
 {
-    // We don't want to double-count the extra memory that was reported in previous collections.
-    if (heap()->operationInProgress() == EdenCollection && MarkedBlock::blockFor(owner)->isRemembered(owner))
-        return;
-
     size_t* counter = &m_shared.m_vm->heap.m_extraMemoryUsage;
     
 #if ENABLE(COMPARE_AND_SWAP)
@@ -259,11 +247,6 @@ inline void SlotVisitor::reportExtraMemoryUsage(JSCell* owner, size_t size)
 #endif
 }
 
-inline Heap* SlotVisitor::heap() const
-{
-    return &sharedData().m_vm->heap;
-}
-
 } // namespace JSC
 
 #endif // SlotVisitorInlines_h
index 5c9aa96..3e29da5 100644 (file)
@@ -39,7 +39,6 @@
 #include "PolymorphicPutByIdList.h"
 #include "RepatchBuffer.h"
 #include "ScratchRegisterAllocator.h"
-#include "StackAlignment.h"
 #include "StructureRareDataInlines.h"
 #include "StructureStubClearingWatchpoint.h"
 #include "ThunkGenerators.h"
index 6db8627..e920abe 100644 (file)
@@ -447,7 +447,7 @@ void JSGenericTypedArrayView<Adaptor>::visitChildren(JSCell* cell, SlotVisitor&
     }
         
     case OversizeTypedArray: {
-        visitor.reportExtraMemoryUsage(thisObject, thisObject->byteSize());
+        visitor.reportExtraMemoryUsage(thisObject->byteSize());
         break;
     }
         
index f4362ff..5914030 100644 (file)
@@ -109,9 +109,9 @@ namespace JSC {
         return m_enumerationCache.get();
     }
     
-    inline void StructureRareData::setEnumerationCache(VM& vm, const Structure*, JSPropertyNameIterator* value)
+    inline void StructureRareData::setEnumerationCache(VM& vm, const Structure* owner, JSPropertyNameIterator* value)
     {
-        m_enumerationCache.set(vm, this, value);
+        m_enumerationCache.set(vm, owner, value);
     }
 
 } // namespace JSC
index 099b623..a5bfe26 100644 (file)
@@ -72,7 +72,7 @@ void JSString::visitChildren(JSCell* cell, SlotVisitor& visitor)
     else {
         StringImpl* impl = thisObject->m_value.impl();
         ASSERT(impl);
-        visitor.reportExtraMemoryUsage(thisObject, impl->costDuringGC());
+        visitor.reportExtraMemoryUsage(impl->costDuringGC());
     }
 }
 
index 5b39bad..20b7f8b 100644 (file)
@@ -35,9 +35,9 @@ inline Structure* StructureRareData::previousID() const
     return m_previous.get();
 }
 
-inline void StructureRareData::setPreviousID(VM& vm, Structure*, Structure* structure)
+inline void StructureRareData::setPreviousID(VM& vm, Structure* transition, Structure* structure)
 {
-    m_previous.set(vm, this, structure);
+    m_previous.set(vm, transition, structure);
 }
 
 inline void StructureRareData::clearPreviousID()
@@ -50,9 +50,9 @@ inline JSString* StructureRareData::objectToStringValue() const
     return m_objectToStringValue.get();
 }
 
-inline void StructureRareData::setObjectToStringValue(VM& vm, const JSCell*, JSString* value)
+inline void StructureRareData::setObjectToStringValue(VM& vm, const JSCell* owner, JSString* value)
 {
-    m_objectToStringValue.set(vm, this, value);
+    m_objectToStringValue.set(vm, owner, value);
 }
 
 } // namespace JSC
index 224be8a..ce60c8c 100644 (file)
@@ -64,7 +64,7 @@ void WeakMapData::visitChildren(JSCell* cell, SlotVisitor& visitor)
     // Rough approximation of the external storage needed for the hashtable.
     // This isn't exact, but it is close enough, and proportional to the actual
     // external mermory usage.
-    visitor.reportExtraMemoryUsage(thisObj, thisObj->m_map.capacity() * (sizeof(JSObject*) + sizeof(WriteBarrier<Unknown>)));
+    visitor.reportExtraMemoryUsage(thisObj->m_map.capacity() * (sizeof(JSObject*) + sizeof(WriteBarrier<Unknown>)));
 }
 
 void WeakMapData::set(VM& vm, JSObject* key, JSValue value)
index 1a8cad2..3af4b32 100644 (file)
@@ -1,3 +1,15 @@
+2014-01-09  Commit Queue  <commit-queue@webkit.org>
+
+        Unreviewed, rolling out r161540.
+        http://trac.webkit.org/changeset/161540
+        https://bugs.webkit.org/show_bug.cgi?id=126704
+
+        Caused assertion failures on multiple tests (Requested by ap
+        on #webkit).
+
+        * wtf/Bitmap.h:
+        (WTF::WordType>::count):
+
 2014-01-07  Mark Hahnenberg  <mhahnenberg@apple.com>
 
         Marking should be generational
index 7b288f9..936ccc2 100644 (file)
@@ -196,7 +196,7 @@ inline size_t Bitmap<size, atomicMode, WordType>::count(size_t start) const
             ++result;
     }
     for (size_t i = start / wordSize; i < words; ++i)
-        result += WTF::bitCount(static_cast<unsigned>(bits[i]));
+        result += WTF::bitCount(bits[i]);
     return result;
 }