Attachment 368428 Details for Bug 186740 – Patch

[patch] Patch

bug-186740-20190428042911.patch (text/plain), 20.81 KB, created by Yusuke Suzuki on 2019-04-28 04:29:12 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Yusuke Suzuki

Created: 2019-04-28 04:29:12 PDT

Size: 20.81 KB

patch

obsolete

>Subversion Revision: 244723
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index 28aeca460ca65580a9ae60e98de7e15fada6d41b..9947d628fd052598fcd8f62915116a5ee4d411cc 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,52 @@
>+2019-04-28  Yusuke Suzuki  <ysuzuki@apple.com>
>+
>+        CodeBlockSet wastes 190KB of HashTable capacity on nytimes.com
>+        https://bugs.webkit.org/show_bug.cgi?id=186740
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * bytecode/CodeBlock.cpp:
>+        (JSC::CodeBlock::visitChildren):
>+        (JSC::CodeBlock::finalizeUnconditionally):
>+        * heap/CodeBlockSet.cpp:
>+        (JSC::CodeBlockSet::dump const):
>+        (JSC::CodeBlockSet::clearCurrentlyExecuting): Deleted.
>+        * heap/CodeBlockSet.h:
>+        * heap/CodeBlockSetInlines.h:
>+        (JSC::CodeBlockSet::mark):
>+        (JSC::CodeBlockSet::unmark):
>+        (JSC::CodeBlockSet::iterateViaSubspaces):
>+        (JSC::CodeBlockSet::iterateCurrentlyExecuting):
>+        * heap/ConservativeRoots.cpp:
>+        (JSC::CompositeMarkHook::CompositeMarkHook):
>+        (JSC::CompositeMarkHook::markKnownJSCell):
>+        (JSC::ConservativeRoots::add):
>+        * heap/Heap.cpp:
>+        (JSC::Heap::Heap):
>+        (JSC::Heap::dumpHeapStatisticsAtVMDestruction):
>+        (JSC::Heap::finalizeUnconditionalFinalizers):
>+        (JSC::Heap::iterateExecutingAndCompilingCodeBlocks):
>+        (JSC::Heap::gatherStackRoots):
>+        (JSC::Heap::gatherJSStackRoots):
>+        (JSC::Heap::deleteUnmarkedCompiledCode):
>+        (JSC::Heap::runEndPhase):
>+        (JSC::Heap::forEachCodeBlockImpl):
>+        (JSC::Heap::forEachCodeBlockIgnoringJITPlansImpl):
>+        * heap/Heap.h:
>+        (JSC::Heap::codeBlockSet):
>+        * heap/IsoCellSet.h:
>+        * heap/IsoCellSetInlines.h:
>+        (JSC::IsoCellSet::forEachLiveCell):
>+        (JSC::IsoCellSet::forEachCell):
>+        * heap/MarkedBlock.cpp:
>+        (JSC::MarkedBlock::Handle::stopAllocating):
>+        * heap/MarkedBlock.h:
>+        (JSC::MarkedBlock::Handle::forEachCell):
>+        * runtime/JSGlobalObject.cpp:
>+        (JSC::JSGlobalObject::bumpGlobalLexicalBindingEpoch):
>+        * runtime/VM.h:
>+        (JSC::VM::forEachCodeBlockSpace): Deleted.
>+
> 2019-04-26  Keith Rollin  <krollin@apple.com>
> 
>         Enable new build rule for post-processing headers when using XCBuild
>diff --git a/Source/JavaScriptCore/bytecode/CodeBlock.cpp b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
>index 0ab756cbb8fa9142c40f5e57aee4255c6353c88b..2d1fbd915cd4c894aec57a724d0191e169c50b93 100644
>--- a/Source/JavaScriptCore/bytecode/CodeBlock.cpp
>+++ b/Source/JavaScriptCore/bytecode/CodeBlock.cpp
>@@ -974,8 +974,6 @@ void CodeBlock::visitChildren(SlotVisitor& visitor)
> 
>     stronglyVisitStrongReferences(locker, visitor);
>     stronglyVisitWeakReferences(locker, visitor);
>-    
>-    VM::SpaceAndSet::setFor(*subspace()).add(this);
> }
> 
> bool CodeBlock::shouldVisitStrongly(const ConcurrentJSLocker& locker)
>@@ -1374,8 +1372,6 @@ void CodeBlock::finalizeUnconditionally(VM& vm)
>         dfgCommon->recordedStatuses.finalize(vm);
>     }
> #endif // ENABLE(DFG_JIT)
>-
>-    VM::SpaceAndSet::setFor(*subspace()).remove(this);
> }
> 
> void CodeBlock::destroy(JSCell* cell)
>diff --git a/Source/JavaScriptCore/heap/CodeBlockSet.cpp b/Source/JavaScriptCore/heap/CodeBlockSet.cpp
>index 49fcd84f4ad97aae0aaf3f193c86ea0613f6d8b7..eac38048b3e4f89c96f93b85342def46985942e6 100644
>--- a/Source/JavaScriptCore/heap/CodeBlockSet.cpp
>+++ b/Source/JavaScriptCore/heap/CodeBlockSet.cpp
>@@ -50,21 +50,12 @@ bool CodeBlockSet::contains(const AbstractLocker&, void* candidateCodeBlock)
>     return m_codeBlocks.contains(codeBlock);
> }
> 
>-void CodeBlockSet::clearCurrentlyExecuting()
>-{
>-    m_currentlyExecuting.clear();
>-}
>-
> void CodeBlockSet::dump(PrintStream& out) const
> {
>     CommaPrinter comma;
>     out.print("{codeBlocks = [");
>     for (CodeBlock* codeBlock : m_codeBlocks)
>         out.print(comma, pointerDump(codeBlock));
>-    out.print("], currentlyExecuting = [");
>-    comma = CommaPrinter();
>-    for (CodeBlock* codeBlock : m_currentlyExecuting)
>-        out.print(comma, pointerDump(codeBlock));
>     out.print("]}");
> }
> 
>diff --git a/Source/JavaScriptCore/heap/CodeBlockSet.h b/Source/JavaScriptCore/heap/CodeBlockSet.h
>index c4c58274fcd0eb752bb614f60f680931edc79cbb..ab8494e9f0c9d6ee79105657bb28e0ec581a23f6 100644
>--- a/Source/JavaScriptCore/heap/CodeBlockSet.h
>+++ b/Source/JavaScriptCore/heap/CodeBlockSet.h
>@@ -49,10 +49,9 @@ class CodeBlockSet {
>     CodeBlockSet();
>     ~CodeBlockSet();
> 
>-    void mark(const AbstractLocker&, CodeBlock* candidateCodeBlock);
>+    void mark(CodeBlock* candidateCodeBlock);
>+    void unmark(CodeBlock*);
>     
>-    void clearCurrentlyExecuting();
>-
>     bool contains(const AbstractLocker&, void* candidateCodeBlock);
>     Lock& getLock() { return m_lock; }
> 
>@@ -64,7 +63,7 @@ class CodeBlockSet {
> 
>     template<typename Functor> void iterateViaSubspaces(VM&, const Functor&);
>     
>-    template<typename Functor> void iterateCurrentlyExecuting(const Functor&);
>+    template<typename Functor> void iterateCurrentlyExecuting(VM&, const Functor&);
>     
>     void dump(PrintStream&) const;
>     
>@@ -73,7 +72,6 @@ class CodeBlockSet {
> 
> private:
>     HashSet<CodeBlock*> m_codeBlocks;
>-    HashSet<CodeBlock*> m_currentlyExecuting;
>     Lock m_lock;
> };
> 
>diff --git a/Source/JavaScriptCore/heap/CodeBlockSetInlines.h b/Source/JavaScriptCore/heap/CodeBlockSetInlines.h
>index 5ddbf494ab23e8080b9932a0d2f9e3cdecad5276..9804bf96ac7b77dbc3a8e4e9387d1f761220088b 100644
>--- a/Source/JavaScriptCore/heap/CodeBlockSetInlines.h
>+++ b/Source/JavaScriptCore/heap/CodeBlockSetInlines.h
>@@ -30,15 +30,21 @@
> 
> #include "CodeBlock.h"
> #include "CodeBlockSet.h"
>+#include "IsoCellSetInlines.h"
>+#include "SubspaceInlines.h"
> 
> namespace JSC {
> 
>-inline void CodeBlockSet::mark(const AbstractLocker&, CodeBlock* codeBlock)
>+inline void CodeBlockSet::mark(CodeBlock* codeBlock)
> {
>-    if (!codeBlock)
>-        return;
>+    ASSERT(codeBlock);
>+    codeBlock->vm()->codeBlockSpace.set.add(codeBlock);
>+}
> 
>-    m_currentlyExecuting.add(codeBlock);
>+inline void CodeBlockSet::unmark(CodeBlock* codeBlock)
>+{
>+    ASSERT(codeBlock);
>+    codeBlock->vm()->codeBlockSpace.set.remove(codeBlock);
> }
> 
> template<typename Functor>
>@@ -58,21 +64,19 @@ void CodeBlockSet::iterate(const AbstractLocker&, const Functor& functor)
> template<typename Functor>
> void CodeBlockSet::iterateViaSubspaces(VM& vm, const Functor& functor)
> {
>-    vm.forEachCodeBlockSpace(
>-        [&] (auto& spaceAndSet) {
>-            spaceAndSet.space.forEachLiveCell(
>-                [&] (HeapCell* cell, HeapCell::Kind) {
>-                    functor(jsCast<CodeBlock*>(static_cast<JSCell*>(cell)));
>-                });
>+    vm.codeBlockSpace.space.forEachLiveCell(
>+        [&] (HeapCell* cell, HeapCell::Kind) {
>+            functor(jsCast<CodeBlock*>(static_cast<JSCell*>(cell)));
>         });
> }
> 
> template<typename Functor>
>-void CodeBlockSet::iterateCurrentlyExecuting(const Functor& functor)
>+void CodeBlockSet::iterateCurrentlyExecuting(VM& vm, const Functor& functor)
> {
>-    LockHolder locker(&m_lock);
>-    for (CodeBlock* codeBlock : m_currentlyExecuting)
>-        functor(codeBlock);
>+    vm.codeBlockSpace.set.forEachMarkedCell(
>+        [&] (HeapCell* cell, HeapCell::Kind) {
>+            functor(jsCast<CodeBlock*>(static_cast<JSCell*>(cell)));
>+        });
> }
> 
> } // namespace JSC
>diff --git a/Source/JavaScriptCore/heap/ConservativeRoots.cpp b/Source/JavaScriptCore/heap/ConservativeRoots.cpp
>index a420fe8e625c993ed594d0acf58aecb76c8c995e..38c90dbbd3e3e7d537dff84db80abd116e5e125c 100644
>--- a/Source/JavaScriptCore/heap/ConservativeRoots.cpp
>+++ b/Source/JavaScriptCore/heap/ConservativeRoots.cpp
>@@ -117,10 +117,9 @@ void ConservativeRoots::add(void* begin, void* end)
> 
> class CompositeMarkHook {
> public:
>-    CompositeMarkHook(JITStubRoutineSet& stubRoutines, CodeBlockSet& codeBlocks, const AbstractLocker& locker)
>+    CompositeMarkHook(JITStubRoutineSet& stubRoutines, CodeBlockSet& codeBlocks)
>         : m_stubRoutines(stubRoutines)
>         , m_codeBlocks(codeBlocks)
>-        , m_codeBlocksLocker(locker)
>     {
>     }
>     
>@@ -132,20 +131,18 @@ class CompositeMarkHook {
>     void markKnownJSCell(JSCell* cell)
>     {
>         if (cell->type() == CodeBlockType)
>-            m_codeBlocks.mark(m_codeBlocksLocker, jsCast<CodeBlock*>(cell));
>+            m_codeBlocks.mark(jsCast<CodeBlock*>(cell));
>     }
> 
> private:
>     JITStubRoutineSet& m_stubRoutines;
>     CodeBlockSet& m_codeBlocks;
>-    const AbstractLocker& m_codeBlocksLocker;
> };
> 
> void ConservativeRoots::add(
>     void* begin, void* end, JITStubRoutineSet& jitStubRoutines, CodeBlockSet& codeBlocks)
> {
>-    LockHolder locker(codeBlocks.getLock());
>-    CompositeMarkHook markHook(jitStubRoutines, codeBlocks, locker);
>+    CompositeMarkHook markHook(jitStubRoutines, codeBlocks);
>     genericAddSpan(begin, end, markHook);
> }
> 
>diff --git a/Source/JavaScriptCore/heap/Heap.cpp b/Source/JavaScriptCore/heap/Heap.cpp
>index 4953ac259223f32a1a0ad6e96182ffbc16aaa522..0a6e20399e2c6a7513f076f9c9fc75f5dc1af228 100644
>--- a/Source/JavaScriptCore/heap/Heap.cpp
>+++ b/Source/JavaScriptCore/heap/Heap.cpp
>@@ -285,7 +285,7 @@ Heap::Heap(VM* vm, HeapType heapType)
>     , m_raceMarkStack(std::make_unique<MarkStackArray>())
>     , m_constraintSet(std::make_unique<MarkingConstraintSet>(*this))
>     , m_handleSet(vm)
>-    , m_codeBlocks(std::make_unique<CodeBlockSet>())
>+    , m_codeBlockSet(std::make_unique<CodeBlockSet>())
>     , m_jitStubRoutines(std::make_unique<JITStubRoutineSet>())
>     , m_vm(vm)
>     // We seed with 10ms so that GCActivityCallback::didAllocate doesn't continuously 
>@@ -349,13 +349,13 @@ void Heap::dumpHeapStatisticsAtVMDestruction()
>     unsigned counter = 0;
>     m_objectSpace.forEachBlock([&] (MarkedBlock::Handle* block) {
>         unsigned live = 0;
>-        block->forEachCell([&] (HeapCell* cell, HeapCell::Kind) {
>+        block->forEachCell([&] (size_t, HeapCell* cell, HeapCell::Kind) {
>             if (cell->isLive())
>                 live++;
>             return IterationStatus::Continue;
>         });
>         dataLogLn("[", counter++, "] ", block->cellSize(), ", ", live, " / ", block->cellsPerBlock(), " ", static_cast<double>(live) / block->cellsPerBlock() * 100, "% ", block->attributes(), " ", block->subspace()->name());
>-        block->forEachCell([&] (HeapCell* heapCell, HeapCell::Kind kind) {
>+        block->forEachCell([&] (size_t, HeapCell* heapCell, HeapCell::Kind kind) {
>             if (heapCell->isLive() && kind == HeapCell::Kind::JSCell) {
>                 auto* cell = static_cast<JSCell*>(heapCell);
>                 if (cell->isObject())
>@@ -590,10 +590,7 @@ void Heap::finalizeUnconditionalFinalizers()
>     vm()->builtinExecutables()->finalizeUnconditionally();
>     if (vm()->m_inferredValueSpace)
>         finalizeMarkedUnconditionalFinalizers<InferredValue>(vm()->m_inferredValueSpace->space);
>-    vm()->forEachCodeBlockSpace(
>-        [&] (auto& space) {
>-            this->finalizeMarkedUnconditionalFinalizers<CodeBlock>(space.set);
>-        });
>+    finalizeMarkedUnconditionalFinalizers<CodeBlock>(vm()->codeBlockSpace.space);
>     finalizeMarkedUnconditionalFinalizers<ExecutableToCodeBlockEdge>(vm()->executableToCodeBlockEdgesWithFinalizers);
>     finalizeMarkedUnconditionalFinalizers<StructureRareData>(vm()->structureRareDataSpace);
>     if (vm()->m_weakSetSpace)
>@@ -632,7 +629,7 @@ void Heap::completeAllJITPlans()
> template<typename Func>
> void Heap::iterateExecutingAndCompilingCodeBlocks(const Func& func)
> {
>-    m_codeBlocks->iterateCurrentlyExecuting(func);
>+    m_codeBlockSet->iterateCurrentlyExecuting(*m_vm, func);
>     if (VM::canUseJIT())
>         DFG::iterateCodeBlocksForGC(*m_vm, func);
> }
>@@ -677,13 +674,13 @@ void Heap::assertMarkStacksEmpty()
> 
> void Heap::gatherStackRoots(ConservativeRoots& roots)
> {
>-    m_machineThreads->gatherConservativeRoots(roots, *m_jitStubRoutines, *m_codeBlocks, m_currentThreadState, m_currentThread);
>+    m_machineThreads->gatherConservativeRoots(roots, *m_jitStubRoutines, *m_codeBlockSet, m_currentThreadState, m_currentThread);
> }
> 
> void Heap::gatherJSStackRoots(ConservativeRoots& roots)
> {
> #if ENABLE(C_LOOP)
>-    m_vm->interpreter->cloopStack().gatherConservativeRoots(roots, *m_jitStubRoutines, *m_codeBlocks);
>+    m_vm->interpreter->cloopStack().gatherConservativeRoots(roots, *m_jitStubRoutines, *m_codeBlockSet);
> #else
>     UNUSED_PARAM(roots);
> #endif
>@@ -962,7 +959,7 @@ void Heap::deleteAllUnlinkedCodeBlocks(DeleteAllCodeEffort effort)
> void Heap::deleteUnmarkedCompiledCode()
> {
>     vm()->forEachScriptExecutableSpace([] (auto& space) { space.space.sweep(); });
>-    vm()->forEachCodeBlockSpace([] (auto& space) { space.space.sweep(); }); // Sweeping must occur before deleting stubs, otherwise the stubs might still think they're alive as they get deleted.
>+    vm()->codeBlockSpace.space.sweep(); // Sweeping must occur before deleting stubs, otherwise the stubs might still think they're alive as they get deleted.
>     m_jitStubRoutines->deleteUnmarkedJettisonedStubRoutines();
> }
> 
>@@ -1505,11 +1502,12 @@ NEVER_INLINE bool Heap::runEndPhase(GCConductor conn)
>     removeDeadCompilerWorklistEntries();
>     notifyIncrementalSweeper();
>     
>-    m_codeBlocks->iterateCurrentlyExecuting(
>+    m_codeBlockSet->iterateCurrentlyExecuting(
>+        *vm(),
>         [&] (CodeBlock* codeBlock) {
>             writeBarrier(codeBlock);
>+            m_codeBlockSet->unmark(codeBlock);
>         });
>-    m_codeBlocks->clearCurrentlyExecuting();
>         
>     m_objectSpace.prepareForAllocation();
>     updateAllocationLimits();
>@@ -2525,12 +2523,12 @@ void Heap::forEachCodeBlockImpl(const ScopedLambda<void(CodeBlock*)>& func)
>     // We don't know the full set of CodeBlocks until compilation has terminated.
>     completeAllJITPlans();
> 
>-    return m_codeBlocks->iterate(func);
>+    return m_codeBlockSet->iterate(func);
> }
> 
> void Heap::forEachCodeBlockIgnoringJITPlansImpl(const AbstractLocker& locker, const ScopedLambda<void(CodeBlock*)>& func)
> {
>-    return m_codeBlocks->iterate(locker, func);
>+    return m_codeBlockSet->iterate(locker, func);
> }
> 
> void Heap::writeBarrierSlowPath(const JSCell* from)
>diff --git a/Source/JavaScriptCore/heap/Heap.h b/Source/JavaScriptCore/heap/Heap.h
>index 38f5321ad9d77c385b5eb2f9ca9512879830a7a6..23d1828618e1405d843f2b31040ceee74d004f98 100644
>--- a/Source/JavaScriptCore/heap/Heap.h
>+++ b/Source/JavaScriptCore/heap/Heap.h
>@@ -274,7 +274,7 @@ class Heap {
> 
>     StructureIDTable& structureIDTable() { return m_structureIDTable; }
> 
>-    CodeBlockSet& codeBlockSet() { return *m_codeBlocks; }
>+    CodeBlockSet& codeBlockSet() { return *m_codeBlockSet; }
> 
> #if USE(FOUNDATION)
>     template<typename T> void releaseSoon(RetainPtr<T>&&);
>@@ -632,7 +632,7 @@ class Heap {
>     Vector<SlotVisitor*> m_availableParallelSlotVisitors;
>     
>     HandleSet m_handleSet;
>-    std::unique_ptr<CodeBlockSet> m_codeBlocks;
>+    std::unique_ptr<CodeBlockSet> m_codeBlockSet;
>     std::unique_ptr<JITStubRoutineSet> m_jitStubRoutines;
>     FinalizerOwner m_finalizerOwner;
>     
>diff --git a/Source/JavaScriptCore/heap/IsoCellSet.h b/Source/JavaScriptCore/heap/IsoCellSet.h
>index dada672c491dc0381f58fa1a672b6c6c0b7e2e58..26ad7b4b29b472af783ea0be93f3c8da88da624a 100644
>--- a/Source/JavaScriptCore/heap/IsoCellSet.h
>+++ b/Source/JavaScriptCore/heap/IsoCellSet.h
>@@ -39,7 +39,7 @@ class IsoSubspace;
> 
> // Create a set of cells that are in an IsoSubspace. This allows concurrent O(1) set insertion and
> // removal. Each such set should be thought of as a 0.8% increase in object size for objects in that
>-// IsoSubspace (it's like adding 1 bit every 16 bytes, or 1 bit every 128 bits).
>+// IsoSubspace (it's like adding 1 bit every 16 bytes, or 1 byte every 128 bits).
> class IsoCellSet : public BasicRawSentinelNode<IsoCellSet> {
> public:
>     IsoCellSet(IsoSubspace& subspace);
>@@ -63,6 +63,9 @@ class IsoCellSet : public BasicRawSentinelNode<IsoCellSet> {
>     
>     template<typename Func>
>     void forEachLiveCell(const Func&);
>+
>+    template<typename Func>
>+    void forEachCell(const Func&);
>     
> private:
>     friend class IsoSubspace;
>diff --git a/Source/JavaScriptCore/heap/IsoCellSetInlines.h b/Source/JavaScriptCore/heap/IsoCellSetInlines.h
>index ce7de8e190ea8e53f93364c7cf1fce5ed34a6f74..56a2c00909509cd047b997c14b8ffa67a54287e3 100644
>--- a/Source/JavaScriptCore/heap/IsoCellSetInlines.h
>+++ b/Source/JavaScriptCore/heap/IsoCellSetInlines.h
>@@ -122,10 +122,26 @@ void IsoCellSet::forEachLiveCell(const Func& func)
>         [&] (size_t blockIndex) {
>             MarkedBlock::Handle* block = directory.m_blocks[blockIndex];
> 
>-            // FIXME: We could optimize this by checking our bits before querying isLive.
>-            // OOPS! (need bug URL)
>             auto* bits = m_bits[blockIndex].get();
>-            block->forEachLiveCell(
>+            block->forEachCell(
>+                [&] (size_t atomNumber, HeapCell* cell, HeapCell::Kind kind) -> IterationStatus {
>+                    if (bits->get(atomNumber) && block->isLive(cell))
>+                        func(cell, kind);
>+                    return IterationStatus::Continue;
>+                });
>+        });
>+}
>+
>+template<typename Func>
>+void IsoCellSet::forEachCell(const Func& func)
>+{
>+    BlockDirectory& directory = m_subspace.m_directory;
>+    m_blocksWithBits.forEachSetBit(
>+        [&] (size_t blockIndex) {
>+            MarkedBlock::Handle* block = directory.m_blocks[blockIndex];
>+
>+            auto* bits = m_bits[blockIndex].get();
>+            block->forEachCell(
>                 [&] (size_t atomNumber, HeapCell* cell, HeapCell::Kind kind) -> IterationStatus {
>                     if (bits->get(atomNumber))
>                         func(cell, kind);
>diff --git a/Source/JavaScriptCore/heap/MarkedBlock.cpp b/Source/JavaScriptCore/heap/MarkedBlock.cpp
>index b1a10a1e793e1813d40af1a10c5e057243fe12fc..dedc759ffa78d09eb69e772bf4d960a2b1856c32 100644
>--- a/Source/JavaScriptCore/heap/MarkedBlock.cpp
>+++ b/Source/JavaScriptCore/heap/MarkedBlock.cpp
>@@ -148,7 +148,7 @@ void MarkedBlock::Handle::stopAllocating(const FreeList& freeList)
>     blockFooter().m_newlyAllocatedVersion = heap()->objectSpace().newlyAllocatedVersion();
> 
>     forEachCell(
>-        [&] (HeapCell* cell, HeapCell::Kind) -> IterationStatus {
>+        [&] (size_t, HeapCell* cell, HeapCell::Kind) -> IterationStatus {
>             block().setNewlyAllocated(cell);
>             return IterationStatus::Continue;
>         });
>diff --git a/Source/JavaScriptCore/heap/MarkedBlock.h b/Source/JavaScriptCore/heap/MarkedBlock.h
>index 4392932aec70fcf220848afe657e80f54b5799a1..570200d11354df2647534b4711b9ee31898e7bfe 100644
>--- a/Source/JavaScriptCore/heap/MarkedBlock.h
>+++ b/Source/JavaScriptCore/heap/MarkedBlock.h
>@@ -636,7 +636,7 @@ inline IterationStatus MarkedBlock::Handle::forEachCell(const Functor& functor)
>     HeapCell::Kind kind = m_attributes.cellKind;
>     for (size_t i = 0; i < m_endAtom; i += m_atomsPerCell) {
>         HeapCell* cell = reinterpret_cast_ptr<HeapCell*>(&m_block->atoms()[i]);
>-        if (functor(cell, kind) == IterationStatus::Done)
>+        if (functor(i, cell, kind) == IterationStatus::Done)
>             return IterationStatus::Done;
>     }
>     return IterationStatus::Continue;
>diff --git a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
>index 64d468e83f49787c1043bad47437769b0b8b70aa..2bfd8b7aba4505cbc353369a1773346efc6a6a51 100644
>--- a/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
>+++ b/Source/JavaScriptCore/runtime/JSGlobalObject.cpp
>@@ -2037,7 +2037,7 @@ void JSGlobalObject::bumpGlobalLexicalBindingEpoch(VM& vm)
>     if (++m_globalLexicalBindingEpoch == Options::thresholdForGlobalLexicalBindingEpoch()) {
>         // Since the epoch overflows, we should rewrite all the CodeBlock to adjust to the newly started generation.
>         m_globalLexicalBindingEpoch = 1;
>-        vm.heap.codeBlockSet().iterate([&] (CodeBlock* codeBlock) {
>+        vm.heap.codeBlockSet().iterateViaSubspaces(vm, [&] (CodeBlock* codeBlock) {
>             if (codeBlock->globalObject() != this)
>                 return;
>             codeBlock->notifyLexicalBindingUpdate();
>diff --git a/Source/JavaScriptCore/runtime/VM.h b/Source/JavaScriptCore/runtime/VM.h
>index b985d47ea4d95edddc9c0cf36689653376f7d1df..03bdef940717c33fc2b98511bbad184b518894c0 100644
>--- a/Source/JavaScriptCore/runtime/VM.h
>+++ b/Source/JavaScriptCore/runtime/VM.h
>@@ -452,15 +452,6 @@ class VM : public ThreadSafeRefCounted<VM>, public DoublyLinkedListNode<VM> {
>     
>     SpaceAndSet codeBlockSpace;
>     DYNAMIC_SPACE_AND_SET_DEFINE_MEMBER(inferredValueSpace)
>-
>-    template<typename Func>
>-    void forEachCodeBlockSpace(const Func& func)
>-    {
>-        // This should not include webAssemblyCodeBlockSpace because this is about subsclasses of
>-        // JSC::CodeBlock.
>-        func(codeBlockSpace);
>-    }
>-
>     DYNAMIC_SPACE_AND_SET_DEFINE_MEMBER(evalExecutableSpace)
>     DYNAMIC_SPACE_AND_SET_DEFINE_MEMBER(moduleProgramExecutableSpace)
>     SpaceAndSet functionExecutableSpace;

Actions: View | Formatted Diff | Diff

Attachments on bug 186740: 368426 | 368428 | 369261