cc: Heuristic for Renderer latency recovery

cc/scheduler/scheduler_state_machine.cc

 // Copyright 2011 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 "cc/scheduler/scheduler_state_machine.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 17 matching lines @@
       last_frame_number_begin_main_frame_sent_(-1),
       last_frame_number_invalidate_output_surface_performed_(-1),
       animate_funnel_(false),
       request_swap_funnel_(false),
       send_begin_main_frame_funnel_(false),
       invalidate_output_surface_funnel_(false),
       prepare_tiles_funnel_(0),
       consecutive_checkerboard_animations_(0),
       max_pending_swaps_(1),
       pending_swaps_(0),
+      swaps_are_likely_high_latency_(false),
+      swap_throttled_in_last_deadline_(false),
       needs_redraw_(false),
       needs_animate_(false),
       needs_prepare_tiles_(false),
       needs_commit_(false),
       visible_(false),
       can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
       pending_tree_is_ready_for_activation_(false),
       active_tree_needs_first_draw_(false),
@@ skipping 763 matching lines @@
     return true;
 
   // If the last commit was aborted because of early out (no updates), we should
   // still want a begin frame in case there is a commit coming again.
   if (last_commit_had_no_updates_)
     return true;
 
   return false;
 }
 
+void SchedulerStateMachine::DidSkipBeginImplFrameToReduceLatency() {
+  // If there are no swap ack's pending to update swaps_are_likely_high_latency
+  // later, reset it now.
+  if (!pending_swaps_)
+    swaps_are_likely_high_latency_ = false;
+}
+
 void SchedulerStateMachine::OnBeginImplFrame() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING;
   current_frame_number_++;
 
   last_commit_had_no_updates_ = false;
   did_request_swap_in_last_frame_ = false;
 
   // Clear funnels for any actions we perform during the frame.
   animate_funnel_ = false;
   send_begin_main_frame_funnel_ = false;
@@ skipping 12 matching lines @@
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadline() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE;
 
   did_perform_swap_in_last_draw_ = false;
 
   // Clear funnels for any actions we perform during the deadline.
   request_swap_funnel_ = false;
+
+  swap_throttled_in_last_deadline_ = pending_swaps_ >= max_pending_swaps_;
+  swaps_are_likely_high_latency_ =
+      swaps_are_likely_high_latency_ || swap_throttled_in_last_deadline_;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameIdle() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_IDLE;
 }
 
 SchedulerStateMachine::BeginImplFrameDeadlineMode
 SchedulerStateMachine::CurrentBeginImplFrameDeadlineMode() const {
   if (settings_.using_synchronous_renderer_compositor) {
     // No deadline for synchronous compositor.
@@ skipping 12 matching lines @@
   } else {
     // The impl thread doesn't have anything it wants to draw and we are just
     // waiting for a new active tree or we are swap throttled. In short we are
     // blocked.
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE;
   }
 }
 
 bool SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineImmediately()
     const {
-  // TODO(brianderson): This should take into account multiple commit sources.
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)
     return false;
 
   // If we just forced activation, we should end the deadline right now.
   if (PendingActivationsShouldBeForced() && !has_pending_tree_)
     return true;
 
   // SwapAck throttle the deadline since we wont draw and swap anyway.
   if (pending_swaps_ >= max_pending_swaps_)
     return false;
@@ skipping 90 matching lines @@
   pending_swaps_++;
   DCHECK_LE(pending_swaps_, max_pending_swaps_);
 
   did_perform_swap_in_last_draw_ = true;
   last_frame_number_swap_performed_ = current_frame_number_;
 }
 
 void SchedulerStateMachine::DidSwapBuffersComplete() {
   DCHECK_GT(pending_swaps_, 0);
   pending_swaps_--;
+
+  swaps_are_likely_high_latency_ =
+      begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME ||

[sunnyps, 2015/05/12 00:36:25]

I don't understand what the frame state has to do with the renderer being in
high latency mode. Consider a renderer that always goes for an immediate
deadline at the beginning of the frame. In that case DidSwapBuffersComplete will
almost always come in while the state is IDLE. That doesn't imply that we're not
in high latency mode.

[brianderson, 2015/05/12 19:25:17]

Regarding frame state:
The code is hard to follow. I think I can use an alternative approach that is
easier to follow by using a swap_throttled_at_last_on_begin_impl_frame_ instead
of a swap_throttled_in_last_deadline like the current code does. That would
remove the need to look at the begin_impl_frame_state here.

Regarding your specific concern:
The immediate deadline case is covered by the swap_throttled_in_last_deadline
logic above, which is used to differentiate between a DidSwapBuffersComplete
that came back quickly vs. one that came after the next BeginFrame's deadline
since the state is IDLE in both cases.
swap_throttled_at_last_on_begin_impl_frame_ could serve the same purpose.

+      swap_throttled_in_last_deadline_;
 }
 
 void SchedulerStateMachine::SetImplLatencyTakesPriority(
     bool impl_latency_takes_priority) {
   impl_latency_takes_priority_ = impl_latency_takes_priority;
 }
 
 void SchedulerStateMachine::DidDrawIfPossibleCompleted(DrawResult result) {
   switch (result) {
     case INVALID_RESULT:
@@ skipping 132 matching lines @@
       static_cast<int>(begin_impl_frame_state_),
       static_cast<int>(commit_state_),
       has_pending_tree_ ? 'T' : 'F',
       pending_tree_is_ready_for_activation_ ? 'T' : 'F',
       active_tree_needs_first_draw_ ? 'T' : 'F',
       max_pending_swaps_,
       pending_swaps_);
 }
 
 }  // namespace cc