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),
+      was_swap_throttled_on_begin_impl_frame_(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),
       did_create_and_initialize_first_output_surface_(false),
       impl_latency_takes_priority_(false),
       skip_next_begin_main_frame_to_reduce_latency_(false),
-      skip_begin_main_frame_to_reduce_latency_(false),
+      skip_next_swap_to_reduce_latency_(false),
       continuous_painting_(false),
       children_need_begin_frames_(false),
       defer_commits_(false),
       video_needs_begin_frames_(false),
       last_commit_had_no_updates_(false),
       wait_for_active_tree_ready_to_draw_(false),
       did_request_swap_in_last_frame_(false),
       did_perform_swap_in_last_draw_(false) {
 }
 
@@ skipping 169 matching lines @@
   state->SetBoolean("active_tree_needs_first_draw",
                     active_tree_needs_first_draw_);
   state->SetBoolean("wait_for_active_tree_ready_to_draw",
                     wait_for_active_tree_ready_to_draw_);
   state->SetBoolean("did_create_and_initialize_first_output_surface",
                     did_create_and_initialize_first_output_surface_);
   state->SetBoolean("impl_latency_takes_priority",
                     impl_latency_takes_priority_);
   state->SetBoolean("main_thread_is_in_high_latency_mode",
                     MainThreadIsInHighLatencyMode());
-  state->SetBoolean("skip_begin_main_frame_to_reduce_latency",
-                    skip_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
                     skip_next_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("continuous_painting", continuous_painting_);
   state->SetBoolean("children_need_begin_frames", children_need_begin_frames_);
   state->SetBoolean("video_needs_begin_frames", video_needs_begin_frames_);
   state->SetBoolean("defer_commits", defer_commits_);
   state->SetBoolean("last_commit_had_no_updates", last_commit_had_no_updates_);
   state->SetBoolean("did_request_swap_in_last_frame",
                     did_request_swap_in_last_frame_);
   state->SetBoolean("did_perform_swap_in_last_draw",
@@ skipping 85 matching lines @@
 
   // Do not queue too many swaps.
   if (pending_swaps_ >= max_pending_swaps_)
     return false;
 
   // Except for the cases above, do not draw outside of the BeginImplFrame
   // deadline.
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
     return false;
 
+  // We are intentionally skipping this swap to reduce our latency.
+  if (skip_next_swap_to_reduce_latency_)
+    return false;
+
   // Only handle forced redraws due to timeouts on the regular deadline.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
     return true;
 
   return needs_redraw_;
 }
 
 bool SchedulerStateMachine::ShouldActivatePendingTree() const {
   // There is nothing to activate.
   if (!has_pending_tree_)
@@ skipping 82 matching lines @@
     return false;
 
   // SwapAck throttle the BeginMainFrames unless we just swapped.
   // TODO(brianderson): Remove this restriction to improve throughput.
   bool just_swapped_in_deadline =
       begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
       did_perform_swap_in_last_draw_;
   if (pending_swaps_ >= max_pending_swaps_ && !just_swapped_in_deadline)
     return false;
 
-  if (skip_begin_main_frame_to_reduce_latency_)
+  if (skip_next_begin_main_frame_to_reduce_latency_)
     return false;
 
   return true;
 }
 
 bool SchedulerStateMachine::ShouldCommit() const {
   if (commit_state_ != COMMIT_STATE_READY_TO_COMMIT)
     return false;
 
   // We must not finish the commit until the pending tree is free.
@@ skipping 259 matching lines @@
   active_tree_needs_first_draw_ = false;  // blocks commit if true
 }
 
 void SchedulerStateMachine::SetSkipNextBeginMainFrameToReduceLatency() {
   TRACE_EVENT_INSTANT0("cc",
                        "Scheduler: SkipNextBeginMainFrameToReduceLatency",
                        TRACE_EVENT_SCOPE_THREAD);
   skip_next_begin_main_frame_to_reduce_latency_ = true;
 }
 
+void SchedulerStateMachine::SetSkipNextSwapToReduceLatency() {
+  TRACE_EVENT_INSTANT0("cc", "Scheduler: SetSkipNextSwapToReduceLatency",
+                       TRACE_EVENT_SCOPE_THREAD);
+  // We need to skip both the BeginMainFrame and swap to make sure we
+  // don't keep stuffing the pipeline.
+  skip_next_swap_to_reduce_latency_ = true;
+  skip_next_begin_main_frame_to_reduce_latency_ = true;
+
+  // If there are no swap ack's pending to update swaps_are_likely_high_latency
+  // later, reset it now.
+  // TODO(brianderson): A unittest that fails without this.
+  if (!pending_swaps_)

[sunnyps, 2015/05/21 23:42:23]

nit: Don't use boolean operators on numeric types.

[brianderson, 2015/05/22 01:12:53]

Done.

+    swaps_are_likely_high_latency_ = false;
+}
+
 bool SchedulerStateMachine::BeginFrameRequiredForChildren() const {
   return children_need_begin_frames_;
 }
 bool SchedulerStateMachine::BeginFrameNeededForVideo() const {
   return video_needs_begin_frames_;
 }
 
 bool SchedulerStateMachine::BeginFrameNeeded() const {
   // We can't handle BeginFrames when output surface isn't initialized.
   // TODO(brianderson): Support output surface creation inside a BeginFrame.
@@ skipping 87 matching lines @@
 
   // Clear funnels for any actions we perform during the frame.
   animate_funnel_ = false;
   send_begin_main_frame_funnel_ = false;
   invalidate_output_surface_funnel_ = false;
 
   // "Drain" the PrepareTiles funnel.
   if (prepare_tiles_funnel_ > 0)
     prepare_tiles_funnel_--;
 
-  skip_begin_main_frame_to_reduce_latency_ =
-      skip_next_begin_main_frame_to_reduce_latency_;
+  was_swap_throttled_on_begin_impl_frame_ =
+      pending_swaps_ >= max_pending_swaps_;
+  swaps_are_likely_high_latency_ =
+      swaps_are_likely_high_latency_ || was_swap_throttled_on_begin_impl_frame_;
+
   skip_next_begin_main_frame_to_reduce_latency_ = false;
+  skip_next_swap_to_reduce_latency_ = false;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadlinePending() {
   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;
@@ skipping 25 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;
 
+  // We aren't going to draw in the deadline if we want to reduce our latency,
+  // so we might as well trigger the deadline immediately.
+  if (skip_next_swap_to_reduce_latency_)
+    return true;
+
   // SwapAck throttle the deadline since we wont draw and swap anyway.
   if (pending_swaps_ >= max_pending_swaps_)
     return false;
 
   if (active_tree_needs_first_draw_)
     return true;
 
   if (!needs_redraw_)
     return false;
 
@@ skipping 83 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_--;
+
+  // If we just skipped a swap, assume the attempt to reduce latency
+  // was successful.
+  swaps_are_likely_high_latency_ = was_swap_throttled_on_begin_impl_frame_ &&
+                                   !skip_next_swap_to_reduce_latency_;
 }
 
 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