ci: add count to benchmark and pass index to fn

hansl · hansl · commit ae9695a1b7ea · 2018-10-03T16:31:27.000-07:00
diff --git a/packages/_/benchmark/src/benchmark.ts b/packages/_/benchmark/src/benchmark.ts
@@ -15,11 +15,11 @@ declare const global: {
 const kNanosecondsPerSeconds = 1e9;
 const kBenchmarkIterationMaxCount = 10000;
 const kBenchmarkTimeoutInMsec = 5000;
-const kWarmupIterationCount = 10;
+const kWarmupIterationCount = 100;
 const kTopMetricCount = 5;
 
 
-function _run(fn: () => void, collector: number[]) {
+function _run(fn: (i: number) => void, collector: number[]) {
   const timeout = Date.now();
   // Gather the first 5 seconds runs, or kMaxNumberOfIterations runs whichever comes first
   // (soft timeout).
@@ -28,7 +28,7 @@ function _run(fn: () => void, collector: number[]) {
        i++) {
     // Start time.
     const start = process.hrtime();
-    fn();
+    fn(i);
     // Get the stop difference time.
     const diff = process.hrtime(start);
 
@@ -41,13 +41,15 @@ function _run(fn: () => void, collector: number[]) {
 function _stats(metrics: number[]) {
   metrics.sort((a, b) => a - b);
 
-  const middle = metrics.length / 2;
+  const count = metrics.length;
+  const middle = count / 2;
   const mean = Number.isInteger(middle)
     ? metrics[middle] : ((metrics[middle - 0.5] + metrics[middle + 0.5]) / 2);
   const total = metrics.reduce((acc, curr) => acc + curr, 0);
-  const average = total / metrics.length;
+  const average = total / count;
 
   return {
+    count: count,
     fastest: metrics.slice(0, kTopMetricCount),
     slowest: metrics.reverse().slice(0, kTopMetricCount),
     mean,
@@ -56,12 +58,12 @@ function _stats(metrics: number[]) {
 }
 
 
-export function benchmark(name: string, fn: () => void, base?: () => void) {
+export function benchmark(name: string, fn: (i: number) => void, base?: (i: number) => void) {
   it(name + ' (time in nanoseconds)', (done) => {
     process.nextTick(() => {
       for (let i = 0; i < kWarmupIterationCount; i++) {
         // Warm it up.
-        fn();
+        fn(i);
       }
 
       const reporter = global.benchmarkReporter;
diff --git a/scripts/benchmark.ts b/scripts/benchmark.ts
@@ -27,6 +27,7 @@ declare const global: {
 
 
 interface BenchmarkResult {
+  count: number;
   slowest: number[];
   fastest: number[];
   mean: number;
@@ -71,12 +72,17 @@ class BenchmarkReporter extends JasmineSpecReporter implements jasmine.CustomRep
         return p.substr(0, p.length - ('' + s).length) + s;
       }
 
+      const count = pad(stat.count);
       const fastest = stat.fastest.map(x => pad(x)).join('');
       const slowest = stat.slowest.map(x => pad(x)).join('');
       const mean = pad(Math.floor(stat.mean));
       const average = pad(Math.floor(stat.average));
       if (stat.base) {
-        const precision = (x: number) => ('' + Math.floor(x * 100)).replace(/(\d\d)$/, '.$1');
+        const precision = (x: number) => {
+          x = Math.floor(x * 100);
+
+          return `${Math.floor(x / 100)}.${Math.floor(x / 10) % 10}${x % 10}`;
+        };
         const multPad = '      ';
         const baseFastest = stat.base.fastest.map(x => pad(x)).join('');
         const baseSlowest = stat.base.slowest.map(x => pad(x)).join('');
@@ -86,6 +92,7 @@ class BenchmarkReporter extends JasmineSpecReporter implements jasmine.CustomRep
         const baseAverageMult = pad(precision(stat.average / stat.base.average), multPad);
 
         console.log(terminal.colors.yellow(tags.indentBy(6)`
+          count:   ${count}
           fastest: ${fastest}
             (base) ${baseFastest}
           slowest: ${slowest}
@@ -95,6 +102,7 @@ class BenchmarkReporter extends JasmineSpecReporter implements jasmine.CustomRep
         `));
       } else {
         console.log(terminal.colors.yellow(tags.indentBy(6)`
+          count:   ${count}
           fastest: ${fastest}
           slowest: ${slowest}
           mean:    ${mean}
@@ -120,12 +128,6 @@ global.benchmarkReporter = new BenchmarkReporter();
 runner.env.addReporter(global.benchmarkReporter);
 
 
-// Manually set exit code (needed with custom reporters)
-runner.onComplete((success: boolean) => {
-  process.exitCode = success ? 0 : 1;
-});
-
-
 // Run the tests.
 const allTests =
   glob.sync('packages/**/*_benchmark.ts')
@@ -134,5 +136,8 @@ const allTests =
 
 
 export default function(_args: {}) {
-  runner.execute(allTests);
+  return new Promise(resolve => {
+    runner.onComplete((passed: boolean) => resolve(passed ? 0 : 1));
+    runner.execute(allTests);
+  });
 }
