gpu: Reduce GL context switches used to check pending queries.

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/hash.h"
 #include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
@@ skipping 181 matching lines @@
       gpu_preference_(gpu_preference),
       use_virtualized_gl_context_(use_virtualized_gl_context),
       stream_id_(stream_id),
       route_id_(route_id),
       surface_id_(surface_id),
       software_(software),
       last_flush_count_(0),
       last_memory_allocation_valid_(false),
       watchdog_(watchdog),
       sync_point_wait_count_(0),
-      delayed_work_scheduled_(false),
       previous_processed_num_(0),
       active_url_(active_url),
       total_gpu_memory_(0) {
   active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
   FastSetActiveURL(active_url_, active_url_hash_);
 
   gpu::gles2::ContextCreationAttribHelper attrib_parser;
   attrib_parser.Parse(requested_attribs_);
 
   if (share_group) {
@@ skipping 93 matching lines @@
         OnSetClientHasMemoryAllocationChangedCallback)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateImage, OnCreateImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyImage, OnDestroyImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateStreamTexture,
                         OnCreateStreamTexture)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   CheckCompleteWaits();
 
+  // Ensure that any delayed work that was created will be handled.
   if (have_context) {
-    // Ensure that any delayed work that was created will be handled.
-    ScheduleDelayedWork(kHandleMoreWorkPeriodMs);
+    if (scheduler_)
+      scheduler_->ProcessPendingQueries();
+    ScheduleDelayedWork(
+        base::TimeDelta::FromMilliseconds(kHandleMoreWorkPeriodMs));
   }
 
   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() {
+  // Post another delayed task if we have not yet reached the time at which
+  // we should process delayed work.
+  base::TimeTicks current_time = base::TimeTicks::Now();
+  DCHECK(!process_delayed_work_time_.is_null());
+  if (process_delayed_work_time_ > current_time) {
+    task_runner_->PostDelayedTask(
+        FROM_HERE, base::Bind(&GpuCommandBufferStub::PollWork, AsWeakPtr()),
+        process_delayed_work_time_ - current_time);
+    return;
+  }
+  process_delayed_work_time_ = base::TimeTicks();
+
+  PerformWork();
 }
 
-void GpuCommandBufferStub::PollWork() {
-  TRACE_EVENT0("gpu", "GpuCommandBufferStub::PollWork");
-  delayed_work_scheduled_ = false;
+void GpuCommandBufferStub::PerformWork() {
+  TRACE_EVENT0("gpu", "GpuCommandBufferStub::PerformWork");
+
   FastSetActiveURL(active_url_, active_url_hash_);
   if (decoder_.get() && !MakeCurrent())
     return;
 
   if (scheduler_) {
     const uint32_t current_unprocessed_num =
         channel()->gpu_channel_manager()->UnprocessedOrderNumber();
     // We're idle when no messages were processed or scheduled.
     bool is_idle = (previous_processed_num_ == current_unprocessed_num);
     if (!is_idle && !last_idle_time_.is_null()) {
       base::TimeDelta time_since_idle =
           base::TimeTicks::Now() - last_idle_time_;
       base::TimeDelta max_time_since_idle =
           base::TimeDelta::FromMilliseconds(kMaxTimeSinceIdleMs);
 
       // Force idle when it's been too long since last time we were idle.
       if (time_since_idle > max_time_since_idle)
         is_idle = true;
     }
 
     if (is_idle) {
       last_idle_time_ = base::TimeTicks::Now();
       scheduler_->PerformIdleWork();
     }
+
+    scheduler_->ProcessPendingQueries();
   }
-  ScheduleDelayedWork(kHandleMoreWorkPeriodBusyMs);
+
+  ScheduleDelayedWork(
+      base::TimeDelta::FromMilliseconds(kHandleMoreWorkPeriodBusyMs));
 }
 
 bool GpuCommandBufferStub::HasUnprocessedCommands() {
   if (command_buffer_) {
     gpu::CommandBuffer::State state = command_buffer_->GetLastState();
     return command_buffer_->GetPutOffset() != state.get_offset &&
         !gpu::error::IsError(state.error);
   }
   return false;
 }
 
-void GpuCommandBufferStub::ScheduleDelayedWork(int64 delay) {
-  if (!HasMoreWork()) {
+void GpuCommandBufferStub::ScheduleDelayedWork(base::TimeDelta delay) {
+  bool has_more_work = scheduler_.get() && (scheduler_->HasPendingQueries() ||
+                                            scheduler_->HasMoreIdleWork());
+  if (!has_more_work) {
     last_idle_time_ = base::TimeTicks();
     return;
   }
 
-  if (delayed_work_scheduled_)
+  base::TimeTicks current_time = base::TimeTicks::Now();
+  // |process_delayed_work_time_| is set if processing of delayed work is
+  // already scheduled. Just update the time if already scheduled.
+  if (!process_delayed_work_time_.is_null()) {
+    process_delayed_work_time_ = current_time + delay;
     return;
-  delayed_work_scheduled_ = true;
+  }
 
   // Idle when no messages are processed between now and when
   // PollWork is called.
   previous_processed_num_ =
       channel()->gpu_channel_manager()->ProcessedOrderNumber();
   if (last_idle_time_.is_null())
-    last_idle_time_ = base::TimeTicks::Now();
+    last_idle_time_ = current_time;
 
   // IsScheduled() returns true after passing all unschedule fences
   // and this is when we can start performing idle work. Idle work
   // is done synchronously so we can set delay to 0 and instead poll
   // for more work at the rate idle work is performed. This also ensures
   // that idle work is done as efficiently as possible without any
   // unnecessary delays.
   if (scheduler_.get() &&
       scheduler_->IsScheduled() &&
       scheduler_->HasMoreIdleWork()) {
-    delay = 0;
+    delay = base::TimeDelta();
   }
 
+  process_delayed_work_time_ = current_time + delay;
   task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&GpuCommandBufferStub::PollWork, AsWeakPtr()),
-      base::TimeDelta::FromMilliseconds(delay));
+      delay);
 }
 
 bool GpuCommandBufferStub::MakeCurrent() {
   if (decoder_->MakeCurrent())
     return true;
   DLOG(ERROR) << "Context lost because MakeCurrent failed.";
   command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
   command_buffer_->SetParseError(gpu::error::kLostContext);
   CheckContextLost();
   return false;
@@ skipping 759 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content