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,

[nduca, 2010/11/26 19:07:37]

Just checking my understanding, the 1 is because the IOSurface isnt' double
buffered so >1 would cause us to render into the IOSurface before it is
presented?

[Ken Russell (switch to Gerrit), 2010/11/26 20:23:10]

No. It's because if we increase it to 2 then the renderer process races ahead
and produces 2 frames for each 1 that is actually displayed to the screen. For
at least one of our test cases this makes JavaScript think that it's rendering
at 120 FPS when in fact it's only rendering at 60 FPS. I think we need to get to
a baseline where JavaScript has a correct notion of the frame rate, which is
achieved by setting this to 1 as well as the number of outstanding swap buffers
calls in gpu_processor.cc to 1.

+// because otherwise the renderer process produces frames that do not
+// actually reach the screen.
+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