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

Timestamp:

Sep 14, 2011, 1:35:43 PM (14 years ago)

Author:

[email protected]

Message:

Prediction tracking is not precise enough
​https://bugs.webkit.org/show_bug.cgi?id=67993

Reviewed by Oliver Hunt.

Added a richer set of type predictions, including JSFinalObject, JSString,
object that is not a JSFinalObject or JSArray (ObjectOther), some object
but we don't or care know what kind (SomeObject), definitely an object,
cell that is not an object or JSString, an value that is none of the above
(so either Undefined or Null). Made the propagator and value profiler work
with the new types.

Performance is neutral, because the DFG JIT does not take advantage of this
new knowledge yet.

In the process of writing predictionToString() (which is now considerably
more complex) I decided to finally add a BoundsCheckedPointer, which
should come in handy in other places, like at least the OSR scratch buffer
and the CompactJITCodeMap. It's great for cases where you want to
do pointer arithmetic, you want to have assertions about the
pointer not going out of bounds, but you don't want to write those
assertions yourself.

This also required refactoring inherits(), since the ValueProfiler may
want to do the equivalent of inherits() but given two ClassInfo's.

• GNUmakefile.list.am:
• JavaScriptCore.vcproj/WTF/WTF.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• bytecode/PredictedType.cpp: Added.

(JSC::predictionToString):
(JSC::makePrediction):
(JSC::predictionFromValue):

• bytecode/PredictedType.h:

(JSC::isCellPrediction):
(JSC::isObjectPrediction):
(JSC::isFinalObjectPrediction):
(JSC::isStringPrediction):
(JSC::mergePredictions):

• bytecode/ValueProfile.h:

(JSC::ValueProfile::numberOfObjects):
(JSC::ValueProfile::numberOfFinalObjects):
(JSC::ValueProfile::numberOfStrings):
(JSC::ValueProfile::probabilityOfObject):
(JSC::ValueProfile::probabilityOfFinalObject):
(JSC::ValueProfile::probabilityOfString):
(JSC::ValueProfile::dump):
(JSC::ValueProfile::Statistics::Statistics):
(JSC::ValueProfile::computeStatistics):

• dfg/DFGByteCodeParser.cpp:

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

• dfg/DFGGraph.cpp:

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

• dfg/DFGNode.h:

(JSC::DFG::Node::predict):

• dfg/DFGPropagator.cpp:

(JSC::DFG::Propagator::propagateNode):

• runtime/ClassInfo.h:

(JSC::ClassInfo::isSubClassOf):

• runtime/JSObject.h:

(JSC::JSCell::inherits):

• wtf/BoundsCheckedPointer.h: Added.

(WTF::BoundsCheckedPointer::BoundsCheckedPointer):
(WTF::BoundsCheckedPointer::operator=):
(WTF::BoundsCheckedPointer::operator+=):
(WTF::BoundsCheckedPointer::operator-=):
(WTF::BoundsCheckedPointer::operator+):
(WTF::BoundsCheckedPointer::operator-):
(WTF::BoundsCheckedPointer::operator++):
(WTF::BoundsCheckedPointer::operator--):
(WTF::BoundsCheckedPointer::operator<):
(WTF::BoundsCheckedPointer::operator<=):
(WTF::BoundsCheckedPointer::operator>):
(WTF::BoundsCheckedPointer::operator>=):
(WTF::BoundsCheckedPointer::operator==):
(WTF::BoundsCheckedPointer::operator!=):
(WTF::BoundsCheckedPointer::operator!):
(WTF::BoundsCheckedPointer::get):
(WTF::BoundsCheckedPointer::operator*):
(WTF::BoundsCheckedPointer::operator[]):
(WTF::BoundsCheckedPointer::strcat):
(WTF::BoundsCheckedPointer::validate):

• wtf/CMakeLists.txt:

File:

• trunk/Source/JavaScriptCore/bytecode/ValueProfile.h (modified) (5 diffs)

trunk/Source/JavaScriptCore/bytecode/ValueProfile.h

@@ -109 +109 @@
     }
     
