Upgrade V8 Benchmark from v4 to v6.

chrome/test/data/v8_benchmark/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 60 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 = '4';
+BenchmarkSuite.version = '6';
 
 
 // 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;
     seed = ((seed + 0x165667b1) + (seed << 5))   & 0xffffffff;
     seed = ((seed + 0xd3a2646c) ^ (seed << 9))   & 0xffffffff;
-    seed = ((seed + 0xd3a2646c) ^ (seed << 9))   & 0xffffffff;
     seed = ((seed + 0xfd7046c5) + (seed << 3))   & 0xffffffff;
     seed = ((seed ^ 0xb55a4f09) ^ (seed >>> 16)) & 0xffffffff;
     return (seed & 0xfffffff) / 0x10000000;
   };
 })();
 
 
 // Runs all registered benchmark suites and optionally yields between
 // each individual benchmark to avoid running for too long in the
 // context of browsers. Once done, the final score is reported to the
@@ skipping 87 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.RunSingleBenchmark = function(benchmark) {
-  var elapsed = 0;
-  var start = new Date();
-  for (var n = 0; elapsed < 1000; n++) {
-    benchmark.run();
-    elapsed = new Date() - start;
+BenchmarkSuite.prototype.RunSingleBenchmark = function(benchmark, data) {
+  function Measure(data) {
+    var elapsed = 0;
+    var start = new Date();
+    for (var n = 0; elapsed < 1000; n++) {
+      benchmark.run();
+      elapsed = new Date() - start;
+    }
+    if (data != null) {
+      data.runs += n;
+      data.elapsed += elapsed;
+    }
   }
-  var usec = (elapsed * 1000) / n;
-  this.NotifyStep(new BenchmarkResult(benchmark, usec));
+
+  if (data == null) {
+    // Measure the benchmark once for warm up and throw the result
+    // away. Return a fresh data object.
+    Measure(null);
+    return { runs: 0, elapsed: 0 };
+  } else {
+    Measure(data);
+    // If we've run too few iterations, we continue for another second.
+    if (data.runs < 32) return data;
+    var usec = (data.elapsed * 1000) / data.runs;
+    this.NotifyStep(new BenchmarkResult(benchmark, usec));
+    return null;
+  }
 }
 
 
 // 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;
+  var data;
 
   // 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.benchmarks[index].Setup();
       } catch (e) {
         suite.NotifyError(e);
         return null;
       }
       return RunNextBenchmark;
     }
     suite.NotifyResult();
     return null;
   }
 
   function RunNextBenchmark() {
     try {
-      suite.RunSingleBenchmark(suite.benchmarks[index]);
+      data = suite.RunSingleBenchmark(suite.benchmarks[index], data);
     } catch (e) {
       suite.NotifyError(e);
       return null;
     }
-    return RunNextTearDown;
+    // If data is null, we're done with this benchmark.
+    return (data == null) ? RunNextTearDown : RunNextBenchmark();
   }
 
   function RunNextTearDown() {
     try {
       suite.benchmarks[index++].TearDown();
     } catch (e) {
       suite.NotifyError(e);
       return null;
     }
     return RunNextSetup;
   }
 
   // Start out running the setup.
   return RunNextSetup();
 }