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'ss idle work to be done.

[Sami, 2013/03/07 16:57:19]

Typo: there'ss

[reveman, 2013/03/07 20:21:04]

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
+  // 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