+    unsigned numberOfObjects() const
+    {
+        unsigned result = 0;
+        for (unsigned i = 0; i < numberOfBuckets; ++i) {
+            const ClassInfo* ci = classInfo(i);
+            if (!!ci && ci->isSubClassOf(&JSObject::s_info))
+                result++;
+        }
+        return result;
+    }
+    
+    unsigned numberOfFinalObjects() const
+    {
+        unsigned result = 0;
+        for (unsigned i = 0; i < numberOfBuckets; ++i) {
+            if (classInfo(i) == &JSFinalObject::s_info)
+                result++;
+        }
+        return result;
+    }
+    
+    unsigned numberOfStrings() const
+    {
+        unsigned result = 0;
+        for (unsigned i = 0; i < numberOfBuckets; ++i) {
+            if (classInfo(i) == &JSString::s_info)
+                result++;
+        }
+        return result;
+    }
+    
     unsigned numberOfArrays() const
     {
@@ -149 +180 @@
     }
     
+    unsigned probabilityOfObject() const
+    {
+        return computeProbability(numberOfObjects(), numberOfSamples());
+    }
+    
+    unsigned probabilityOfFinalObject() const
+    {
+        return computeProbability(numberOfFinalObjects(), numberOfSamples());
+    }
+    
     unsigned probabilityOfArray() const
     {
         return computeProbability(numberOfArrays(), numberOfSamples());
+    }
+    
+    unsigned probabilityOfString() const
+    {
+        return computeProbability(numberOfStrings(), numberOfSamples());
     }
     
@@ -163 +209 @@
     {
         fprintf(out,
-                "samples = %u, int32 = %u (%u), double = %u (%u), cell = %u (%u), array = %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)",
                 numberOfSamples(),
                 probabilityOfInt32(), numberOfInt32s(),
                 probabilityOfDouble(), numberOfDoubles(),
                 probabilityOfCell(), numberOfCells(),
+                probabilityOfObject(), numberOfObjects(),
+                probabilityOfFinalObject(), numberOfFinalObjects(),
                 probabilityOfArray(), numberOfArrays(),
+                probabilityOfString(), numberOfStrings(),
                 probabilityOfBoolean(), numberOfBooleans());
         bool first = true;
@@ -194 +243 @@
         unsigned doubles;
         unsigned cells;
+        unsigned objects;
+        unsigned finalObjects;
         unsigned arrays;
+        unsigned strings;
         unsigned booleans;
+        
+        Statistics()
+        {
+            bzero(this, sizeof(Statistics));
+        }
     };
+    
+    // Method for incrementing all relevant statistics for a ClassInfo, except for
+    // 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++;
+    }
 
     // Optimized method for getting all counts at once.
-    void computeStatistics(JSGlobalData& globalData, Statistics& statistics) const
-    {
-        unsigned samples  = 0;
-        unsigned int32s   = 0;
-        unsigned doubles  = 0;
-        unsigned cells    = 0;
-        unsigned arrays   = 0;
-        unsigned booleans = 0;
-        
+    void computeStatistics(Statistics& statistics) const
+    {
         for (unsigned i = 0; i < numberOfBuckets; ++i) {
             if (!buckets[i]) {
                 WeakBucket weakBucket = weakBuckets[i];
                 if (!!weakBucket) {
-                    samples++;
-                    cells++;
-                    if (weakBucket.getClassInfo() == &JSArray::s_info)
-                        arrays++;
+                    statistics.samples++;
+                    computeStatistics(weakBucket.getClassInfo(), statistics);
                 }
                 
@@ -221 +297 @@
             }
             
-            samples++;
+            statistics.samples++;
             
             JSValue value = JSValue::decode(buckets[i]);
             if (value.isInt32())
-                int32s++;
+                statistics.int32s++;
             else if (value.isDouble())
-                doubles++;
-            else if (value.isCell()) {
-                cells++;
-                if (isJSArray(&globalData, value.asCell()))
-                    arrays++;
-            } else if (value.isBoolean())
-                booleans++;
-        }
-        
-        statistics.samples  = samples;
-        statistics.int32s   = int32s;
-        statistics.doubles  = doubles;
-        statistics.cells    = cells;
-        statistics.arrays   = arrays;
-        statistics.booleans = booleans;
+                statistics.doubles++;
+            else if (value.isCell())
+                computeStatistics(value.asCell()->structure()->classInfo(), statistics);
+            else if (value.isBoolean())
+                statistics.booleans++;
+        }
     }