Changeset 122206 in webkit for trunk/Source/JavaScriptCore/bytecode/CodeBlock.h

Timestamp:

Jul 10, 2012, 2:18:47 AM (13 years ago)

Author:

[email protected]

Message:

DFG recompilation heuristics should be based on count, not rate
​https://bugs.webkit.org/show_bug.cgi?id=90146

Reviewed by Oliver Hunt.

Rolling r121511 back in after fixing the DFG's interpretation of op_div
profiling, with Gavin's rubber stamp.

This removes a bunch of code that was previously trying to prevent spurious
reoptimizations if a large enough majority of executions of a code block did
not result in OSR exit. It turns out that this code was purely harmful. This
patch removes all of that logic and replaces it with a dead-simple
heuristic: if you exit more than N times (where N is an exponential function
of the number of times the code block has already been recompiled) then we
will recompile.

This appears to be a broad ~1% win on many benchmarks large and small.

• bytecode/CodeBlock.cpp:

(JSC::CodeBlock::CodeBlock):

• bytecode/CodeBlock.h:

(JSC::CodeBlock::couldTakeSpecialFastCase):
(CodeBlock):
(JSC::CodeBlock::osrExitCounter):
(JSC::CodeBlock::countOSRExit):
(JSC::CodeBlock::addressOfOSRExitCounter):
(JSC::CodeBlock::offsetOfOSRExitCounter):
(JSC::CodeBlock::adjustedExitCountThreshold):
(JSC::CodeBlock::exitCountThresholdForReoptimization):
(JSC::CodeBlock::exitCountThresholdForReoptimizationFromLoop):
(JSC::CodeBlock::shouldReoptimizeNow):
(JSC::CodeBlock::shouldReoptimizeFromLoopNow):

• bytecode/ExecutionCounter.cpp:

(JSC::ExecutionCounter::setThreshold):

• bytecode/ExecutionCounter.h:

(ExecutionCounter):
(JSC::ExecutionCounter::clippedThreshold):

• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::makeDivSafe):

• dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::compileBody):

• dfg/DFGOSRExit.cpp:

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

• dfg/DFGOSRExitCompiler.cpp:

(JSC::DFG::OSRExitCompiler::handleExitCounts):

• dfg/DFGOperations.cpp:
• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

• runtime/Options.h:

(JSC):

File:

• trunk/Source/JavaScriptCore/bytecode/CodeBlock.h (modified) (3 diffs)

trunk/Source/JavaScriptCore/bytecode/CodeBlock.h

@@ -717 +717 @@
         }
         
+        bool couldTakeSpecialFastCase(int bytecodeOffset)
+        {
+            if (!numberOfRareCaseProfiles())
+                return false;
+            unsigned specialFastCaseCount = specialFastCaseProfileForBytecodeOffset(bytecodeOffset)->m_counter;
+            return specialFastCaseCount >= Options::couldTakeSlowCaseMinimumCount() && static_cast<double>(specialFastCaseCount) / m_executionEntryCount >= Options::couldTakeSlowCaseThreshold();
+        }
+        
         bool likelyToTakeDeepestSlowCase(int bytecodeOffset)
         {
@@ -1093 +1101 @@
         }
         
