GPU: Only allow the UI channel to preempt if all stubs are scheduled.

content/common/gpu/gpu_channel.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 139 matching lines @@
  public:
   // Takes ownership of gpu_channel (see below).
   SyncPointMessageFilter(base::WeakPtr<GpuChannel>* gpu_channel,
                          scoped_refptr<SyncPointManager> sync_point_manager,
                          scoped_refptr<base::MessageLoopProxy> message_loop)
       : preemption_state_(IDLE),
         gpu_channel_(gpu_channel),
         channel_(NULL),
         sync_point_manager_(sync_point_manager),
         message_loop_(message_loop),
-        messages_received_(0) {
+        messages_received_(0),
+        a_stub_is_descheduled_(false) {
   }
 
   virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
     DCHECK(!channel_);
     channel_ = channel;
   }
 
   virtual void OnFilterRemoved() OVERRIDE {
     DCHECK(channel_);
     channel_ = NULL;
@@ skipping 29 matching lines @@
     }
   }
 
   void MessageProcessed(uint64 messages_processed) {
     while (!pending_messages_.empty() &&
            pending_messages_.front().message_number <= messages_processed)
       pending_messages_.pop();
     UpdatePreemptionState();
   }
 
-  void SetPreemptingFlag(gpu::PreemptionFlag* preempting_flag) {
+  void SetPreemptingFlagAndSchedulingState(
+      gpu::PreemptionFlag* preempting_flag,
+      bool a_stub_is_descheduled) {
     preempting_flag_ = preempting_flag;
+    a_stub_is_descheduled_ = a_stub_is_descheduled;
+  }
+
+  void UpdateStubSchedulingState(bool a_stub_is_descheduled) {

[piman, 2013/02/27 21:54:43]

I'm afraid this will kick preemption more than you'd generally want. Basically
any time passed unscheduled counts towards the preemption timeout.
OTOH, I think changing the state machine to take a_stub_is_descheduled_ into
account isn't bad at all, all you have to change is UpdatePreemtionState, to
test a_stub_is_descheduled_ any time you check pending_messages_.empty()
(and call UpdateStubSchedulingState)

[jonathan.backer, 2013/02/28 21:43:56]

Done.

+    a_stub_is_descheduled_ = a_stub_is_descheduled;
+    if (preemption_state_ == PREEMPTING) {
+      if (a_stub_is_descheduled_)
+        preempting_flag_->Reset();
+      else
+        preempting_flag_->Set();
+    }
   }
 
  protected:
   virtual ~SyncPointMessageFilter() {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &SyncPointMessageFilter::DeleteWeakPtrOnMainThread, gpu_channel_));
   }
 
  private:
   enum PreemptionState {
     // Either there's no other channel to preempt, there are no messages
     // pending processing, or we just finished preempting and have to wait
     // before preempting again.
     IDLE,
     // We are waiting kPreemptWaitTimeMs before checking if we should preempt.
     WAITING,
     // We can preempt whenever any IPC processing takes more than
     // kPreemptWaitTimeMs.
     CHECKING,
-    // We are currently preempting.
+    // We are currently preempting if and only if all stubs on this channel
+    // are scheduled.
     PREEMPTING,
   };
 
   PreemptionState preemption_state_;
 
   struct PendingMessage {
     uint64 message_number;
     base::TimeTicks time_received;
 
     explicit PendingMessage(uint64 message_number)
@@ skipping 75 matching lines @@
   }
 
   void TransitionToPreempting() {
     DCHECK_EQ(preemption_state_, CHECKING);
 
     // Stop any pending state update checks that we may have queued
     // while CHECKING.
     timer_.Stop();
 
     preemption_state_ = PREEMPTING;
-    preempting_flag_->Set();
+    if (!a_stub_is_descheduled_)
+      preempting_flag_->Set();
     TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 1);
 
     timer_.Start(
        FROM_HERE,
        base::TimeDelta::FromMilliseconds(kMaxPreemptTimeMs),
        this, &SyncPointMessageFilter::TransitionToIdle);
 
     UpdatePreemptionState();
   }
 
@@ skipping 35 matching lines @@
   scoped_refptr<SyncPointManager> sync_point_manager_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
 
   std::queue<PendingMessage> pending_messages_;
 
   // Count of the number of IPCs received on this GpuChannel.
   uint64 messages_received_;
 
   base::OneShotTimer<SyncPointMessageFilter> timer_;
