Add new Splay benchmark to the V8 benchmark suite and remove...

benchmarks/base.js

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 // Simple framework for running the benchmark suites and
 // computing a score based on the timing measurements.
 
 
 // A benchmark has a name (string) and a function that will be run to
-// do the performance measurement.
-function Benchmark(name, run) {
+// do the performance measurement. The optional setup and tearDown
+// arguments are functions that will be invoked before and after
+// running the benchmark, but the running time of these functions will
+// not be accounted for in the benchmark score.
+function Benchmark(name, run, setup, tearDown) {
   this.name = name;
   this.run = run;
+  this.Setup = setup ? setup : function() { };
+  this.TearDown = tearDown ? tearDown : function() { };
 }
 
 
 // Benchmark results hold the benchmark and the measured time used to
 // run the benchmark. The benchmark score is computed later once a
 // full benchmark suite has run to completion.
 function BenchmarkResult(benchmark, time) {
   this.benchmark = benchmark;
   this.time = time;
 }
@@ skipping 18 matching lines @@
 }
 
 
 // Keep track of all declared benchmark suites.
 BenchmarkSuite.suites = [];
 
 
 // Scores are not comparable across versions. Bump the version if
 // you're making changes that will affect that scores, e.g. if you add
 // a new benchmark or change an existing one.
-BenchmarkSuite.version = '3';
+BenchmarkSuite.version = '4';
 
 
 // To make the benchmark results predictable, we replace Math.random
 // with a 100% deterministic alternative.
 Math.random = (function() {
   var seed = 49734321;
   return function() {
     // Robert Jenkins' 32 bit integer hash function.
     seed = ((seed + 0x7ed55d16) + (seed << 12))  & 0xffffffff;
     seed = ((seed ^ 0xc761c23c) ^ (seed >>> 19)) & 0xffffffff;
@@ skipping 20 matching lines @@
   function RunStep() {
     while (continuation || index < length) {
       if (continuation) {
         continuation = continuation();
       } else {
         var suite = suites[index++];
         if (runner.NotifyStart) runner.NotifyStart(suite.name);
         continuation = suite.RunStep(runner);
       }
       if (continuation && typeof window != 'undefined' && window.setTimeout) {
-        window.setTimeout(RunStep, 100);
+        window.setTimeout(RunStep, 25);
         return;
       }
     }
     if (runner.NotifyScore) {
       var score = BenchmarkSuite.GeometricMean(BenchmarkSuite.scores);
       var formatted = BenchmarkSuite.FormatScore(100 * score);
       runner.NotifyScore(formatted);
     }
   }
   RunStep();
@@ skipping 59 matching lines @@
     this.runner.NotifyError(this.name, error);
   }
   if (this.runner.NotifyStep) {
     this.runner.NotifyStep(this.name);
   }
 }
 
 
 // Runs a single benchmark for at least a second and computes the
 // average time it takes to run a single iteration.
-BenchmarkSuite.prototype.RunSingle = function(benchmark) {
+BenchmarkSuite.prototype.RunSingleBenchmark = function(benchmark) {
   var elapsed = 0;
   var start = new Date();
   for (var n = 0; elapsed < 1000; n++) {
     benchmark.run();
     elapsed = new Date() - start;
   }
   var usec = (elapsed * 1000) / n;
   this.NotifyStep(new BenchmarkResult(benchmark, usec));
 }
 
 
 // This function starts running a suite, but stops between each
 // individual benchmark in the suite and returns a continuation
 // function which can be invoked to run the next benchmark. Once the
 // last benchmark has been executed, null is returned.
 BenchmarkSuite.prototype.RunStep = function(runner) {
   this.results = [];
   this.runner = runner;
   var length = this.benchmarks.length;
   var index = 0;
   var suite = this;
-  function RunNext() {
+
+  // Run the setup, the actual benchmark, and the tear down in three
+  // separate steps to allow the framework to yield between any of the
+  // steps.
+
+  function RunNextSetup() {
     if (index < length) {
       try {
-        suite.RunSingle(suite.benchmarks[index++]);
+        suite.benchmarks[index].Setup();
       } catch (e) {
         suite.NotifyError(e);
         return null;
       }
-      return RunNext;
+      return RunNextBenchmark;
     }
     suite.NotifyResult();
     return null;
   }
-  return RunNext();
+
+  function RunNextBenchmark() {
+    try {
+      suite.RunSingleBenchmark(suite.benchmarks[index]);
+    } catch (e) {
+      suite.NotifyError(e);
+      return null;
+    }
+    return RunNextTearDown;
+  }
+
+  function RunNextTearDown() {
+    try {
+      suite.benchmarks[index++].TearDown();
+    } catch (e) {
+      suite.NotifyError(e);
+      return null;
+    }
+    return RunNextSetup;
+  }
+
+  // Start out running the setup.
+  return RunNextSetup();
 }