Add flow control between renderer and GPU processes, and, on Mac OS X,...

chrome/renderer/ggl/ggl.cc

 // Copyright (c) 2010 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.
 
 #include "build/build_config.h"
 
 #include "base/ref_counted.h"
 #include "base/singleton.h"
 #include "base/weak_ptr.h"
 #include "chrome/renderer/command_buffer_proxy.h"
@@ skipping 16 matching lines @@
 
 #if defined(ENABLE_GPU)
 
 namespace {
 
 const int32 kCommandBufferSize = 1024 * 1024;
 // TODO(kbr): make the transfer buffer size configurable via context
 // creation attributes.
 const int32 kTransferBufferSize = 1024 * 1024;
 
+// TODO(kbr) / TODO(apatrick): determine the best number of pending frames
+// in the general case. On Mac OS X it seems we really want this to be 1,
+// because otherwise the renderer process produces frames that do not
+// actually reach the screen.

[Nico, 2010/11/24 23:43:29]

True, but the browser process would show the latest of the N frames the renderer
produces, not the first. So it's not all wasted work, it reduces display
latency.

[Ken Russell (switch to Gerrit), 2010/11/25 01:02:08]

Correct.
That's possible. More investigation is needed. In Safari, where Core Animation's
built-in rate limiting mechanisms are in use, Chris Rogers' fill-limited test
case reaches a steady state of 60 FPS. If we increase this number here to 2 then
Chromium claims 120 FPS, but the browser is only displaying 60 FPS. In that
situation we are definitely doing more rendering work than desired. We may need
to do some sort of adaptive throttling to get the best behavior.

+const int kMaxFramesPending = 1;
+
 // Singleton used to initialize and terminate the gles2 library.
 class GLES2Initializer {
  public:
   GLES2Initializer() {
     gles2::Initialize();
   }
 
   ~GLES2Initializer() {
     gles2::Terminate();
   }
@@ skipping 78 matching lines @@
   scoped_refptr<GpuChannelHost> channel_;
   base::WeakPtr<Context> parent_;
   scoped_ptr<Callback0::Type> swap_buffers_callback_;
   uint32 parent_texture_id_;
   CommandBufferProxy* command_buffer_;
   gpu::gles2::GLES2CmdHelper* gles2_helper_;
   int32 transfer_buffer_id_;
   gpu::gles2::GLES2Implementation* gles2_implementation_;
   gfx::Size size_;
 
+  int32 swap_buffer_tokens_[kMaxFramesPending];
+
   Error last_error_;
 
   DISALLOW_COPY_AND_ASSIGN(Context);
 };
 
 Context::Context(GpuChannelHost* channel, Context* parent)
     : channel_(channel),
       parent_(parent ? parent->AsWeakPtr() : base::WeakPtr<Context>()),
       parent_texture_id_(0),
       command_buffer_(NULL),
       gles2_helper_(NULL),
       transfer_buffer_id_(0),
       gles2_implementation_(NULL),
       last_error_(SUCCESS) {
   DCHECK(channel);
+  for (int i = 0; i < kMaxFramesPending; ++i)
+    swap_buffer_tokens_[i] = -1;
 }
 
 Context::~Context() {
   Destroy();
 }
 
 bool Context::Initialize(gfx::NativeViewId view,
                          int render_view_id,
                          const gfx::Size& size,
                          const char* allowed_extensions,
@@ skipping 209 matching lines @@
 
   return true;
 }
 
 bool Context::SwapBuffers() {
   // Don't request latest error status from service. Just use the locally cached
   // information from the last flush.
   if (command_buffer_->GetLastState().error != gpu::error::kNoError)
     return false;
 
+  // Throttle until there are not too many frames pending.
+  if (swap_buffer_tokens_[0] != -1) {
+    gles2_helper_->WaitForToken(swap_buffer_tokens_[0]);
+  }
+
   gles2_implementation_->SwapBuffers();
+
+  // Insert a new token to throttle against for this frame.
+  for (int i = 0; i < kMaxFramesPending - 1; ++i)
+    swap_buffer_tokens_[i] = swap_buffer_tokens_[i + 1];
+  swap_buffer_tokens_[kMaxFramesPending - 1] = gles2_helper_->InsertToken();
+
   return true;
 }
 
 media::VideoDecodeEngine* Context::CreateVideoDecodeEngine() {
   return channel_->gpu_video_service_host()->CreateVideoDecoder(
       command_buffer_->route_id());
 }
 
 media::VideoDecodeContext* Context::CreateVideoDecodeContext(
     MessageLoop* message_loop, bool hardware_decoder) {
@@ skipping 173 matching lines @@
 }
 
 gpu::gles2::GLES2Implementation* GetImplementation(Context* context) {
   if (!context)
     return NULL;
 
   return context->gles2_implementation();
 }
 
 }  // namespace ggl