+
+  bool a_stub_is_descheduled_;
 };
 
 GpuChannel::GpuChannel(GpuChannelManager* gpu_channel_manager,
                        GpuWatchdog* watchdog,
                        gfx::GLShareGroup* share_group,
                        gpu::gles2::MailboxManager* mailbox,
                        int client_id,
                        bool software)
     : gpu_channel_manager_(gpu_channel_manager),
       messages_processed_(0),
       client_id_(client_id),
       share_group_(share_group ? share_group : new gfx::GLShareGroup),
       mailbox_manager_(mailbox ? mailbox : new gpu::gles2::MailboxManager),
       image_manager_(new gpu::gles2::ImageManager),
       watchdog_(watchdog),
       software_(software),
       handle_messages_scheduled_(false),
       processed_get_state_fast_(false),
       currently_processing_message_(NULL),
-      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      a_stub_is_descheduled_(false) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
   disallowed_features_.multisampling =
       command_line->HasSwitch(switches::kDisableGLMultisampling);
 #if defined(OS_ANDROID)
   stream_texture_manager_.reset(new StreamTextureManagerAndroid(this));
@@ skipping 125 matching lines @@
   // not emptied here, which ensures that OnMessageReceived will continue to
   // defer newly received messages until the ones in the queue have all been
   // handled by HandleMessage. HandleMessage is invoked as a
   // task to prevent reentrancy.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&GpuChannel::HandleMessage, weak_factory_.GetWeakPtr()));
   handle_messages_scheduled_ = true;
 }
 
+void GpuChannel::StubSchedulingChanged() {
+  bool a_stub_is_descheduled = false;
+  for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
+       !it.IsAtEnd(); it.Advance()) {

[piman, 2013/02/27 21:54:43]

Could we count scheduled stubs? If we fix the callbacks so that this is called
exactly once for each change (see below), we can avoid walking the map every
time.

[jonathan.backer, 2013/02/28 21:43:56]

Done. I'm concerned about teardown. I think I've handled that appropriately in
OnDestroyCommandBuffer.

+    if (!it.GetCurrentValue()->IsScheduled()) {
+      a_stub_is_descheduled = true;
+      break;
+    }
+  }
+  if (a_stub_is_descheduled != a_stub_is_descheduled_) {
+    a_stub_is_descheduled_ = a_stub_is_descheduled;
+    if (preempting_flag_.get()) {
+      io_message_loop_->PostTask(
+          FROM_HERE,
+          base::Bind(&SyncPointMessageFilter::UpdateStubSchedulingState,
+                     filter_, a_stub_is_descheduled));
+    }
+  }
+}
+
 void GpuChannel::CreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& window,
     int32 surface_id,
     const GPUCreateCommandBufferConfig& init_params,
     int32* route_id) {
   TRACE_EVENT1("gpu",
                "GpuChannel::CreateViewCommandBuffer",
                "surface_id",
                surface_id);
 
@@ skipping 84 matching lines @@
 
 void GpuChannel::RemoveRoute(int32 route_id) {
   router_.RemoveRoute(route_id);
 }
 
 gpu::PreemptionFlag* GpuChannel::GetPreemptionFlag() {
   if (!preempting_flag_.get()) {
     preempting_flag_ = new gpu::PreemptionFlag;
     io_message_loop_->PostTask(
         FROM_HERE,
-        base::Bind(&SyncPointMessageFilter::SetPreemptingFlag,
-                   filter_, preempting_flag_));
+        base::Bind(&SyncPointMessageFilter::SetPreemptingFlagAndSchedulingState,
+                   filter_, preempting_flag_, a_stub_is_descheduled_));
   }
   return preempting_flag_.get();
 }
 
 void GpuChannel::SetPreemptByFlag(
     scoped_refptr<gpu::PreemptionFlag> preempted_flag) {
   preempted_flag_ = preempted_flag;
 
   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
        !it.IsAtEnd(); it.Advance()) {
@@ skipping 186 matching lines @@
   messages_processed_++;
   if (preempting_flag_.get()) {
     io_message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&SyncPointMessageFilter::MessageProcessed,
                    filter_, messages_processed_));
   }
 }
 
 }  // namespace content