Compute the final score using geometric mean in Speedometer 2.0
authorrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 6 Sep 2017 02:37:41 +0000 (02:37 +0000)
committerrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 6 Sep 2017 02:37:41 +0000 (02:37 +0000)
https://bugs.webkit.org/show_bug.cgi?id=172968

Reviewed by Saam Barati.

Make Speedometer 2.0 use the geometric mean of the subtotal of each test suite instead of the total..

In Speedometer 1.0, we used the total time to compute the final score because we wanted to make
the slowest framework and library faster. The fastest suite (FlightJS) still accounted for ~6% and
the slowest case (React) accounted for ~25% so we felt the total time, or the arithmetic mean with
a constant factor, was a good metric to track.

In the latest version of Speedometer 2.0, however, the fastest suite (Preact) runs in ~55ms whereas
the slowest suite (Inferno) takes 1.5s on Safari. Since the total time is 6.5s, Preact's suite only
accounts for ~0.8% of the total score while Inferno's suite accounts for ~23% of the total score.
Since the goal of Speedometer is to approximate different kinds of DOM API use patterns on the Web,
we want each framework & library to have some measurement impact on the overall benchmark score.

Furthermore, after r221205, we're testing both debug build of Ember.js as well as release build.
Since debug build is 4x slower, using the total time or the arithmetic mean thereof will effectively
give 4x as much weight to debug build of Ember.js relative to release build of Ember.js. Given only
~5% of websites that deploy Ember.js use debug build, this weighting is clearly not right.

This patch, therefore, replaces the arithmetic mean by the geometric mean to compute the final score.
It also moves the code to compute the final score to BenchmarkRunner to be shared between main.js
and InteractiveRunner.html.

* Speedometer/InteractiveRunner.html:
(.didRunSuites): Show geometric mean, arithmetic mean, total, as well as the score for completeness
since this is a debugging page for developers.
* Speedometer/resources/benchmark-runner.js:
(BenchmarkRunner.prototype.step): Added mean, geomean, and score as measuredValues' properties.
(BenchmarkRunner.prototype._runTestAndRecordResults): Removed the dead code.
(BenchmarkRunner.prototype._finalize): Compute and add total, arithmetic mean (just mean in the code),
and geometric mean (geomean) to measuredValues.
* Speedometer/resources/main.js:
(window.benchmarkClient): Replaced testsCount by stepsCount and _timeValues by _measuredValuesList.
(window.benchmarkClient.willRunTest):
(window.benchmarkClient.didRunTest):
(window.benchmarkClient.didRunSuites): Store measuredValues object instead of just the total time.
(window.benchmarkClient.didFinishLastIteration):
(window.benchmarkClient._computeResults):
(window.benchmarkClient._computeResults.valueForUnit): Renamed from totalTimeInDisplayUnit. Now simply
retrieves the values computed by BenchmarkRunner's_finalize.
(startBenchmark):
(computeScore): Deleted.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@221659 268f45cc-cd09-0410-ab3c-d52691b4dbfc

PerformanceTests/ChangeLog
PerformanceTests/Speedometer/InteractiveRunner.html
PerformanceTests/Speedometer/resources/benchmark-runner.js
PerformanceTests/Speedometer/resources/main.js

index 1af9f76..75ed920 100644 (file)
@@ -1,3 +1,52 @@
+2017-09-05  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Compute the final score using geometric mean in Speedometer 2.0
+        https://bugs.webkit.org/show_bug.cgi?id=172968
+
+        Reviewed by Saam Barati.
+
+        Make Speedometer 2.0 use the geometric mean of the subtotal of each test suite instead of the total..
+
+        In Speedometer 1.0, we used the total time to compute the final score because we wanted to make
+        the slowest framework and library faster. The fastest suite (FlightJS) still accounted for ~6% and
+        the slowest case (React) accounted for ~25% so we felt the total time, or the arithmetic mean with
+        a constant factor, was a good metric to track.
+
+        In the latest version of Speedometer 2.0, however, the fastest suite (Preact) runs in ~55ms whereas
+        the slowest suite (Inferno) takes 1.5s on Safari. Since the total time is 6.5s, Preact's suite only
+        accounts for ~0.8% of the total score while Inferno's suite accounts for ~23% of the total score.
+        Since the goal of Speedometer is to approximate different kinds of DOM API use patterns on the Web,
+        we want each framework & library to have some measurement impact on the overall benchmark score.
+
+        Furthermore, after r221205, we're testing both debug build of Ember.js as well as release build.
+        Since debug build is 4x slower, using the total time or the arithmetic mean thereof will effectively
+        give 4x as much weight to debug build of Ember.js relative to release build of Ember.js. Given only
+        ~5% of websites that deploy Ember.js use debug build, this weighting is clearly not right.
+
+        This patch, therefore, replaces the arithmetic mean by the geometric mean to compute the final score.
+        It also moves the code to compute the final score to BenchmarkRunner to be shared between main.js
+        and InteractiveRunner.html.
+
+        * Speedometer/InteractiveRunner.html:
+        (.didRunSuites): Show geometric mean, arithmetic mean, total, as well as the score for completeness
+        since this is a debugging page for developers.
+        * Speedometer/resources/benchmark-runner.js:
+        (BenchmarkRunner.prototype.step): Added mean, geomean, and score as measuredValues' properties.
+        (BenchmarkRunner.prototype._runTestAndRecordResults): Removed the dead code.
+        (BenchmarkRunner.prototype._finalize): Compute and add total, arithmetic mean (just mean in the code),
+        and geometric mean (geomean) to measuredValues.
+        * Speedometer/resources/main.js:
+        (window.benchmarkClient): Replaced testsCount by stepsCount and _timeValues by _measuredValuesList.
+        (window.benchmarkClient.willRunTest):
+        (window.benchmarkClient.didRunTest):
+        (window.benchmarkClient.didRunSuites): Store measuredValues object instead of just the total time.
+        (window.benchmarkClient.didFinishLastIteration):
+        (window.benchmarkClient._computeResults):
+        (window.benchmarkClient._computeResults.valueForUnit): Renamed from totalTimeInDisplayUnit. Now simply
+        retrieves the values computed by BenchmarkRunner's_finalize.
+        (startBenchmark):
+        (computeScore): Deleted.
+
 2017-09-05  JF Bastien  <jfbastien@apple.com>
 
         StitchMarker build fix
