gpu: Implement idle async pixel transfers.

content/common/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hash.h"
 #include "base/shared_memory.h"
@@ skipping 70 matching lines @@
   static size_t g_last_url_hash = 0;
   if (url_hash != g_last_url_hash) {
     g_last_url_hash = url_hash;
     GetContentClient()->SetActiveURL(url);
   }
 }
 
 // The first time polling a fence, delay some extra time to allow other
 // stubs to process some work, or else the timing of the fences could
 // allow a pattern of alternating fast and slow frames to occur.
-const int64 kHandleMoreWorkPeriodMs = 2;
-const int64 kHandleMoreWorkPeriodBusyMs = 1;
+const int64 kHandleMoreWorkPeriodMicroseconds = 2000;
+const int64 kHandleMoreWorkPeriodBusyMicroseconds = 1000;
+
+// Use a shorter delay when there's idle work to be done.
+const int64 kHandleMoreIdleWorkPeriodBusyMicroseconds = 100;
+// Prevents idle work from being starved.
+const int64 kMaxTimeSinceIdleMicroseconds = 10000;
 
 }  // namespace
 
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     GpuCommandBufferStub* share_group,
     const gfx::GLSurfaceHandle& handle,
     gpu::gles2::MailboxManager* mailbox_manager,
     gpu::gles2::ImageManager* image_manager,
     const gfx::Size& size,
@@ skipping 16 matching lines @@
       route_id_(route_id),
       surface_id_(surface_id),
       software_(software),
       last_flush_count_(0),
       last_memory_allocation_valid_(false),
       parent_stub_for_initialization_(),
       parent_texture_for_initialization_(0),
       watchdog_(watchdog),
       sync_point_wait_count_(0),
       delayed_work_scheduled_(false),
+      is_idle_(false),
       active_url_(active_url),
       total_gpu_memory_(0) {
   active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
   FastSetActiveURL(active_url_, active_url_hash_);
   if (share_group) {
     context_group_ = share_group->context_group_;
   } else {
     context_group_ = new gpu::gles2::ContextGroup(
         mailbox_manager,
         image_manager,
@@ skipping 20 matching lines @@
   // messages directed at the command buffer. This ensures that the message
   // handler can assume that the context is current (not necessary for
   // Echo, RetireSyncPoint, or WaitSyncPoint).
   if (decoder_.get() &&
       message.type() != GpuCommandBufferMsg_Echo::ID &&
       message.type() != GpuCommandBufferMsg_RetireSyncPoint::ID) {
     if (!MakeCurrent())
       return false;
   }
 
+  is_idle_ = false;
+
   // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Initialize,
                                     OnInitialize);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetGetBuffer,
                                     OnSetGetBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetParent,
                                     OnSetParent);
@@ skipping 25 matching lines @@
                         OnSignalSyncPoint)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SendClientManagedMemoryStats,
                         OnReceivedClientManagedMemoryStats)
     IPC_MESSAGE_HANDLER(
         GpuCommandBufferMsg_SetClientHasMemoryAllocationChangedCallback,
         OnSetClientHasMemoryAllocationChangedCallback)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   // Ensure that any delayed work that was created will be handled.
-  ScheduleDelayedWork(kHandleMoreWorkPeriodMs);
+  ScheduleDelayedWork(kHandleMoreWorkPeriodMicroseconds);
 
   DCHECK(handled);
   return handled;
 }
 
 bool GpuCommandBufferStub::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
 
 bool GpuCommandBufferStub::IsScheduled() {
   return (!scheduler_.get() || scheduler_->IsScheduled());
 }
 
 bool GpuCommandBufferStub::HasMoreWork() {
   return scheduler_.get() && scheduler_->HasMoreWork();
 }
 
 void GpuCommandBufferStub::PollWork() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::PollWork");
   delayed_work_scheduled_ = false;
   FastSetActiveURL(active_url_, active_url_hash_);
   if (decoder_.get() && !MakeCurrent())
     return;
