exo: Improve benchmark support in motion event client.

components/exo/wayland/clients/motion_events.cc

 // Copyright 2016 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.
 
 // Implementation of a client that produces output in the form of RGBA
 // buffers when receiving pointer/touch events. RGB contains the lower
 // 24 bits of the event timestamp and A is 0xff.
 
 #include <fcntl.h>
 #include <linux-dmabuf-unstable-v1-client-protocol.h>
@@ skipping 87 matching lines @@
 // DRI render node path template.
 const char kDriRenderNodeTemplate[] = "/dev/dri/renderD%u";
 #endif
 
 // Number of buffers.
 const size_t kBuffers = 8;
 
 // Rotation speed (degrees/second).
 const double kRotationSpeed = 360.0;
 
-// Benchmark interval in seconds.
-const int kBenchmarkInterval = 5;
+// Benchmark warmup frames before starting measurement.
+const int kBenchmarkWarmupFrames = 10;
 
 struct Globals {
   std::unique_ptr<wl_compositor> compositor;
   std::unique_ptr<wl_shm> shm;
   std::unique_ptr<zwp_linux_dmabuf_v1> linux_dmabuf;
   std::unique_ptr<wl_shell> shell;
   std::unique_ptr<wl_seat> seat;
 };
 
 void RegistryHandler(void* data,
@@ skipping 178 matching lines @@
 
 class MotionEvents {
  public:
   MotionEvents(size_t width,
                size_t height,
                int scale,
                size_t num_rects,
                size_t max_frames_pending,
                bool fullscreen,
                bool show_fps_counter,
+               size_t num_benchmark_runs,
+               base::TimeDelta benchmark_interval,
                const std::string* use_drm)
       : width_(width),
         height_(height),
         scale_(scale),
         num_rects_(num_rects),
         max_frames_pending_(max_frames_pending),
         fullscreen_(fullscreen),
         show_fps_counter_(show_fps_counter),
+        num_benchmark_runs_(num_benchmark_runs),
+        benchmark_interval_(benchmark_interval),
         use_drm_(use_drm) {}
 
   // Initialize and run client main loop.
   int Run();
 
  private:
   bool CreateBuffer(Buffer* buffer);
 
   const size_t width_;
   const size_t height_;
   const int scale_;
   const size_t num_rects_;
   const size_t max_frames_pending_;
   const bool fullscreen_;
   const bool show_fps_counter_;
+  const size_t num_benchmark_runs_;
+  const base::TimeDelta benchmark_interval_;
   const std::string* use_drm_;
 
   Globals globals_;
   std::unique_ptr<wl_display> display_;
 
 #if defined(OZONE_PLATFORM_GBM)
   base::ScopedFD drm_fd_;
   std::unique_ptr<gbm_device> device_;
 #endif
 
@@ skipping 182 matching lines @@
   wl_touch_listener touch_listener = {TouchDown, TouchUp, TouchMotion,
                                       TouchFrame, TouchCancel};
   wl_touch_add_listener(touch.get(), &touch_listener, &event_times);
 
   Frame frame;
   std::unique_ptr<wl_callback> frame_callback;
   wl_callback_listener frame_listener = {FrameCallback};
   std::deque<wl_buffer*> pending_frames;
 
   uint32_t frames = 0;
-  base::TimeTicks benchmark_time = base::TimeTicks::Now();
-  base::TimeDelta benchmark_interval =
-      base::TimeDelta::FromSeconds(kBenchmarkInterval);
+  size_t num_benchmark_runs_left = num_benchmark_runs_;
+  base::TimeTicks benchmark_time;
   base::TimeDelta benchmark_wall_time;
   base::TimeDelta benchmark_cpu_time;
   std::string fps_counter_text("??");
 
   SkPaint text_paint;
   text_paint.setTextSize(32.0f);
   text_paint.setColor(SK_ColorWHITE);
   text_paint.setStyle(SkPaint::kFill_Style);
 
   int dispatch_status = 0;
   do {
     bool enqueue_frame = frame.callback_pending
                              ? pending_frames.size() < max_frames_pending_
                              : pending_frames.empty();
     if (enqueue_frame) {
       Buffer* buffer =
           std::find_if(std::begin(buffers_), std::end(buffers_),
                        [](const Buffer& buffer) { return !buffer.busy; });
       if (buffer == std::end(buffers_)) {
         LOG(ERROR) << "Can't find free buffer";
         return 1;
       }
 
-      base::TimeTicks wall_time_start = base::TimeTicks::Now();
-      if ((wall_time_start - benchmark_time) > benchmark_interval) {
-        // Print benchmark statistics for the frames produced.
-        // Note: frames produced is not necessarily the same as frames
-        // displayed.
-        std::cout << frames << " frames in " << benchmark_interval.InSeconds()
-                  << " seconds: " << frames / benchmark_interval.InSecondsF()
-                  << " fps (wall="
-                  << benchmark_wall_time.InMillisecondsF() / frames
-                  << " cpu=" << benchmark_cpu_time.InMillisecondsF() / frames
-                  << ")" << std::endl;
+      base::TimeTicks wall_time_start;
+      base::ThreadTicks cpu_time_start;
+      if (num_benchmark_runs_ || show_fps_counter_) {
+        wall_time_start = base::TimeTicks::Now();
+        if (frames <= kBenchmarkWarmupFrames)
+          benchmark_time = wall_time_start;
 
-        // Set FPS counter text in case it's being shown.
-        fps_counter_text = base::UintToString(
-            std::round(frames / benchmark_interval.InSecondsF()));
+        if ((wall_time_start - benchmark_time) > benchmark_interval_) {
+          uint32_t benchmark_frames = frames - kBenchmarkWarmupFrames;
+          if (num_benchmark_runs_left) {
+            // Print benchmark statistics for the frames produced and exit.
+            // Note: frames produced is not necessarily the same as frames
+            // displayed.
+            std::cout << benchmark_frames << '\t'
+                      << benchmark_wall_time.InMilliseconds() << '\t'
+                      << benchmark_cpu_time.InMilliseconds() << '\t'
+                      << std::endl;
+            if (!--num_benchmark_runs_left)
+              return 0;
+          }
 
-        frames = 0;
-        benchmark_time = wall_time_start;
-        benchmark_wall_time = base::TimeDelta();
-        benchmark_cpu_time = base::TimeDelta();
+          // Set FPS counter text in case it's being shown.
+          fps_counter_text = base::UintToString(
+              std::round(benchmark_frames / benchmark_interval_.InSecondsF()));
+
+          frames = kBenchmarkWarmupFrames;
+          benchmark_time = wall_time_start;
+          benchmark_wall_time = base::TimeDelta();
+          benchmark_cpu_time = base::TimeDelta();
+        }
+
+        cpu_time_start = base::ThreadTicks::Now();
       }
 
-      base::ThreadTicks cpu_time_start = base::ThreadTicks::Now();
-
       SkCanvas* canvas = buffer->sk_surface->getCanvas();
       if (event_times.empty()) {
         canvas->clear(SK_ColorBLACK);
       } else {
         // Split buffer into one horizontal rectangle for each event received
         // since last frame. Latest event at the top.
         int y = 0;
         // Note: Rounding up to ensure we cover the whole canvas.
         int h = (height_ + (event_times.size() / 2)) / event_times.size();
         while (!event_times.empty()) {
@@ skipping 47 matching lines @@
           eglClientWaitSyncKHR(eglGetCurrentDisplay(), sync,
                                EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
                                EGL_FOREVER_KHR);
           eglDestroySyncKHR(eglGetCurrentDisplay(), sync);
         }
       }
 
       buffer->busy = true;
       pending_frames.push_back(buffer->buffer.get());
 
-      ++frames;
-      benchmark_wall_time += base::TimeTicks::Now() - wall_time_start;
-      benchmark_cpu_time += base::ThreadTicks::Now() - cpu_time_start;
+      if (num_benchmark_runs_ || show_fps_counter_) {
+        ++frames;
+        benchmark_wall_time += base::TimeTicks::Now() - wall_time_start;
+        benchmark_cpu_time += base::ThreadTicks::Now() - cpu_time_start;
+      }
       continue;
     }
 
     if (!frame.callback_pending) {
       DCHECK_GT(pending_frames.size(), 0u);
       wl_surface_set_buffer_scale(surface.get(), scale_);
       wl_surface_attach(surface.get(), pending_frames.front(), 0, 0);
       pending_frames.pop_front();
 
       frame_callback.reset(wl_surface_frame(surface.get()));
@@ skipping 114 matching lines @@
 
 // Specifies the maximum number of pending frames.
 const char kMaxFramesPending[] = "max-frames-pending";
 
 // Specifies if client should be fullscreen.
 const char kFullscreen[] = "fullscreen";
 
 // Specifies if FPS counter should be shown.
 const char kShowFpsCounter[] = "show-fps-counter";
 
+// Enables benchmark mode and specifies the number of benchmark runs to
+// perform before client will exit. Client will print the results to
+// standard output as a tab seperated list.
+//
+//  The output format is:
+//   "frames wall-time-ms cpu-time-ms"
+const char kBenchmark[] = "benchmark";
+
+// Specifies the number of milliseconds to use as benchmark interval.
+const char kBenchmarkInterval[] = "benchmark-interval";
+
 // Use drm buffer instead of shared memory.
 const char kUseDrm[] = "use-drm";
 
 }  // namespace switches
 
 int main(int argc, char* argv[]) {
   base::AtExitManager exit_manager;
   base::CommandLine::Init(argc, argv);
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
@@ skipping 25 matching lines @@
 
   size_t max_frames_pending = 0;
   if (command_line->HasSwitch(switches::kMaxFramesPending) &&
       (!base::StringToSizeT(
           command_line->GetSwitchValueASCII(switches::kMaxFramesPending),
           &max_frames_pending))) {
     LOG(ERROR) << "Invalid value for " << switches::kMaxFramesPending;
     return 1;
   }
 
+  size_t num_benchmark_runs = 0;
+  if (command_line->HasSwitch(switches::kBenchmark) &&
+      (!base::StringToSizeT(
+          command_line->GetSwitchValueASCII(switches::kBenchmark),
+          &num_benchmark_runs))) {
+    LOG(ERROR) << "Invalid value for " << switches::kBenchmark;
+    return 1;
+  }
+
+  size_t benchmark_interval_ms = 5000;  // 5 seconds.
+  if (command_line->HasSwitch(switches::kBenchmarkInterval) &&
+      (!base::StringToSizeT(
+          command_line->GetSwitchValueASCII(switches::kBenchmark),
+          &benchmark_interval_ms))) {
+    LOG(ERROR) << "Invalid value for " << switches::kBenchmark;
+    return 1;
+  }
+
   std::unique_ptr<std::string> use_drm;
   if (command_line->HasSwitch(switches::kUseDrm)) {
     use_drm.reset(
         new std::string(command_line->GetSwitchValueASCII(switches::kUseDrm)));
   }
 
   exo::wayland::clients::MotionEvents client(
       width, height, scale, num_rects, max_frames_pending,
       command_line->HasSwitch(switches::kFullscreen),
-      command_line->HasSwitch(switches::kShowFpsCounter), use_drm.get());
+      command_line->HasSwitch(switches::kShowFpsCounter), num_benchmark_runs,
+      base::TimeDelta::FromMilliseconds(benchmark_interval_ms), use_drm.get());
   return client.Run();
 }