Changeset 95134 in webkit for trunk/Source/JavaScriptCore/bytecode/ValueProfile.h

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/ValueProfile.h (modified) (11 diffs)

trunk/Source/JavaScriptCore/bytecode/ValueProfile.h

@@ -31 +31 @@
 
 #include "JSArray.h"
+#include "PredictedType.h"
 #include "Structure.h"
 #include "WriteBarrier.h"
@@ -45 +46 @@
     
     ValueProfile(int bytecodeOffset)
-        : bytecodeOffset(bytecodeOffset)
+        : m_bytecodeOffset(bytecodeOffset)
+        , m_prediction(PredictNone)
+        , m_numberOfSamplesInPrediction(0)
     {
         for (unsigned i = 0; i < numberOfBuckets; ++i)
-            buckets[i] = JSValue::encode(JSValue());
+            m_buckets[i] = JSValue::encode(JSValue());
     }
     
     const ClassInfo* classInfo(unsigned bucket) const
     {
-        if (!!buckets[bucket]) {
-            JSValue value = JSValue::decode(buckets[bucket]);
+        if (!!m_buckets[bucket]) {
+            JSValue value = JSValue::decode(m_buckets[bucket]);
             if (!value.isCell())
                 return 0;
             return value.asCell()->structure()->classInfo();
         }
-        return weakBuckets[bucket].getClassInfo();
+        return m_weakBuckets[bucket].getClassInfo();
     }
     
@@ -66 +69 @@
         unsigned result = 0;
         for (unsigned i = 0; i < numberOfBuckets; ++i) {
-            if (!!buckets[i] || !!weakBuckets[i])
-                result++;
-        }
-        return result;
+            if (!!m_buckets[i] || !!m_weakBuckets[i])
+                result++;
+        }
+        return result;
+    }
+    
+    unsigned totalNumberOfSamples() const
+    {
+        return numberOfSamples() + m_numberOfSamplesInPrediction;
+    }
+    
+    bool isLive() const
+    {
+        for (unsigned i = 0; i < numberOfBuckets; ++i) {
+            if (!!m_buckets[i] || !!m_weakBuckets[i])
+                return true;
+        }
+        return false;
     }
     
@@ -83 +100 @@
         unsigned result = 0;
         for (unsigned i = 0; i < numberOfBuckets; ++i) {
-            if (!!buckets[i] && JSValue::decode(buckets[i]).isInt32())
+            if (!!m_buckets[i] && JSValue::decode(m_buckets[i]).isInt32())
                 result++;
         }
@@ -93 +110 @@
         unsigned result = 0;
         for (unsigned i = 0; i < numberOfBuckets; ++i) {
-            if (!!buckets[i] && JSValue::decode(buckets[i]).isDouble())
+            if (!!m_buckets[i] && JSValue::decode(m_buckets[i]).isDouble())
                 result++;
         }
@@ -154 +171 @@
         unsigned result = 0;
         for (unsigned i = 0; i < numberOfBuckets; ++i) {
-            if (!!buckets[i] && JSValue::decode(buckets[i]).isBoolean())
+            if (!!m_buckets[i] && JSValue::decode(m_buckets[i]).isBoolean())
                 result++;
         }
@@ -209 +226 @@
     {
         fprintf(out,
-                "samples = %u, int32 = %u (%u), double = %u (%u), cell = %u (%u), object = %u (%u), final object = %u (%u), array = %u (%u), string = %u (%u), boolean = %u (%u)",
+                "samples = %u, int32 = %u (%u), double = %u (%u), cell = %u (%u), object = %u (%u), final object = %u (%u), array = %u (%u), string = %u (%u), boolean = %u (%u), prediction = %s, samples in prediction = %u",
                 numberOfSamples(),
                 probabilityOfInt32(), numberOfInt32s(),
@@ -218 +235 @@
                 probabilityOfArray(), numberOfArrays(),
                 probabilityOfString(), numberOfStrings(),
-                probabilityOfBoolean(), numberOfBooleans());
+                probabilityOfBoolean(), numberOfBooleans(),
+                predictionToString(m_prediction), m_numberOfSamplesInPrediction);
         bool first = true;
         for (unsigned i = 0; i < numberOfBuckets; ++i) {
-            if (!!buckets[i] || !!weakBuckets[i]) {
+            if (!!m_buckets[i] || !!m_weakBuckets[i]) {
                 if (first) {
                     fprintf(out, ": ");
@@ -229 +247 @@
             }
             
-            if (!!buckets[i])
-                fprintf(out, "%s", JSValue::decode(buckets[i]).description());
+            if (!!m_buckets[i])
+                fprintf(out, "%s", JSValue::decode(m_buckets[i]).description());
             
-            if (!!weakBuckets[i])
+            if (!!m_weakBuckets[i])
                 fprintf(out, "DeadCell");
         }
@@ -258 +276 @@
     // incrementing the number of samples, which the caller is responsible for
     // doing.
-    static void computeStatistics(const ClassInfo* classInfo, Statistics& statistics)
-    {
-        statistics.cells++;
-        
-        if (classInfo == &JSFinalObject::s_info) {
-            statistics.finalObjects++;
-            statistics.objects++;
-            return;
-        }
-        
-        if (classInfo == &JSArray::s_info) {
-            statistics.arrays++;
-            statistics.objects++;
-            return;
-        }
-        
-        if (classInfo == &JSString::s_info) {
-            statistics.strings++;
-            return;
-        }
-        
-        if (classInfo->isSubClassOf(&JSObject::s_info))
-            statistics.objects++;
-    }
+    static void computeStatistics(const ClassInfo*, Statistics&);
 
     // Optimized method for getting all counts at once.
-    void computeStatistics(Statistics& statistics) const
-    {
-        for (unsigned i = 0; i < numberOfBuckets; ++i) {
-            if (!buckets[i]) {
-                WeakBucket weakBucket = weakBuckets[i];
-                if (!!weakBucket) {
-                    statistics.samples++;
-                    computeStatistics(weakBucket.getClassInfo(), statistics);
-                }
-                
-                continue;
-            }
-            
-            statistics.samples++;
-            
-            JSValue value = JSValue::decode(buckets[i]);
-            if (value.isInt32())
-                statistics.int32s++;
-            else if (value.isDouble())
-                statistics.doubles++;
-            else if (value.isCell())
-                computeStatistics(value.asCell()->structure()->classInfo(), statistics);
-            else if (value.isBoolean())
-                statistics.booleans++;
-        }
-    }
-    
-    int bytecodeOffset; // -1 for prologue
-    EncodedJSValue buckets[numberOfBuckets];
+    void computeStatistics(Statistics&) const;
+    
+    // Updates the prediction and returns the new one.
+    PredictedType computeUpdatedPrediction();
+    
+    int m_bytecodeOffset; // -1 for prologue
+    
+    PredictedType m_prediction;
+    unsigned m_numberOfSamplesInPrediction;
+    
+    EncodedJSValue m_buckets[numberOfBuckets];
     
     class WeakBucket {
@@ -376 +353 @@
     };
     
-    WeakBucket weakBuckets[numberOfBuckets]; // this is not covered by a write barrier because it is only set from GC
+    WeakBucket m_weakBuckets[numberOfBuckets]; // this is not covered by a write barrier because it is only set from GC
 };
 
 inline int getValueProfileBytecodeOffset(ValueProfile* valueProfile)
 {
-    return valueProfile->bytecodeOffset;
+    return valueProfile->m_bytecodeOffset;
 }
 #endif