Changeset 102917 in webkit for trunk/Source/JavaScriptCore/heap/MarkStack.cpp

Timestamp:

Dec 15, 2011, 4:01:30 AM (13 years ago)

Author:

[email protected]

Message:

Rename JSC::Heuristics to JSC::Options
​https://bugs.webkit.org/show_bug.cgi?id=72889

Patch by Andy Wingo <​[email protected]> on 2011-12-15
Reviewed by Filip Pizlo.

• runtime/Options.cpp: Renamed from Source/JavaScriptCore/runtime/Heuristics.cpp.
• runtime/Options.h: Renamed from Source/JavaScriptCore/runtime/Heuristics.h.

• CMakeLists.txt:
• GNUmakefile.list.am:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Target.pri:
• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::shouldOptimizeNow):

• bytecode/CodeBlock.h:

(JSC::CodeBlock::likelyToTakeSlowCase):
(JSC::CodeBlock::couldTakeSlowCase):
(JSC::CodeBlock::likelyToTakeSpecialFastCase):
(JSC::CodeBlock::likelyToTakeDeepestSlowCase):
(JSC::CodeBlock::likelyToTakeAnySlowCase):
(JSC::CodeBlock::reoptimizationRetryCounter):
(JSC::CodeBlock::countReoptimization):
(JSC::CodeBlock::counterValueForOptimizeAfterWarmUp):
(JSC::CodeBlock::counterValueForOptimizeAfterLongWarmUp):
(JSC::CodeBlock::optimizeNextInvocation):
(JSC::CodeBlock::dontOptimizeAnytimeSoon):
(JSC::CodeBlock::optimizeSoon):
(JSC::CodeBlock::largeFailCountThreshold):
(JSC::CodeBlock::largeFailCountThresholdForLoop):
(JSC::CodeBlock::shouldReoptimizeNow):
(JSC::CodeBlock::shouldReoptimizeFromLoopNow):

• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::handleInlining):

• dfg/DFGCapabilities.h:

(JSC::DFG::mightCompileEval):
(JSC::DFG::mightCompileProgram):
(JSC::DFG::mightCompileFunctionForCall):
(JSC::DFG::mightCompileFunctionForConstruct):
(JSC::DFG::mightInlineFunctionForCall):
(JSC::DFG::mightInlineFunctionForConstruct):

• dfg/DFGOSRExit.cpp:

(JSC::DFG::OSRExit::considerAddingAsFrequentExitSiteSlow):

• dfg/DFGOSRExitCompiler32_64.cpp:

(JSC::DFG::OSRExitCompiler::compileExit):

• dfg/DFGOSRExitCompiler64.cpp:

(JSC::DFG::OSRExitCompiler::compileExit):

• dfg/DFGVariableAccessData.h:

(JSC::DFG::VariableAccessData::shouldUseDoubleFormatAccordingToVote):

• heap/MarkStack.cpp:

(JSC::MarkStackSegmentAllocator::allocate):
(JSC::MarkStackSegmentAllocator::shrinkReserve):
(JSC::MarkStackArray::MarkStackArray):
(JSC::MarkStackArray::donateSomeCellsTo):
(JSC::MarkStackArray::stealSomeCellsFrom):
(JSC::MarkStackThreadSharedData::MarkStackThreadSharedData):
(JSC::SlotVisitor::donateSlow):
(JSC::SlotVisitor::drain):
(JSC::SlotVisitor::drainFromShared):

• heap/MarkStack.h:

(JSC::MarkStack::mergeOpaqueRootsIfProfitable):
(JSC::MarkStack::addOpaqueRoot):
(JSC::MarkStackArray::canDonateSomeCells):

• heap/SlotVisitor.h:

(JSC::SlotVisitor::donate):

• jit/JIT.cpp:

(JSC::JIT::emitOptimizationCheck):

• runtime/InitializeThreading.cpp:

(JSC::initializeThreadingOnce): Adapt callers and build systems.

• testRegExp.cpp:

(CommandLine::CommandLine):

• jsc.cpp:

(CommandLine::CommandLine):
Rename from Options, to avoid name conflict.

File:

• trunk/Source/JavaScriptCore/heap/MarkStack.cpp (modified) (10 diffs)

trunk/Source/JavaScriptCore/heap/MarkStack.cpp

@@ -29 +29 @@
 #include "ConservativeRoots.h"
 #include "Heap.h"
-#include "Heuristics.h"
+#include "Options.h"
 #include "JSArray.h"
 #include "JSCell.h"
@@ -61 +61 @@
     }
 
