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) {
+    a_stub_is_descheduled_ = a_stub_is_descheduled;
+    UpdatePreemptionState();
   }
 
  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 (i.e. no stub is descheduled).
     PREEMPTING,
+    // We would like to preempt, but some stub is descheduled.
+    WOULD_PREEMPT_DESCHEDULED,
   };
 
   PreemptionState preemption_state_;
 
+  // Maximum amount of time that we can spend in PREEMPTING.
+  // It is reset when we transition to IDLE.
+  base::TimeDelta max_preemption_time_;
+
   struct PendingMessage {
     uint64 message_number;
     base::TimeTicks time_received;
 
     explicit PendingMessage(uint64 message_number)
         : message_number(message_number),
           time_received(base::TimeTicks::Now()) {
     }
   };
 
@@ skipping 12 matching lines @@
           base::TimeDelta time_elapsed =
               base::TimeTicks::Now() - pending_messages_.front().time_received;
           if (time_elapsed.InMilliseconds() < kPreemptWaitTimeMs) {
             // Schedule another check for when the IPC may go long.
             timer_.Start(
                 FROM_HERE,
                 base::TimeDelta::FromMilliseconds(kPreemptWaitTimeMs) -
                     time_elapsed,
                 this, &SyncPointMessageFilter::UpdatePreemptionState);
           } else {
-            TransitionToPreempting();
+            if (a_stub_is_descheduled_)
+              TransitionToWouldPreemptDescheduled();
+            else
+              TransitionToPreempting();
           }
         }
         break;
       case PREEMPTING:
-        if (pending_messages_.empty()) {
-          TransitionToIdle();
-        } else {
-          base::TimeDelta time_elapsed =
-              base::TimeTicks::Now() - pending_messages_.front().time_received;
-          if (time_elapsed.InMilliseconds() < kStopPreemptThresholdMs)
-            TransitionToIdle();
-        }
+        // A TransitionToIdle() timer should always be running in this state.
+        DCHECK(timer_.IsRunning());
+        if (a_stub_is_descheduled_)
+          TransitionToWouldPreemptDescheduled();
+        else
+          TransitionToIdleIfCaughtUp();
+        break;
+      case WOULD_PREEMPT_DESCHEDULED:
+        // A TransitionToIdle() timer should never be running in this state.
+        DCHECK(!timer_.IsRunning());
+        if (!a_stub_is_descheduled_)
+          TransitionToPreempting();
+        else
+          TransitionToIdleIfCaughtUp();
         break;
       default:
         NOTREACHED();
     }
   }
 
+  void TransitionToIdleIfCaughtUp() {
+    DCHECK(preemption_state_ == PREEMPTING ||
+           preemption_state_ == WOULD_PREEMPT_DESCHEDULED);
+    if (pending_messages_.empty()) {
+      TransitionToIdle();
+    } else {
+      base::TimeDelta time_elapsed =
+          base::TimeTicks::Now() - pending_messages_.front().time_received;
+      if (time_elapsed.InMilliseconds() < kStopPreemptThresholdMs)
+        TransitionToIdle();
+    }
+  }
+
   void TransitionToIdle() {
-    DCHECK_EQ(preemption_state_, PREEMPTING);
+    DCHECK(preemption_state_ == PREEMPTING ||
+           preemption_state_ == WOULD_PREEMPT_DESCHEDULED);
     // Stop any outstanding timer set to force us from PREEMPTING to IDLE.
     timer_.Stop();
 
     preemption_state_ = IDLE;
     preempting_flag_->Reset();
     TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 0);
 
     UpdatePreemptionState();
   }
 
   void TransitionToWaiting() {
     DCHECK_EQ(preemption_state_, IDLE);
     DCHECK(!timer_.IsRunning());
 
     preemption_state_ = WAITING;
     timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kPreemptWaitTimeMs),
         this, &SyncPointMessageFilter::TransitionToChecking);
   }
 
   void TransitionToChecking() {
     DCHECK_EQ(preemption_state_, WAITING);
     DCHECK(!timer_.IsRunning());
 
     preemption_state_ = CHECKING;
+    max_preemption_time_ = base::TimeDelta::FromMilliseconds(kMaxPreemptTimeMs);
     UpdatePreemptionState();
   }
 
   void TransitionToPreempting() {
-    DCHECK_EQ(preemption_state_, CHECKING);
+    DCHECK(preemption_state_ == CHECKING ||
+           preemption_state_ == WOULD_PREEMPT_DESCHEDULED);
+    DCHECK(!a_stub_is_descheduled_);
 
     // Stop any pending state update checks that we may have queued
     // while CHECKING.
-    timer_.Stop();
+    if (preemption_state_ == CHECKING)
+      timer_.Stop();
 
     preemption_state_ = PREEMPTING;
     preempting_flag_->Set();
     TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 1);
 
     timer_.Start(
        FROM_HERE,
-       base::TimeDelta::FromMilliseconds(kMaxPreemptTimeMs),
+       max_preemption_time_,
        this, &SyncPointMessageFilter::TransitionToIdle);
 
     UpdatePreemptionState();
   }
 
