exo: Add max frames pending flag 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>
 #include <wayland-client-core.h>
 #include <wayland-client-protocol.h>
 
+#include <deque>
 #include <iostream>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/scoped_generic.h"
@@ skipping 67 matching lines @@
 const int32_t kDrmFormat = DRM_FORMAT_ABGR8888;
 #endif
 const size_t kBytesPerPixel = 4;
 
 #if defined(OZONE_PLATFORM_GBM)
 // DRI render node path template.
 const char kDriRenderNodeTemplate[] = "/dev/dri/renderD%u";
 #endif
 
 // Number of buffers.
-const size_t kBuffers = 3;
+const size_t kBuffers = 8;
 
 // Rotation speed (degrees/second).
 const double kRotationSpeed = 360.0;
 
 // Benchmark interval in seconds.
 const int kBenchmarkInterval = 5;
 
 struct Globals {
   std::unique_ptr<wl_compositor> compositor;
   std::unique_ptr<wl_shm> shm;
@@ skipping 181 matching lines @@
 #endif
 
 }  // namespace
 
 class MotionEvents {
  public:
   MotionEvents(size_t width,
                size_t height,
                int scale,
                size_t num_rects,
-               const std::string* use_drm,
-               bool fullscreen)
+               size_t max_frames_pending,
+               bool fullscreen,
+               const std::string* use_drm)
       : width_(width),
         height_(height),
         scale_(scale),
         num_rects_(num_rects),
-        use_drm_(use_drm),
-        fullscreen_(fullscreen) {}
+        max_frames_pending_(max_frames_pending),
+        fullscreen_(fullscreen),
+        use_drm_(use_drm) {}
 
   // Initialize and run client main loop.
   int Run();
 
  private:
   bool CreateBuffer(Buffer* buffer);
-  size_t stride() const { return width_ * kBytesPerPixel; }
-  size_t buffer_size() const { return stride() * height_; }
 
   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 std::string* use_drm_;
-  const bool fullscreen_;
 
   Globals globals_;
   std::unique_ptr<wl_display> display_;
 
 #if defined(OZONE_PLATFORM_GBM)
   base::ScopedFD drm_fd_;
   std::unique_ptr<gbm_device> device_;
 #endif
 
   scoped_refptr<gl::GLSurface> gl_surface_;
@@ skipping 11 matching lines @@
   if (!display_) {
     LOG(ERROR) << "wl_display_connect failed";
     return 1;
   }
 
   bool gl_initialized = gl::init::InitializeGLOneOff();
   DCHECK(gl_initialized);
   gl_surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
   gl_context_ =
       gl::init::CreateGLContext(nullptr,  // share_group
-                                gl_surface_.get(), gl::PreferIntegratedGpu);
+                                gl_surface_.get(), gl::GLContextAttribs());
 
   make_current_.reset(
       new ui::ScopedMakeCurrent(gl_context_.get(), gl_surface_.get()));
+
   wl_registry_listener registry_listener = {RegistryHandler, RegistryRemover};
 
   wl_registry* registry = wl_display_get_registry(display_.get());
   wl_registry_add_listener(registry, &registry_listener, &globals_);
 
   wl_display_roundtrip(display_.get());
 
   if (!globals_.compositor) {
     LOG(ERROR) << "Can't find compositor interface";
     return 1;
   }
   if (!globals_.shm) {
     LOG(ERROR) << "Can't find shm interface";
     return 1;
   }
   if (use_drm_ && !globals_.linux_dmabuf) {
     LOG(ERROR) << "Can't find linux_dmabuf interface";
     return 1;
   }
   if (!globals_.shell) {
     LOG(ERROR) << "Can't find shell interface";
     return 1;
   }
   if (!globals_.seat) {
     LOG(ERROR) << "Can't find seat interface";
     return 1;
   }
 
+  EGLenum egl_sync_type = 0;
 #if defined(OZONE_PLATFORM_GBM)
   if (use_drm_) {
     // Number of files to look for when discovering DRM devices.
     const uint32_t kDrmMaxMinor = 15;
     const uint32_t kRenderNodeStart = 128;
     const uint32_t kRenderNodeEnd = kRenderNodeStart + kDrmMaxMinor;
 
     for (uint32_t i = kRenderNodeStart; i < kRenderNodeEnd; i++) {
       std::string dri_render_node(
           base::StringPrintf(kDriRenderNodeTemplate, i));
@@ skipping 24 matching lines @@
       return 1;
     }
   }
 
   sk_sp<const GrGLInterface> native_interface(GrGLCreateNativeInterface());
   DCHECK(native_interface);
   gr_context_ = sk_sp<GrContext>(GrContext::Create(
       kOpenGL_GrBackend,
       reinterpret_cast<GrBackendContext>(native_interface.get())));
   DCHECK(gr_context_);
