Use only the steady gesture in frame rate tests.

chrome/test/data/perf/frame_rate/head.js

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview  Perform various "gestures" and calculate average frame rate.
  * "Gestures" are recorded scrolling behaviors in terms of time (ms) and
  * absolute positions.
  *
  * How to run a single gesture:
@@ skipping 23 matching lines @@
  *      ],
  */
 
 var __initialized = true;
 var __running = false;
 var __running_all = false;
 var __old_title = "";
 var __raf_is_live = false;
 var __raf;
 
+var __t_start;
 var __t_last;
 var __t_est;
-var __t_est_total;
-var __t_est_squared_total;
-var __t_count;
-var __t_start;
+var __t_deltas;
 
 var __queued_gesture_functions;
 var __results;
 
 var __recording = [];
 var __advance_gesture;
 
 // This flag indicates whether the test page contains an animation loop
 // For more on testing animated pages, see head_animation.js
 var __animation = false;
 
 var __gesture_library = {
   init: [
     {"time_ms":1, "y":0},
     {"time_ms":5, "y":10}
   ],
   stationary: [
     {"time_ms":1, "y":0},
     {"time_ms":5000, "y":0}
   ],
+  steady: [
+    {"time_ms":1, "y":0},
+    {"time_ms":500, "y":400}
+  ],
   reading: [
     {"time_ms":1, "y":0},
     {"time_ms":842, "y":40},
     {"time_ms":858, "y":67},
     {"time_ms":874, "y":94},
     {"time_ms":890, "y":149},
     {"time_ms":907, "y":203},
     {"time_ms":923, "y":257},
     {"time_ms":939, "y":311},
     {"time_ms":955, "y":393},
@@ skipping 93 matching lines @@
   var new_gesture = JSON.parse(JSON.stringify(gesture));
   for (var i = 0; i < new_gesture.length; ++i) {
     new_gesture[i].time_ms *= stretch_factor;
   }
   return new_gesture;
 }
 
 // Gesture set to use for testing, initialized with default gesture set.
 // Redefine in test file to use a different set of gestures.
 var __gestures = {
-  none: __gesture_library["stationary"],
-  steady: __gesture_library["init"],
-  reading: __gesture_library["reading"],
-  mouse_wheel: __gesture_library["mouse_wheel"],
-  mac_fling: __gesture_library["mac_fling"],
+  steady: __gesture_library["steady"],
 };
 
 function __init_stats() {
   __t_last = undefined;
   __t_est = undefined;
-  __t_est_total = 0;
-  __t_est_squared_total = 0;
-  __t_count = 0;
+  __t_deltas = [];
 }
 __init_stats();
 
+var __cur_chrome_interval;
+function __init_time() {
+  if (chrome.Interval) {
+    __cur_chrome_interval = new chrome.Interval();
+    __cur_chrome_interval.start();
+  }
+}
+__init_time();
+
+function __get_time() {
+  if (__cur_chrome_interval)
+    return __cur_chrome_interval.microseconds() / 1000;
+  return new Date().getTime();
+}
+
 function __init_raf() {
   if ("requestAnimationFrame" in window)
     __raf = requestAnimationFrame;
   else if ("webkitRequestAnimationFrame" in window)
     __raf = webkitRequestAnimationFrame;
   else if ("mozRequestAnimationFrame" in window)
     __raf = mozRequestAnimationFrame;
   else if ("oRequestAnimationFrame" in window)
     __raf = oRequestAnimationFrame;
   else if ("msRequestAnimationFrame" in window)
     __raf = msRequestAnimationFrame;
   else
     // No raf implementation available, fake it with 16ms timeouts
     __raf = function(callback, element) {
       setTimeout(callback, 16);
-    }
+    };
 }
 __init_raf();
 
 function __calc_results() {
-  var M = __t_est_total / __t_count;
-  var X = __t_est_squared_total / __t_count;
-  var V = X - M * M;
-  var S = Math.sqrt(V);
+  var M = 0.0;
+  var N = __t_deltas.length;
 
+  for (var i = 0; i < N; i++)
+    M += __t_deltas[i];
+  M = M / N;
+
+  var V = 0.0;
+  for (var i = 0; i < N; i++) {
+    var v = __t_deltas[i] - M;
+    V += v * v;
+  }
+
+  var S = Math.sqrt(V / (N - 1));

[jbates, 2011/11/11 23:43:46]

(N - 1) should be N?

[Justin Novosad, 2011/11/14 16:08:42]

Actually N-1 is correct for calculating unbiased sample variance. The unbiased
estimator is always preferable when N is variable.

+
+  // Report frame rate in terms of frames-per-second. However,
+  // report error as an interval. Reporting it as 1/sigma amplifies
+  // the noise and makes it seem higher than it actually is.
+  // TODO(nduca): switch to a smarter measure of noise, possibly something
+  // based on histogram-spikes or percentiles.

[Justin Novosad, 2011/11/14 16:08:42]

I think the right way to do it would be to compute the variance in terms of fps.
To get sigma in fps, you would need to change line 239 to:
var v = 1000.0/__t_deltas[i] - 1000.0/M;
This the result of this is _not_ equivalent to 1/interval_sigma

   var R = new Object();
   R.mean = 1000.0 / M;
-  R.sigma = R.mean - 1000.0 / (M + S);
+  R.sigma = S;
   return R;
 }
 
 function __calc_results_total() {
   if (!__results) {
-    return;
+    return {};
   }
   var size = __results.gestures.length;
   var mean = 0;
   var variance = 0;
-  var sigma;
 
   // Remove any intial caching test(s).
   while (__results.means.length != size) {
     __results.means.shift();
     __results.sigmas.shift();
   }
   for (var i = 0; i < size; i++) {
     mean += __results.means[i];
     variance += __results.sigmas[i] * __results.sigmas[i];
   }
   mean /= size;
   variance /= size;
-  sigma = Math.sqrt(variance);
+  var sigma = Math.sqrt(variance);
 
   var results = new Object();
   // GTest expects a comma-separated string for lists.
   results.gestures = __results.gestures.join(",");
   results.means = __results.means.join(",");
   results.sigmas = __results.sigmas.join(",");
   results.mean = mean;
   results.sigma = sigma;
   return results;
 }
 
 function __update_fps() {
-  var t_now = new Date().getTime();
+  var t_now = __get_time();
   if (window.__t_last) {
     var t_delta = t_now - __t_last;
     if (window.__t_est) {
       __t_est = (0.1 * __t_est) + (0.9 * t_delta);  // low-pass filter
     } else {
       __t_est = t_delta;
     }
+
+    __t_deltas.push(t_delta);
+
     var fps = 1000.0 / __t_est;
     document.title = "FPS: " + (fps | 0);
-
-    __t_est_total += t_delta;
-    __t_est_squared_total += t_delta * t_delta;
-    __t_count++;
   }
   __t_last = t_now;
 }
 
 // Returns true if a recorded gesture movement occured.
 function __advance_gesture_recording() {
   var y = document.body.scrollTop;
   // Only add a gesture if the scroll position changes.
   if (__recording.length == 0 || y != __recording[__recording.length - 1].y) {
-    var time_ms = new Date().getTime() - __t_start;
+    var time_ms = __get_time() - __t_start;
     __recording.push({ time_ms: time_ms, y: y });
     return true;
   }
   return false;
 }
 
 function __scroll_window_to(y) {
   // Scrolls a window to a new location using window.scrollBy, but avoids
   // window.scrollTo because of potential animation that may cause. This tracks
   // the current scrollTop position to avoid forcing layout.
@@ skipping 15 matching lines @@
 }
 
 // Returns true if a gesture movement occured.
 function __create_gesture_function(gestures) {
   var i0 = 0;
   return function() {
     if (i0 >= gestures.length) {
       __stop();
       return false;
     }
-    var time_cur = new Date().getTime() - __t_start;
+    var time_cur = __get_time() - __t_start;
     if (time_cur <= gestures[i0].time_ms)
       return false;
 
     // Skip any keyframes that we missed
     for (i0; i0 < gestures.length && gestures[i0].time_ms < time_cur; ++i0);
 
     // This loop overshoots by 1, so move back in time by 1
     i0--;
     var i1 = i0 + 1;
 
@@ skipping 45 matching lines @@
     // In case __raf falls back to using setTimeout, we must schedule the next
     // update before rendering the current update to help maintain the
     // regularity of update intervals.
     __sched_update();
     if (__running) {
       // Only update the FPS if a gesture movement occurs. Otherwise, the frame
       // rate average becomes inaccurate after any pause.
       if (__advance_gesture())
         __update_fps();
       else
-        __t_last = new Date().getTime();
+        __t_last = __get_time();
     }
   }, document.body);
 }
 
 function __start_recording() {
   __start(__advance_gesture_recording);
 }
 
 function __make_body_composited() {
   document.body.style.webkitTransform = "translateZ(0)";
@@ skipping 13 matching lines @@
     }
     else
       gesture_function = __create_repeating_gesture_function(
                             __gestures[gesture_function]);
   }
   else if (typeof gesture_function != "function")
     throw new Error("Argument is not a function or gesture name");
 
   __old_title = document.title;
   __advance_gesture = gesture_function;
-  __t_start = new Date().getTime();
+  __t_start = __get_time();
   __running = true;
   if (!__raf_is_live && !__animation) {
     __sched_update();
   }
 }
 
 function __start_all() {
   __queued_gesture_functions = [];
   __results = {
     gestures: [],
@@ skipping 34 matching lines @@
   __running = false;
   __running_all = false;
   document.title = __old_title;
   document.body.scrollTop = 0;
   __init_stats();
 }
 
 function __force_compositor() {
   document.body.style.webkitTransform = "translateZ(0)";
 }