/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/** ****************************************************************
* window.talosDebug provides some statistical functions
* (sum, average, median, stddev) and a tpRecordTime method which
* reports some statistics about the data set, including detected
* stability point of the data (detecting first few noisy elements).
* If tpRecordTime doesn't exist globally (i.e. running outside of
* talos, e.g. in a browser), then it points it to window.talosDebug.tpRecordTime
* Can be controlled by few properties (disable display, hardcoded
* stability point, etc)
*
* talos-debug.js: Bug 849558
*****************************************************************/
window.talosDebug = {
// Optional config properties
disabled:
false,
ignore: -1,
// Number of items to ignore at the begining of the set. -1 for auto-detect.
displayData:
false,
// If true, will also display all the data points.
fixed: 2,
// default floating point digits for display.
// End of config
sum(values) {
return values.reduce(
function (a, b) {
return a + b;
});
},
average(values) {
var d = window.talosDebug;
return values.length ? d.sum(values) / values.length : 999999;
},
median(values) {
var clone = values.slice(0);
var sorted = clone.sort(
function (a, b) {
// eslint-disable-next-line no-nested-ternary
return a > b ? 1 : a < b ? -1 : 0;
});
var len = values.length;
if (!len) {
return 999999;
}
if (len % 2) {
// We have a middle number
return sorted[(len - 1) / 2];
}
return (sorted[len / 2] + sorted[len / 2 - 1]) / 2;
// Average value of the two middle items.
},
stddev(values, avg) {
if (values.length <= 1) {
return 0;
}
return Math.sqrt(
values
.map(
function (v) {
return Math.pow(v - avg, 2);
})
.reduce(
function (a, b) {
return a + b;
}) /
(values.length - 1)
);
},
// Estimate the number of warmup iterations of this data set (in a completely unscrientific way).
// returns -1 if could not find a stability point (supposedly meaning that the values
// are still in the process of convergence).
// Algorithm (not based on a scientific method which I know of):
// Target: Find a locally noisy value after the values show stability
// (stddev of a moving window stops decreasing), while trying to make sure
// that it wasn't a glitch and the next 2 floating window stddev are, indeed, not
// still decreasing.
// Do the above for few different window widths (3-7), get the maximum result of those.
// Now we should have an index which is at least the 2nd value within the stable part.
// We get stddev for that index..end (baseStd), and then go backwards as long as stddev is
// decreasing or within ~1% of baseStd, and return the earliest index for which it is.
detectWarmup(values) {
var MIN_WIDTH = 3;
var MAX_WIDTH = 7;
var d = window.talosDebug;
function windowStd(from, winSize) {
var win = values.slice(from, from + winSize);
return d.stddev(win, d.median(values));
}
var stableFrom = -1;
var overallAverage = d.median(values);
// var overallStd = d.stddev(values, overallAverage);
for (
var winWidth = MIN_WIDTH; winWidth < MAX_WIDTH + 1; winWidth++) {
var prevStd = windowStd(0, winWidth);
for (
var i = 1; i < values.length - winWidth - 3; i++) {
var w0 = windowStd(i + 0, winWidth);
var w1 = windowStd(i + 1, winWidth);
var w2 = windowStd(i + 2, winWidth);
// var currWindow = values.slice(i, i + winWidth);
if (w0 >= prevStd && !(w1 < w0 && w2 < w1)) {
if (i > stableFrom) {
stableFrom = i;
}
break;
}
prevStd = w0;
}
}
function withinPercentage(base, value, percentage) {
return Math.abs(base - value) < (base * percentage) / 100;
}
// Now go backwards as long as stddev decreases or doesn't increase in more than 1%.
var baseStd = d.stddev(values.slice(stableFrom), overallAverage);
var len = values.length;
while (
true) {
var current = d.stddev(values.slice(stableFrom - 1), overallAverage);
// 100/len : the more items we have, the more sensitively we compare:
// for 100 items, we're allowing 2% over baseStd.
if (
stableFrom > 0 &&
(current < baseStd ||
withinPercentage(baseStd, current, 200 / (len ? len : 100)))
) {
stableFrom--;
}
else {
break;
}
}
return stableFrom;
},
statsDisplay(collection) {
var d = window.talosDebug;
var std = d.stddev(collection, d.average(collection));
var avg = d.average(collection);
var med = d.median(collection);
return (
"Count: " +
collection.length +
"\nAverage: " +
avg.toFixed(d.fixed) +
"\nMedian: " +
med.toFixed(d.fixed) +
"\nStdDev: " +
std.toFixed(d.fixed) +
" (" +
((100 * std) / (avg ? avg : 1)).toFixed(d.fixed) +
"% of average)"
);
},
tpRecordTime(dataCSV) {
var d = window.talosDebug;
if (d.disabled) {
return;
}
var collection = (
"" + dataCSV).split(
",").map(
function (item) {
return parseFloat(item);
});
var res = d.statsDisplay(collection);
var warmup = d.ignore >= 0 ? d.ignore : d.detectWarmup(collection);
if (warmup >= 0) {
res +=
"\n\nWarmup " +
(d.ignore >= 0 ?
"requested: " :
"auto-detected: ") +
warmup;
var warmedUp = collection.slice(warmup);
if (warmup) {
res +=
"\nAfter ignoring first " +
(warmup > 1 ? warmup +
" items" :
"item") +
":\n";
res += d.statsDisplay(warmedUp);
}
}
else {
res +=
"\n\nWarmup auto-detection: Failed.";
}
if (d.displayData) {
var disp = collection.map(
function (item) {
return item.toFixed(d.fixed);
});
if (warmup >= 0) {
disp.splice(warmup, 0,
"[warmed-up:]");
}
res +=
"\n\nRecorded:\n" + disp.join(
", ");
res +=
"\n\nStddev from item NN to last:\n";
disp = collection.map(
function (value, index) {
return d
.stddev(collection.slice(index), d.average(collection.slice(index)))
.toFixed(d.fixed);
});
if (warmup >= 0) {
disp.splice(warmup, 0,
"[warmed-up:]");
}
res += disp.join(
", ");
}
else {
res +=
"\n\n[set window.talosDebug.displayData=true for data]";
}
alert(res);
},
};
// Enable testing outside of talos by providing an alternative report function.
if (
typeof tpRecordTime ===
"undefined") {
tpRecordTime = window.talosDebug.tpRecordTime;
}
