Changeset 95134 in webkit for trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

Timestamp:

Sep 14, 2011, 4:00:26 PM (14 years ago)

Author:

[email protected]

Message:

Tiered compilation heuristics do not account for value profile fullness
​https://bugs.webkit.org/show_bug.cgi?id=68116

Reviewed by Oliver Hunt.

Tiered compilation avoids invoking the DFG JIT if it finds that value
profiles contain insufficient information. Instead, it produces a
prediction from the current value profile, and then clears the value
profile. This allows the value profile to heat up from scratch for
some number of additional executions. The new profiles will then be
merged with the previous prediction. Once the amount of information
in predictions is enough according to heuristics in CodeBlock.cpp,
DFG optimization is allowed to proceed.

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

(JSC::CodeBlock::CodeBlock):
(JSC::CodeBlock::~CodeBlock):
(JSC::CodeBlock::visitAggregate):
(JSC::CodeBlock::visitWeakReferences):
(JSC::CodeBlock::shouldOptimizeNow):
(JSC::CodeBlock::dumpValueProfiles):

• bytecode/CodeBlock.h:
• bytecode/PredictedType.cpp:

(JSC::predictionToString):

• bytecode/PredictedType.h:
• bytecode/ValueProfile.cpp: Added.

(JSC::ValueProfile::computeStatistics):
(JSC::ValueProfile::computeUpdatedPrediction):

• bytecode/ValueProfile.h:

(JSC::ValueProfile::ValueProfile):
(JSC::ValueProfile::classInfo):
(JSC::ValueProfile::numberOfSamples):
(JSC::ValueProfile::totalNumberOfSamples):
(JSC::ValueProfile::isLive):
(JSC::ValueProfile::numberOfInt32s):
(JSC::ValueProfile::numberOfDoubles):
(JSC::ValueProfile::numberOfBooleans):
(JSC::ValueProfile::dump):
(JSC::getValueProfileBytecodeOffset):

• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::stronglyPredict):

• dfg/DFGGraph.cpp:

(JSC::DFG::Graph::predictArgumentTypes):

• dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::exitSpeculativeWithOSR):
(JSC::DFG::JITCompiler::jumpFromSpeculativeToNonSpeculative):

• jit/JIT.cpp:

(JSC::JIT::emitOptimizationCheck):

• jit/JITInlineMethods.h:

(JSC::JIT::emitValueProfilingSite):

• jit/JITStubs.cpp:

(JSC::DEFINE_STUB_FUNCTION):

File:

• trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp (modified) (7 diffs)

trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -1429 +1429 @@
     , m_symbolTable(symTab)
     , m_alternative(alternative)