+
+  if (gl::GLSurfaceEGL::HasEGLExtension("EGL_EXT_image_flush_external") ||
+      gl::GLSurfaceEGL::HasEGLExtension("EGL_ARM_implicit_external_sync")) {
+    egl_sync_type = EGL_SYNC_FENCE_KHR;
+  }
+  if (gl::GLSurfaceEGL::HasEGLExtension("EGL_ANDROID_native_fence_sync")) {
+    egl_sync_type = EGL_SYNC_NATIVE_FENCE_ANDROID;
+  }
 #endif
 
   wl_buffer_listener buffer_listener = {BufferRelease};
 
   for (size_t i = 0; i < kBuffers; ++i) {
     if (!CreateBuffer(&buffers_[i]))
       return 1;
   }
   wl_display_roundtrip(display_.get());
   for (size_t i = 0; i < kBuffers; ++i) {
@@ skipping 61 matching lines @@
     return 1;
   }
 
   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);
+  base::TimeDelta benchmark_wall_time;
+  base::TimeDelta benchmark_cpu_time;
 
+  int dispatch_status = 0;
   do {
-    if (frame.callback_pending)
+    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;
+
+        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);
+          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->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};
+        paint.setColor(SkColorSetA(kColors[i % arraysize(kColors)], 0xA0));
+        canvas->rotate(rotation / num_rects_);
+        canvas->drawIRect(rect, paint);
+      }
+
+      canvas->restore();
+      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,
+                               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;
       continue;
-
-    Buffer* buffer =
-        std::find_if(std::begin(buffers_), std::end(buffers_),
-                     [](const Buffer& buffer) { return !buffer.busy; });
-    if (buffer == std::end(buffers_))
-      continue;
-
-    base::TimeTicks current_time = base::TimeTicks::Now();
-    if ((current_time - benchmark_time) > benchmark_interval) {
-      std::cout << frames << " frames in " << benchmark_interval.InSeconds()
-                << " seconds: "
-                << static_cast<double>(frames) / benchmark_interval.InSeconds()
-                << " fps" << std::endl;
-      benchmark_time = current_time;
-      frames = 0;
     }
 
-    SkCanvas* canvas = buffer->sk_surface->getCanvas();
-    canvas->save();
+    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();
 
-    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);
-        event_times.pop_back();
-        y += h;
-      }
+      frame_callback.reset(wl_surface_frame(surface.get()));
+      wl_callback_add_listener(frame_callback.get(), &frame_listener, &frame);
+      frame.callback_pending = true;
+      wl_surface_commit(surface.get());
+      wl_display_flush(display_.get());
+      continue;
     }
 