+  void TransitionToWouldPreemptDescheduled() {
+    DCHECK(preemption_state_ == CHECKING ||
+           preemption_state_ == PREEMPTING);
+    DCHECK(a_stub_is_descheduled_);
+
+    if (preemption_state_ == CHECKING) {
+      // Stop any pending state update checks that we may have queued
+      // while CHECKING.
+      timer_.Stop();
+    } else {
+      // Stop any TransitionToIdle() timers that we may have queued
+      // while PREEMPTING.
+      timer_.Stop();
+      max_preemption_time_ = timer_.desired_run_time() - base::TimeTicks::Now();
+      if (max_preemption_time_ < base::TimeDelta()) {
+        TransitionToIdle();
+        return;
+      }
+    }
+
+    preemption_state_ = WOULD_PREEMPT_DESCHEDULED;
+    preempting_flag_->Reset();
+    TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 0);
+
+    UpdatePreemptionState();
+  }
+
   static void InsertSyncPointOnMainThread(
       base::WeakPtr<GpuChannel>* gpu_channel,
       scoped_refptr<SyncPointManager> manager,
       int32 routing_id,
       uint32 sync_point) {
     // This function must ensure that the sync point will be retired. Normally
     // we'll find the stub based on the routing ID, and associate the sync point
     // with it, but if that fails for any reason (channel or stub already
     // deleted, invalid routing id), we need to retire the sync point
     // immediately.
@@ skipping 25 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)),
+      num_stubs_descheduled_(0) {
   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 scheduled) {
+  bool a_stub_was_descheduled = num_stubs_descheduled_ > 0;
+  if (scheduled) {
+    num_stubs_descheduled_--;
+    OnScheduled();
+  } else {
+    num_stubs_descheduled_++;
+  }
+  DCHECK_LE(num_stubs_descheduled_, stubs_.size());
+  bool a_stub_is_descheduled = num_stubs_descheduled_ > 0;
+
+  if (a_stub_is_descheduled != a_stub_was_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_, num_stubs_descheduled_ > 0));
   }
   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 128 matching lines @@
   TRACE_EVENT1("gpu", "GpuChannel::OnDestroyCommandBuffer",
                "route_id", route_id);
 
   if (router_.ResolveRoute(route_id)) {
     GpuCommandBufferStub* stub = stubs_.Lookup(route_id);
     bool need_reschedule = (stub && !stub->IsScheduled());
     router_.RemoveRoute(route_id);
     stubs_.Remove(route_id);
     // In case the renderer is currently blocked waiting for a sync reply from
     // the stub, we need to make sure to reschedule the GpuChannel here.
-    if (need_reschedule)
-      OnScheduled();
+    if (need_reschedule) {
+      // This stub won't get a chance to reschedule, so update the count
+      // now.
+      StubSchedulingChanged(true);
+    }
   }
 }
 
 #if defined(OS_ANDROID)
 void GpuChannel::OnRegisterStreamTextureProxy(
     int32 stream_id,  const gfx::Size& initial_size, int32* route_id) {
   // Note that route_id is only used for notifications sent out from here.
   // StreamTextureManager owns all texture objects and for incoming messages
   // it finds the correct object based on stream_id.
   *route_id = GenerateRouteID();
@@ skipping 36 matching lines @@
   messages_processed_++;
   if (preempting_flag_.get()) {
     io_message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&SyncPointMessageFilter::MessageProcessed,
                    filter_, messages_processed_));
   }
 }
 
 }  // namespace content