+    , m_optimizationDelayCounter(0)
 {
     ASSERT(m_source);
@@ -1442 +1443 @@
 {
 #if ENABLE(VERBOSE_VALUE_PROFILE)
-    fprintf(stderr, "ValueProfile for %p:\n", this);
-    for (unsigned i = 0; i < numberOfValueProfiles(); ++i) {
-        ValueProfile* profile = valueProfile(i);
-        if (profile->bytecodeOffset < 0) {
-            ASSERT(profile->bytecodeOffset == -1);
-            fprintf(stderr, "   arg = %u: ", i + 1);
-        } else
-            fprintf(stderr, "   bc = %d: ", profile->bytecodeOffset);
-        profile->dump(stderr);
-        fprintf(stderr, "\n");
-    }
+    dumpValueProfiles();
 #endif
     
@@ -1591 +1582 @@
         
         for (unsigned index = 0; index < ValueProfile::numberOfBuckets; ++index) {
-            if (!profile->buckets[index]) {
-                if (!!profile->weakBuckets[index])
+            if (!profile->m_buckets[index]) {
+                if (!!profile->m_weakBuckets[index])
                     handleWeakReferences = true;
                 continue;
             }
             
-            if (!JSValue::decode(profile->buckets[index]).isCell()) {
-                profile->weakBuckets[index] = ValueProfile::WeakBucket();
+            if (!JSValue::decode(profile->m_buckets[index]).isCell()) {
+                profile->m_weakBuckets[index] = ValueProfile::WeakBucket();
                 continue;
             }
@@ -1618 +1609 @@
         
         for (unsigned index = 0; index < ValueProfile::numberOfBuckets; ++index) {
-            if (!!profile->buckets[index]) {
-                JSValue value = JSValue::decode(profile->buckets[index]);
+            if (!!profile->m_buckets[index]) {
+                JSValue value = JSValue::decode(profile->m_buckets[index]);
                 if (!value.isCell())
                     continue;
@@ -1627 +1618 @@
                     continue;
                 
-                profile->buckets[index] = JSValue::encode(JSValue());
-                profile->weakBuckets[index] = cell->structure();
+                profile->m_buckets[index] = JSValue::encode(JSValue());
+                profile->m_weakBuckets[index] = cell->structure();
             }
             
-            ValueProfile::WeakBucket weak = profile->weakBuckets[index];
+            ValueProfile::WeakBucket weak = profile->m_weakBuckets[index];
             if (!weak || weak.isClassInfo())
                 continue;
@@ -1639 +1630 @@
                 continue;
             
-            profile->weakBuckets[index] = weak.asStructure()->classInfo();
+            profile->m_weakBuckets[index] = weak.asStructure()->classInfo();
         }
     }
@@ -1947 +1938 @@
 #endif
 
+#if ENABLE(VALUE_PROFILER)
+bool CodeBlock::shouldOptimizeNow()
+{
+#if ENABLE(JIT_VERBOSE_OSR)
+    printf("Considering optimizing %p...\n", this);
+#endif
+
+#if ENABLE(VERBOSE_VALUE_PROFILE)
+    dumpValueProfiles();
+#endif
+
+    if (m_optimizationDelayCounter >= 5)
+        return true;
+    
+    unsigned numberOfNonArgumentValueProfiles = 0;
+    unsigned numberOfLiveNonArgumentValueProfiles = 0;
+    unsigned numberOfSamplesInProfiles = 0; // If this divided by ValueProfile::numberOfBuckets equals numberOfValueProfiles() then value profiles are full.
+    for (unsigned i = 0; i < numberOfValueProfiles(); ++i) {
+        ValueProfile* profile = valueProfile(i);
+        unsigned numSamples = profile->totalNumberOfSamples();
+        if (numSamples > ValueProfile::numberOfBuckets)
+            numSamples = ValueProfile::numberOfBuckets; // We don't want profiles that are extremely hot to be given more weight.
+        numberOfSamplesInProfiles += numSamples;
+        if (profile->m_bytecodeOffset < 0) {
+            profile->computeUpdatedPrediction();
+            continue;
+        }
+        numberOfNonArgumentValueProfiles++;
+        if (profile->numberOfSamples() || profile->m_prediction != PredictNone)
+            numberOfLiveNonArgumentValueProfiles++;
+        profile->computeUpdatedPrediction();
+    }
+
+#if ENABLE(JIT_VERBOSE_OSR)
+    printf("Profile hotness: %lf, %lf\n", (double)numberOfLiveNonArgumentValueProfiles / numberOfNonArgumentValueProfiles, (double)numberOfSamplesInProfiles / ValueProfile::numberOfBuckets / numberOfValueProfiles());
+#endif
+
+    if ((double)numberOfLiveNonArgumentValueProfiles / numberOfNonArgumentValueProfiles >= 0.75
+        && (double)numberOfSamplesInProfiles / ValueProfile::numberOfBuckets / numberOfValueProfiles() >= 0.5)
+        return true;
+    
+    m_optimizationDelayCounter++;
+    optimizeAfterWarmUp();
+    return false;
+}
+#endif
+
+#if ENABLE(VERBOSE_VALUE_PROFILE)
+void CodeBlock::dumpValueProfiles()
+{
+    fprintf(stderr, "ValueProfile for %p:\n", this);
+    for (unsigned i = 0; i < numberOfValueProfiles(); ++i) {
+        ValueProfile* profile = valueProfile(i);
+        if (profile->m_bytecodeOffset < 0) {
+            ASSERT(profile->m_bytecodeOffset == -1);
+            fprintf(stderr, "   arg = %u: ", i + 1);
+        } else
+            fprintf(stderr, "   bc = %d: ", profile->m_bytecodeOffset);
+        if (!profile->numberOfSamples() && profile->m_prediction == PredictNone) {
+            fprintf(stderr, "<empty>\n");
+            continue;
+        }
+        profile->dump(stderr);
+        fprintf(stderr, "\n");
+    }
+}
+#endif
+
 } // namespace JSC