index 20ca6a1..21db2c0 100644 (file)
@@ -141,7 +141,10 @@ function startTest() {
                 }
                 results += suiteName + ' : ' + suiteResults.total + ' ms\n';
             }
+            results += 'Arithemtic Mean : ' + measuredValues.mean  + ' ms\n';
+            results += 'Geometric Mean : ' + measuredValues.geomean  + ' ms\n';
             results += 'Total : ' + measuredValues.total + ' ms\n';
+            results += 'Score : ' + measuredValues.score + ' rpm\n';
 
             if (!results)
                 return;
index 1974b3f..47cedfc 100644 (file)
@@ -194,7 +194,7 @@ BenchmarkState.prototype.prepareCurrentSuite = function (runner, frame) {
 BenchmarkRunner.prototype.step = function (state) {
     if (!state) {
         state = new BenchmarkState(this._suites);
-        this._measuredValues = {tests: {}, total: 0};
+        this._measuredValues = {tests: {}, total: 0, mean: NaN, geomean: NaN, score: NaN};
     }
 
     var suite = state.currentSuite();
@@ -207,7 +207,6 @@ BenchmarkRunner.prototype.step = function (state) {
 
     if (state.isFirstTest()) {
         this._removeFrame();
-        this._masuredValuesForCurrentSuite = {};
         var self = this;
         return state.prepareCurrentSuite(this, this._appendFrame()).then(function (prepareReturnValue) {
             self._prepareReturnValue = prepareReturnValue;
@@ -260,7 +259,6 @@ BenchmarkRunner.prototype._runTestAndRecordResults = function (state) {
             self._measuredValues.tests[suite.name] = suiteResults;
             suiteResults.tests[test.name] = {tests: {'Sync': syncTime, 'Async': asyncTime}, total: total};
             suiteResults.total += total;
-            self._measuredValues.total += total;
 
             if (self._client && self._client.didRunTest)
                 self._client.didRunTest(suite, test);
@@ -275,8 +273,26 @@ BenchmarkRunner.prototype._runTestAndRecordResults = function (state) {
 BenchmarkRunner.prototype._finalize = function () {
     this._removeFrame();
 
-    if (this._client && this._client.didRunSuites)
+    if (this._client && this._client.didRunSuites) {
+        var product = 1;
+        var values = [];
+        for (var suiteName in this._measuredValues.tests) {
+            var suiteTotal = this._measuredValues.tests[suiteName].total;
+            product *= suiteTotal;
+            values.push(suiteTotal);
+        }
+
+        values.sort(function (a, b) { return a - b }); // Avoid the loss of significance for the sum.
+        var total = values.reduce(function (a, b) { return a + b });
+        var geomean = Math.pow(product, 1 / values.length);
+
+        var correctionFactor = 3; // This factor makes the test score look reasonably fit within 0 to 140.
+        this._measuredValues.total = total;
+        this._measuredValues.mean = total / values.length;
+        this._measuredValues.geomean = geomean;
+        this._measuredValues.score = 60 * 1000 / geomean / correctionFactor;
         this._client.didRunSuites(this._measuredValues);
+    }
 
     if (this._runNextIteration)
         this._runNextIteration();
index 59dc7e1..2ab8777 100644 (file)
@@ -1,9 +1,9 @@
 window.benchmarkClient = {
     displayUnit: 'runs/min',
     iterationCount: 10,
-    testsCount: null,
+    stepCount: null,
     suitesCount: null,
-    _timeValues: [],
+    _measuredValuesList: [],
     _finishedTestCount: 0,
     _progressCompleted: null,
     willAddTestFrame: function (frame) {
@@ -13,17 +13,17 @@ window.benchmarkClient = {
         frame.style.top = main.offsetTop + parseInt(style.borderTopWidth) + parseInt(style.paddingTop) + 'px';
     },
     willRunTest: function (suite, test) {
-        document.getElementById('info').textContent = suite.name + ' ( ' + this._finishedTestCount + ' / ' + this.testsCount + ' )';
+        document.getElementById('info').textContent = suite.name + ' ( ' + this._finishedTestCount + ' / ' + this.stepCount + ' )';
     },
     didRunTest: function () {
         this._finishedTestCount++;
-        this._progressCompleted.style.width = (this._finishedTestCount * 100 / this.testsCount) + '%';
+        this._progressCompleted.style.width = (this._finishedTestCount * 100 / this.stepCount) + '%';
     },
     didRunSuites: function (measuredValues) {
-        this._timeValues.push(measuredValues.total);
+        this._measuredValuesList.push(measuredValues);
     },
     willStartFirstIteration: function () {
-        this._timeValues = [];
+        this._measuredValuesList = [];
         this._finishedTestCount = 0;
         this._progressCompleted = document.getElementById('progress-completed');
         document.getElementById('logo-link').onclick = function (event) { event.preventDefault(); return false; }
@@ -31,7 +31,7 @@ window.benchmarkClient = {
     didFinishLastIteration: function () {
         document.getElementById('logo-link').onclick = null;
 
-        var results = this._computeResults(this._timeValues, this.displayUnit);
+        var results = this._computeResults(this._measuredValuesList, this.displayUnit);
 
         this._updateGaugeNeedle(results.mean);
         document.getElementById('result-number').textContent = results.formattedMean;
@@ -47,12 +47,12 @@ window.benchmarkClient = {
         } else
             showResultsSummary();
     },
-    _computeResults: function (timeValues, displayUnit) {
+    _computeResults: function (measuredValuesList, displayUnit) {
         var suitesCount = this.suitesCount;
-        function totalTimeInDisplayUnit(time) {
+        function valueForUnit(measuredValues) {
             if (displayUnit == 'ms')
-                return time;
-            return computeScore(time);
+                return measuredValues.geomean;
+            return measuredValues.score;
         }
 
         function sigFigFromPercentDelta(percentDelta) {
@@ -64,7 +64,7 @@ window.benchmarkClient = {
             return number.toPrecision(Math.max(nonDecimalDigitCount, Math.min(6, sigFig)));
         }
 
-        var values = timeValues.map(totalTimeInDisplayUnit);
+        var values = measuredValuesList.map(valueForUnit);
         var sum = values.reduce(function (a, b) { return a + b; }, 0);
         var arithmeticMean = sum / values.length;
         var meanSigFig = 4;
@@ -83,8 +83,8 @@ window.benchmarkClient = {
         var formattedMean = toSigFigPrecision(arithmeticMean, Math.max(meanSigFig, 3));
 
         return {
-            formattedValues: timeValues.map(function (time) {
-                return toSigFigPrecision(totalTimeInDisplayUnit(time), 4) + ' ' + displayUnit;
+            formattedValues: values.map(function (value) {
+                return toSigFigPrecision(value, 4) + ' ' + displayUnit;
             }),
             mean: arithmeticMean,
             formattedMean: formattedMean,
@@ -196,8 +196,8 @@ function startBenchmark() {
     }
 
     var enabledSuites = Suites.filter(function (suite) { return !suite.disabled; });
-    var totalSubtestCount = enabledSuites.reduce(function (testsCount, suite) { return testsCount + suite.tests.length; }, 0);
-    benchmarkClient.testsCount = benchmarkClient.iterationCount * totalSubtestCount;
+    var totalSubtestsCount = enabledSuites.reduce(function (testsCount, suite) { return testsCount + suite.tests.length; }, 0);
+    benchmarkClient.stepCount = benchmarkClient.iterationCount * totalSubtestsCount;
     benchmarkClient.suitesCount = enabledSuites.length;
     var runner = new BenchmarkRunner(Suites, benchmarkClient);
     runner.runMultipleIterations(benchmarkClient.iterationCount);
@@ -205,10 +205,6 @@ function startBenchmark() {
     return true;
 }
 
-function computeScore(time) {
-    return 60 * 1000 * benchmarkClient.suitesCount / time;
-}
-
 function showSection(sectionIdentifier, pushState) {
     var currentSectionElement = document.querySelector('section.selected');
     console.assert(currentSectionElement);