-    // 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->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};
-      paint.setColor(SkColorSetA(kColors[i % arraysize(kColors)], 0xA0));
-      canvas->rotate(rotation / num_rects_);
-      canvas->drawIRect(rect, paint);
-    }
-    canvas->restore();
-    if (gr_context_) {
-      gr_context_->flush();
-      glFinish();
-    }
-    wl_surface_set_buffer_scale(surface.get(), scale_);
-    wl_surface_attach(surface.get(), buffer->buffer.get(), 0, 0);
-    buffer->busy = true;
-
-    frame_callback.reset(wl_surface_frame(surface.get()));
-    wl_callback_add_listener(frame_callback.get(), &frame_listener, &frame);
-    frame.callback_pending = true;
-
-    ++frames;
-
-    wl_surface_commit(surface.get());
-  } while (wl_display_dispatch(display_.get()) != -1);
+    dispatch_status = wl_display_dispatch(display_.get());
+  } while (dispatch_status != -1);
 
   return 0;
 }
 
 bool MotionEvents::CreateBuffer(Buffer* buffer) {
 #if defined(OZONE_PLATFORM_GBM)
   if (use_drm_) {
     buffer->bo.reset(gbm_bo_create(device_.get(), width_, height_, kDrmFormat,
                                    GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING));
     if (!buffer->bo) {
       LOG(ERROR) << "Can't create gbm buffer";
       return false;
     }
     base::ScopedFD fd(gbm_bo_get_plane_fd(buffer->bo.get(), 0));
     static const zwp_linux_buffer_params_v1_listener params_listener = {
         LinuxBufferParamsCreated, LinuxBufferParamsFailed};
 
     buffer->params.reset(
         zwp_linux_dmabuf_v1_create_params(globals_.linux_dmabuf.get()));
     zwp_linux_buffer_params_v1_add_listener(buffer->params.get(),
                                             &params_listener, buffer);
-    zwp_linux_buffer_params_v1_add(buffer->params.get(), fd.get(), 0, 0,
-                                   stride(), 0, 0);
+    uint32_t stride = gbm_bo_get_stride(buffer->bo.get());
+    zwp_linux_buffer_params_v1_add(buffer->params.get(), fd.get(), 0, 0, stride,
+                                   0, 0);
     zwp_linux_buffer_params_v1_create(buffer->params.get(), width_, height_,
                                       kDrmFormat, 0);
 
     EGLint khr_image_attrs[] = {EGL_DMA_BUF_PLANE0_FD_EXT,
                                 fd.get(),
                                 EGL_WIDTH,
                                 width_,
                                 EGL_HEIGHT,
                                 height_,
                                 EGL_LINUX_DRM_FOURCC_EXT,
                                 kDrmFormat,
                                 EGL_DMA_BUF_PLANE0_PITCH_EXT,
-                                stride(),
+                                stride,
                                 EGL_DMA_BUF_PLANE0_OFFSET_EXT,
                                 0,
                                 EGL_NONE};
     EGLImageKHR image = eglCreateImageKHR(
         eglGetCurrentDisplay(), EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT,
         nullptr /* no client buffer */, khr_image_attrs);
 
     buffer->egl_image.reset(new ScopedEglImage(image));
     GLuint texture = 0;
     glGenTextures(1, &texture);
@@ skipping 13 matching lines @@
     desc.fConfig = kGrPixelConfig;
     desc.fOrigin = kTopLeft_GrSurfaceOrigin;
     desc.fTextureHandle = reinterpret_cast<GrBackendObject>(&texture_info);
 
     buffer->sk_surface = SkSurface::MakeFromBackendTextureAsRenderTarget(
         gr_context_.get(), desc, nullptr);
     DCHECK(buffer->sk_surface);
     return true;
   }
 #endif
-  buffer->shared_memory.CreateAndMapAnonymous(buffer_size());
+
+  size_t stride = width_ * kBytesPerPixel;
+  buffer->shared_memory.CreateAndMapAnonymous(stride * height_);
   buffer->shm_pool.reset(
       wl_shm_create_pool(globals_.shm.get(), buffer->shared_memory.handle().fd,
                          buffer->shared_memory.requested_size()));
 
   buffer->buffer.reset(static_cast<wl_buffer*>(wl_shm_pool_create_buffer(
-      buffer->shm_pool.get(), 0, width_, height_, stride(), kShmFormat)));
+      buffer->shm_pool.get(), 0, width_, height_, stride, kShmFormat)));
   if (!buffer->buffer) {
     LOG(ERROR) << "Can't create buffer";
     return false;
   }
 
   buffer->sk_surface = SkSurface::MakeRasterDirect(
       SkImageInfo::Make(width_, height_, kColorType, kOpaque_SkAlphaType),
-      static_cast<uint8_t*>(buffer->shared_memory.memory()), stride());
+      static_cast<uint8_t*>(buffer->shared_memory.memory()), stride);
   DCHECK(buffer->sk_surface);
   return true;
 }
 
 }  // namespace clients
 }  // namespace wayland
 }  // namespace exo
 
 namespace switches {
 
 // Specifies the client buffer size.
 const char kSize[] = "size";
 
 // Specifies the client scale factor (ie. number of physical pixels per DIP).
 const char kScale[] = "scale";
 
 // 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";
+
 // Use drm buffer instead of shared memory.
 const char kUseDrm[] = "use-drm";
 
-// Specifies if client should be fullscreen.
-const char kFullscreen[] = "fullscreen";
-
 }  // namespace switches
 
 int main(int argc, char* argv[]) {
   base::AtExitManager exit_manager;
   base::CommandLine::Init(argc, argv);
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   int width = 256;
   int height = 256;
   if (command_line->HasSwitch(switches::kSize)) {
@@ skipping 13 matching lines @@
   }
 
   size_t num_rects = 1;
   if (command_line->HasSwitch(switches::kNumRects) &&
       !base::StringToSizeT(
           command_line->GetSwitchValueASCII(switches::kNumRects), &num_rects)) {
     LOG(ERROR) << "Invalid value for " << switches::kNumRects;
     return 1;
   }
 
+  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;
+  }
+
   std::unique_ptr<std::string> use_drm;
   if (command_line->HasSwitch(switches::kUseDrm)) {
     use_drm.reset(
         new std::string(command_line->GetSwitchValueASCII(switches::kUseDrm)));
   }
 
-  bool fullscreen = command_line->HasSwitch(switches::kFullscreen);
-
-  exo::wayland::clients::MotionEvents client(width, height, scale, num_rects,
-                                             use_drm.get(), fullscreen);
+  exo::wayland::clients::MotionEvents client(
+      width, height, scale, num_rects, max_frames_pending,
+      command_line->HasSwitch(switches::kFullscreen), use_drm.get());
   return client.Run();
 }