exo: Add FPS counter to 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 285 matching lines @@
 }  // namespace
 
 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,
                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),
         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 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 187 matching lines @@
   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);
   base::TimeDelta benchmark_wall_time;
   base::TimeDelta benchmark_cpu_time;
+  std::string fps_counter_text;

[Daniele Castagna, 2016/11/14 03:04:31]

Should it be initialized to something like "fps: N/A" in case show_fps_counter_
is true?

[reveman, 2016/11/14 15:00:49]

I'd like to have the ability to run this without drawing any text for benchmark
purposes.

[Daniele Castagna, 2016/11/14 15:17:03]

Sure, but what I was suggesting is to have the N/A string in case you want the
text (show_fps_counter_ is true), and it's the first benchmark period.

[reveman, 2016/11/14 16:52:35]

Done. But "??" as I want to keep text layout simple.

+
+  SkPaint text_paint;
+  text_paint.setTextSize(32.0f);
+  text_paint.setColor(SK_ColorWHITE);

[Daniele Castagna, 2016/11/14 03:04:32]

It'd be much more readable if it had a black border.

[reveman, 2016/11/14 15:00:49]

The background is typically black and that makes this easy to read. I'd also
like to keep this as simple as possible and I think this is good enough.

[Daniele Castagna, 2016/11/14 15:17:03]

Acknowledged.

+  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;
 
+        if (show_fps_counter_) {
+          fps_counter_text =
+              base::UintToString(frames / benchmark_interval.InSeconds());

[Daniele Castagna, 2016/11/14 03:04:32]

Why not a floating point here?
Should it also include something like "fps: " before the actual number?

[reveman, 2016/11/14 15:00:49]

Just printing 2 digits makes it easy from a layout perspective and I think just
the number is clean and good enough.

[Daniele Castagna, 2016/11/14 15:17:03]

Should you round the number instead of getting floor(fps) then?

[reveman, 2016/11/14 16:52:35]

Done.

+        }
+
         frames = 0;
         benchmark_time = wall_time_start;
         benchmark_wall_time = base::TimeDelta();
         benchmark_cpu_time = base::TimeDelta();
       }
 
       base::ThreadTicks cpu_time_start = base::ThreadTicks::Now();
 
       SkCanvas* canvas = buffer->sk_surface->getCanvas();
-      canvas->save();
-
       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()) {
           SkIRect rect = SkIRect::MakeXYWH(0, y, width_, h);
           SkPaint paint;
           paint.setColor(SkColorSetRGB((event_times.back() & 0x0000ff) >> 0,
                                        (event_times.back() & 0x00ff00) >> 8,
                                        (event_times.back() & 0xff0000) >> 16));
           canvas->drawIRect(rect, paint);
+          std::string text = base::UintToString(event_times.back());

[Daniele Castagna, 2016/11/14 03:04:32]

Should we have something like "event ts: " before the timestamp?

[reveman, 2016/11/14 15:00:49]

Like to keep this consistent with above and just print the number. The user
needs to look at the code to understand how what this time stamp is anyhow.

+          canvas->drawText(text.c_str(), text.length(), 8, y + 32, text_paint);
           event_times.pop_back();
           y += h;
         }
       }
 
       // Draw rotating rects.
       SkScalar half_width = SkScalarHalf(width_);
       SkScalar half_height = SkScalarHalf(height_);
       SkIRect rect = SkIRect::MakeXYWH(-SkScalarHalf(half_width),
                                        -SkScalarHalf(half_height), half_width,
                                        half_height);
       SkScalar rotation = SkScalarMulDiv(frame.time, kRotationSpeed, 1000);
-      SkPaint paint;
+      canvas->save();
       canvas->translate(half_width, half_height);
       for (size_t i = 0; i < num_rects_; ++i) {
         const SkColor kColors[] = {SK_ColorBLUE, SK_ColorGREEN,
                                    SK_ColorRED,  SK_ColorYELLOW,
                                    SK_ColorCYAN, SK_ColorMAGENTA};
+        SkPaint paint;
         paint.setColor(SkColorSetA(kColors[i % arraysize(kColors)], 0xA0));
         canvas->rotate(rotation / num_rects_);
         canvas->drawIRect(rect, paint);
       }
+      canvas->restore();
 
-      canvas->restore();
+      // Draw FPS counter.
+      if (fps_counter_text.length()) {
+        canvas->drawText(fps_counter_text.c_str(), fps_counter_text.length(),
+                         width_ - 48, 32, text_paint);
+      }
+
       if (gr_context_) {
         gr_context_->flush();
         glFlush();
 
         if (egl_sync_type) {
           EGLSyncKHR sync =
               eglCreateSyncKHR(eglGetCurrentDisplay(), egl_sync_type, nullptr);
           DCHECK(sync != EGL_NO_SYNC_KHR);
           eglClientWaitSyncKHR(eglGetCurrentDisplay(), sync,
                                EGL_SYNC_FLUSH_COMMANDS_BIT_KHR,
@@ skipping 132 matching lines @@
 
 // Specifies the number of rotating rects to draw.
 const char kNumRects[] = "num-rects";
 
 // 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";
+
 // 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 33 matching lines @@
   }
 
   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), use_drm.get());
+      command_line->HasSwitch(switches::kFullscreen),
+      command_line->HasSwitch(switches::kShowFpsCounter), use_drm.get());

[Daniele Castagna, 2016/11/14 03:04:32]

Why would you *not* want to see the fps? And if there is any reason for that,
wouldn't it be better to have it on by default and have a flag to disable it?

[reveman, 2016/11/14 15:00:49]

I'd like to use this client as a benchmark that would produce the maximum number
of bytes that can be transferred to screen per second without having any text
rendering influence the results.

[Daniele Castagna, 2016/11/14 15:17:03]

Then you might want to be able not to print the event timestamps too.

[reveman, 2016/11/14 16:52:35]

I think this is OK as these will only be printed as a result of motion events
and that's not going to happen in the benchmark case I'm thinking of.

   return client.Run();
 }