-        // The speculative JIT tracks its success rate, so that we can
-        // decide when to reoptimize. It's interesting to note that these
-        // counters may overflow without any protection. The success
-        // counter will overflow before the fail one does, becuase the
-        // fail one is used as a trigger to reoptimize. So the worst case
-        // is that the success counter overflows and we reoptimize without
-        // needing to. But this is harmless. If a method really did
-        // execute 2^32 times then compiling it again probably won't hurt
-        // anyone.
-        
-        void countSpeculationSuccess()
-        {
-            m_speculativeSuccessCounter++;
-        }
-        
-        void countSpeculationFailure()
-        {
-            m_speculativeFailCounter++;
-        }
-        
-        uint32_t speculativeSuccessCounter() const { return m_speculativeSuccessCounter; }
-        uint32_t speculativeFailCounter() const { return m_speculativeFailCounter; }
-        uint32_t forcedOSRExitCounter() const { return m_forcedOSRExitCounter; }
-        
-        uint32_t* addressOfSpeculativeSuccessCounter() { return &m_speculativeSuccessCounter; }
-        uint32_t* addressOfSpeculativeFailCounter() { return &m_speculativeFailCounter; }
-        uint32_t* addressOfForcedOSRExitCounter() { return &m_forcedOSRExitCounter; }
-        
-        static ptrdiff_t offsetOfSpeculativeSuccessCounter() { return OBJECT_OFFSETOF(CodeBlock, m_speculativeSuccessCounter); }
-        static ptrdiff_t offsetOfSpeculativeFailCounter() { return OBJECT_OFFSETOF(CodeBlock, m_speculativeFailCounter); }
-        static ptrdiff_t offsetOfForcedOSRExitCounter() { return OBJECT_OFFSETOF(CodeBlock, m_forcedOSRExitCounter); }
+        uint32_t osrExitCounter() const { return m_osrExitCounter; }
+        
+        void countOSRExit() { m_osrExitCounter++; }
+        
+        uint32_t* addressOfOSRExitCounter() { return &m_osrExitCounter; }
+        
+        static ptrdiff_t offsetOfOSRExitCounter() { return OBJECT_OFFSETOF(CodeBlock, m_osrExitCounter); }
 
 #if ENABLE(JIT)
-        // The number of failures that triggers the use of the ratio.
-        unsigned largeFailCountThreshold() { return Options::largeFailCountThresholdBase() << baselineVersion()->reoptimizationRetryCounter(); }
-        unsigned largeFailCountThresholdForLoop() { return Options::largeFailCountThresholdBaseForLoop() << baselineVersion()->reoptimizationRetryCounter(); }
+        uint32_t adjustedExitCountThreshold(uint32_t desiredThreshold)
+        {
+            ASSERT(getJITType() == JITCode::DFGJIT);
+            // Compute this the lame way so we don't saturate. This is called infrequently
+            // enough that this loop won't hurt us.
+            unsigned result = desiredThreshold;
+            for (unsigned n = baselineVersion()->reoptimizationRetryCounter(); n--;) {
+                unsigned newResult = result << 1;
+                if (newResult < result)
+                    return std::numeric_limits<uint32_t>::max();
+                result = newResult;
+            }
+            return result;
+        }
+        
+        uint32_t exitCountThresholdForReoptimization()
+        {
+            return adjustedExitCountThreshold(Options::osrExitCountForReoptimization());
+        }
+        
+        uint32_t exitCountThresholdForReoptimizationFromLoop()
+        {
+            return adjustedExitCountThreshold(Options::osrExitCountForReoptimizationFromLoop());
+        }
 
         bool shouldReoptimizeNow()
         {
-            return (Options::desiredSpeculativeSuccessFailRatio() *
-                        speculativeFailCounter() >= speculativeSuccessCounter()
-                    && speculativeFailCounter() >= largeFailCountThreshold())
-                || forcedOSRExitCounter() >=
-                       Options::forcedOSRExitCountForReoptimization();
-        }
-
+            return osrExitCounter() >= exitCountThresholdForReoptimization();
+        }
+        
         bool shouldReoptimizeFromLoopNow()
         {
-            return (Options::desiredSpeculativeSuccessFailRatio() *
-                        speculativeFailCounter() >= speculativeSuccessCounter()
-                    && speculativeFailCounter() >= largeFailCountThresholdForLoop())
-                || forcedOSRExitCounter() >=
-                       Options::forcedOSRExitCountForReoptimization();
+            return osrExitCounter() >= exitCountThresholdForReoptimizationFromLoop();
         }
 #endif
@@ -1348 +1345 @@
         ExecutionCounter m_jitExecuteCounter;
         int32_t m_totalJITExecutions;
-        uint32_t m_speculativeSuccessCounter;
-        uint32_t m_speculativeFailCounter;
-        uint32_t m_forcedOSRExitCounter;
+        uint32_t m_osrExitCounter;
         uint16_t m_optimizationDelayCounter;
         uint16_t m_reoptimizationRetryCounter;