-    return static_cast<MarkStackSegment*>(OSAllocator::reserveAndCommit(Heuristics::gcMarkStackSegmentSize));
+    return static_cast<MarkStackSegment*>(OSAllocator::reserveAndCommit(Options::gcMarkStackSegmentSize));
 }
 
@@ -82 +82 @@
         MarkStackSegment* toFree = segments;
         segments = segments->m_previous;
-        OSAllocator::decommitAndRelease(toFree, Heuristics::gcMarkStackSegmentSize);
+        OSAllocator::decommitAndRelease(toFree, Options::gcMarkStackSegmentSize);
     }
 }
@@ -88 +88 @@
 MarkStackArray::MarkStackArray(MarkStackSegmentAllocator& allocator)
     : m_allocator(allocator)
-    , m_segmentCapacity(MarkStackSegment::capacityFromSize(Heuristics::gcMarkStackSegmentSize))
+    , m_segmentCapacity(MarkStackSegment::capacityFromSize(Options::gcMarkStackSegmentSize))
     , m_top(0)
     , m_numberOfPreviousSegments(0)
@@ -146 +146 @@
         
     // Fast check: see if the other mark stack already has enough segments.
-    if (other.m_numberOfPreviousSegments + 1 >= Heuristics::maximumNumberOfSharedSegments)
+    if (other.m_numberOfPreviousSegments + 1 >= Options::maximumNumberOfSharedSegments)
         return false;
         
-    size_t numberOfCellsToKeep = Heuristics::minimumNumberOfCellsToKeep;
+    size_t numberOfCellsToKeep = Options::minimumNumberOfCellsToKeep;
     ASSERT(m_top > numberOfCellsToKeep || m_topSegment->m_previous);
         
@@ -210 +210 @@
         
     // Otherwise drain 1/Nth of the shared array where N is the number of
-    // workers, or Heuristics::minimumNumberOfCellsToKeep, whichever is bigger.
-    size_t numberOfCellsToSteal = std::max((size_t)Heuristics::minimumNumberOfCellsToKeep, other.size() / Heuristics::numberOfGCMarkers);
+    // workers, or Options::minimumNumberOfCellsToKeep, whichever is bigger.
+    size_t numberOfCellsToSteal = std::max((size_t)Options::minimumNumberOfCellsToKeep, other.size() / Options::numberOfGCMarkers);
     while (numberOfCellsToSteal-- > 0 && other.canRemoveLast())
         append(other.removeLast());
@@ -239 +239 @@
 {
 #if ENABLE(PARALLEL_GC)
-    for (unsigned i = 1; i < Heuristics::numberOfGCMarkers; ++i) {
+    for (unsigned i = 1; i < Options::numberOfGCMarkers; ++i) {
         m_markingThreads.append(createThread(markingThreadStartFunc, this, "JavaScriptCore::Marking"));
         ASSERT(m_markingThreads.last());
@@ -330 +330 @@
         // Only wake up threads if the shared stack is big enough; otherwise assume that
         // it's more profitable for us to just scan this ourselves later.
-        if (m_shared.m_sharedMarkStack.size() >= Heuristics::sharedStackWakeupThreshold)
+        if (m_shared.m_sharedMarkStack.size() >= Options::sharedStackWakeupThreshold)
             m_shared.m_markingCondition.broadcast();
     }
@@ -344 +344 @@
 
 #if ENABLE(PARALLEL_GC)
-    if (Heuristics::numberOfGCMarkers > 1) {
+    if (Options::numberOfGCMarkers > 1) {
         while (!m_stack.isEmpty()) {
             m_stack.refill();
-            for (unsigned countdown = Heuristics::minimumNumberOfScansBetweenRebalance; m_stack.canRemoveLast() && countdown--;)
+            for (unsigned countdown = Options::minimumNumberOfScansBetweenRebalance; m_stack.canRemoveLast() && countdown--;)
                 visitChildren(*this, m_stack.removeLast(), jsFinalObjectVPtr, jsArrayVPtr, jsStringVPtr);
             donateKnownParallel();
@@ -368 +368 @@
     ASSERT(m_isInParallelMode);
     
-    ASSERT(Heuristics::numberOfGCMarkers);
+    ASSERT(Options::numberOfGCMarkers);
     
     bool shouldBeParallel;
 
 #if ENABLE(PARALLEL_GC)
-    shouldBeParallel = Heuristics::numberOfGCMarkers > 1;
+    shouldBeParallel = Options::numberOfGCMarkers > 1;
 #else
-    ASSERT(Heuristics::numberOfGCMarkers == 1);
+    ASSERT(Options::numberOfGCMarkers == 1);
     shouldBeParallel = false;
 #endif