Add markers for each frame interval while rendering statistics and scale the graph

sky/compositor/instrumentation.cc

@@ -13,6 +13,7 @@ namespace compositor {
 namespace instrumentation {
 
 static const size_t kMaxSamples = 120;
+static const double kOneFrameMS = 1e3 / 60.0;
 
 Stopwatch::Stopwatch() : _start(base::TimeTicks::Now()), _current_sample(0) {
   const base::TimeDelta delta;
@@ -41,6 +42,16 @@ static inline constexpr double UnitFrameInterval(double frameTimeMS) {
   return frameTimeMS * 60.0 * 1e-3;
 }
 
+base::TimeDelta Stopwatch::maxDelta() const {
+  base::TimeDelta maxDelta;
+  for (size_t i = 0; i < kMaxSamples; i++) {
+    if (_laps[i] > maxDelta) {
+      maxDelta = _laps[i];
+    }
+  }
+  return maxDelta;
+}
+
 void Stopwatch::visualize(SkCanvas& canvas, const SkRect& rect) const {
   SkPaint paint;
 
@@ -50,18 +61,30 @@ void Stopwatch::visualize(SkCanvas& canvas, const SkRect& rect) const {
 
   // Paint the graph
   SkPath path;
-  auto width = rect.width();
-  auto height = rect.height();
+  const SkScalar width = rect.width();
+  const SkScalar height = rect.height();
+
+  // Find the max delta. We use this to scale the graph
 
-  auto unitHeight =
-      std::min(1.0, UnitFrameInterval(_laps[0].InMillisecondsF()));
+  double maxInterval = maxDelta().InMillisecondsF();
+
+  if (maxInterval < kOneFrameMS) {
+    maxInterval = kOneFrameMS;
+  }
+
+  const double maxUnitInterval = UnitFrameInterval(maxInterval);
+
+  // Draw the path
+  double unitHeight =
+      UnitFrameInterval(_laps[0].InMillisecondsF()) / maxUnitInterval;
 
   path.moveTo(0, height);
   path.lineTo(0, height * (1.0 - unitHeight));
 
   for (size_t i = 0; i < kMaxSamples; i++) {
     double unitWidth = (static_cast<double>(i + 1) / kMaxSamples);
-    unitHeight = std::min(1.0, UnitFrameInterval(_laps[i].InMillisecondsF()));
+    unitHeight =
+        UnitFrameInterval(_laps[i].InMillisecondsF()) / maxUnitInterval;
     path.lineTo(width * unitWidth, height * (1.0 - unitHeight));
   }
 
@@ -72,7 +95,22 @@ void Stopwatch::visualize(SkCanvas& canvas, const SkRect& rect) const {
   paint.setColor(0xAA0000FF);
   canvas.drawPath(path, paint);
 
-  // Paint the marker
+  paint.setStrokeWidth(1);
+  paint.setStyle(SkPaint::Style::kStroke_Style);
+  paint.setColor(SK_ColorWHITE);
+
+  if (maxInterval > kOneFrameMS) {
+    // Paint the horizontal markers
+    for (size_t frameIndex = 1; (frameIndex * kOneFrameMS) < maxInterval;
+         frameIndex++) {
+      const double frameHeight =
+          height * (1.0 - (UnitFrameInterval(frameIndex * kOneFrameMS) /
+                           maxUnitInterval));
+      canvas.drawLine(0, frameHeight, width, frameHeight, paint);
+    }
+  }
+
+  // Paint the vertical marker
   if (UnitFrameInterval(lastLap().InMillisecondsF()) > 1.0) {
     // budget exceeded
     paint.setColor(SK_ColorRED);
@@ -81,9 +119,8 @@ void Stopwatch::visualize(SkCanvas& canvas, const SkRect& rect) const {
     paint.setColor(SK_ColorGREEN);
   }
 
+  double sampleX = width * (static_cast<double>(_current_sample) / kMaxSamples);
   paint.setStrokeWidth(3);
-  paint.setStyle(SkPaint::Style::kStroke_Style);
-  auto sampleX = width * (static_cast<double>(_current_sample) / kMaxSamples);
   canvas.drawLine(sampleX, 0, sampleX, height, paint);
 }
 

sky/compositor/instrumentation.h

@@ -50,6 +50,8 @@ class Stopwatch {
   std::vector<base::TimeDelta> _laps;
   size_t _current_sample;
 
+  base::TimeDelta maxDelta() const;
+
   DISALLOW_COPY_AND_ASSIGN(Stopwatch);
 };