-  if (scheduler_.get())
-    scheduler_->PollUnscheduleFences();
-  ScheduleDelayedWork(kHandleMoreWorkPeriodBusyMs);
+  int64 delay = kHandleMoreWorkPeriodBusyMicroseconds;
+  if (scheduler_.get()) {
+    bool fences_complete = scheduler_->PollUnscheduleFences();
+    // Perform idle work if all fences are complete.
+    if (fences_complete) {
+      DCHECK(!last_idle_time_.is_null());
+      base::TimeDelta time_since_idle = base::TimeTicks::Now() -
+          last_idle_time_;
+      base::TimeDelta max_time_since_idle =
+          base::TimeDelta::FromMicroseconds(kMaxTimeSinceIdleMicroseconds);
+
+      // Perform some idle work if idle or it's been too long since
+      // last time we were idle.
+      if (is_idle_ || time_since_idle > max_time_since_idle) {
+        last_idle_time_ = base::TimeTicks::Now();
+        // Use idle work period delay when there's more idle work pending.
+        if (scheduler_->PerformIdleWork())
+          delay = kHandleMoreIdleWorkPeriodBusyMicroseconds;
+      }
+    }
+  }
+  ScheduleDelayedWork(delay);
 }
 
 bool GpuCommandBufferStub::HasUnprocessedCommands() {
   if (command_buffer_.get()) {
     gpu::CommandBuffer::State state = command_buffer_->GetLastState();
     return state.put_offset != state.get_offset &&
         !gpu::error::IsError(state.error);
   }
   return false;
 }
 
 void GpuCommandBufferStub::ScheduleDelayedWork(int64 delay) {
-  if (HasMoreWork() && !delayed_work_scheduled_) {
-    delayed_work_scheduled_ = true;
-    MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&GpuCommandBufferStub::PollWork,
-                   AsWeakPtr()),
-        base::TimeDelta::FromMilliseconds(delay));
+  if (!HasMoreWork()) {
+    last_idle_time_ = base::TimeTicks();
+    return;
   }
+
+  if (delayed_work_scheduled_)
+    return;
+  delayed_work_scheduled_ = true;
+
+  // Consider the command buffer idle if no messages are received between

[epenner, 2013/03/08 21:44:57]

It seems like there might be a way this could be done more accurately with less
poll tasks.

- Do we even need a timer delay at all? (If there is future work shouldn't it
already be posted to the message loop)?

- Similarly, if there is no idle work, do we need to poll at all?  Doesn't the
idle work arrive via GPU commands, at which point we could do one idle poll
followed by one more poll after each idle job?

It also seems like we could do this globally for all contexts somehow (maybe not
important right now). Perhaps by querying the message loop directly somehow to
know it's truly idle? Wdyt?

[reveman, 2013/03/12 00:31:42]

Latest patch has a much more efficient way of detecting if we're in an idle
state. It doesn't do less polling but uses 0 delay when possible.
The message deferring system for each gpu channel made this a bit tricky but
what's in the latest patch seem to be working well.
That's basically how this works. ScheduleDelayedWork() is called after some
commands are processed. If no messages are processed or scheduled to be
processed between ScheduleDelayedWork() and PollWork(), we're idle.
Latest patch also does this globally instead of per command buffer.

+  // now and when PollWork is called.
+  is_idle_ = true;
+  if (last_idle_time_.is_null())
+    last_idle_time_ = base::TimeTicks::Now();
+
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&GpuCommandBufferStub::PollWork,
+                 AsWeakPtr()),
+      base::TimeDelta::FromMicroseconds(delay));
 }
 
 void GpuCommandBufferStub::OnEcho(const IPC::Message& message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnEcho");
   Send(new IPC::Message(message));
 }
 
 bool GpuCommandBufferStub::MakeCurrent() {
   if (decoder_->MakeCurrent())
     return true;
@@ skipping 602 matching lines @@
     if (surface_ && MakeCurrent())
       surface_->SetFrontbufferAllocation(
           allocation.browser_allocation.suggest_have_frontbuffer);
   }
 
   last_memory_allocation_valid_ = true;
   last_memory_allocation_ = allocation;
 }
 
 }  // namespace content