Create a new action triggered when a BeginMainFrame is not expected before vsync

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 27 matching lines @@
       commit_count_(0),
       current_frame_number_(0),
       last_frame_number_submit_performed_(-1),
       last_frame_number_draw_performed_(-1),
       last_frame_number_begin_main_frame_sent_(-1),
       last_frame_number_invalidate_compositor_frame_sink_performed_(-1),
       draw_funnel_(false),
       send_begin_main_frame_funnel_(true),
       invalidate_compositor_frame_sink_funnel_(false),
       impl_side_invalidation_funnel_(false),
+      do_idle_work_funnel_(false),
       prepare_tiles_funnel_(0),
       consecutive_checkerboard_animations_(0),
       pending_submit_frames_(0),
       submit_frames_with_current_compositor_frame_sink_(0),
       needs_redraw_(false),
       needs_prepare_tiles_(false),
       needs_begin_main_frame_(false),
       needs_one_begin_impl_frame_(false),
       visible_(false),
       begin_frame_source_paused_(false),
@@ skipping 129 matching lines @@
     case ACTION_DRAW_ABORT:
       return "ACTION_DRAW_ABORT";
     case ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION:
       return "ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION";
     case ACTION_PREPARE_TILES:
       return "ACTION_PREPARE_TILES";
     case ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK:
       return "ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK";
     case ACTION_PERFORM_IMPL_SIDE_INVALIDATION:
       return "ACTION_PERFORM_IMPL_SIDE_INVALIDATION";
+    case ACTION_DO_IDLE_WORK:
+      return "ACTION_DO_IDLE_WORK";
   }
   NOTREACHED();
   return "???";
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 SchedulerStateMachine::AsValue() const {
   std::unique_ptr<base::trace_event::TracedValue> state(
       new base::trace_event::TracedValue());
   AsValueInto(state.get());
@@ skipping 32 matching lines @@
   state->SetInteger("last_begin_frame_sequence_number_pending_tree_was_fresh",
                     last_begin_frame_sequence_number_pending_tree_was_fresh_);
   state->SetInteger("last_begin_frame_sequence_number_active_tree_was_fresh",
                     last_begin_frame_sequence_number_active_tree_was_fresh_);
   state->SetInteger(
       "last_begin_frame_sequence_number_compositor_frame_was_fresh",
       last_begin_frame_sequence_number_compositor_frame_was_fresh_);
   state->SetBoolean("funnel: draw_funnel", draw_funnel_);
   state->SetBoolean("funnel: send_begin_main_frame_funnel",
                     send_begin_main_frame_funnel_);
+  state->SetBoolean("funnel: do_idle_work_funnel", do_idle_work_funnel_);
   state->SetInteger("funnel: prepare_tiles_funnel", prepare_tiles_funnel_);
   state->SetBoolean("funnel: invalidate_compositor_frame_sink_funnel",
                     invalidate_compositor_frame_sink_funnel_);
   state->SetBoolean("funnel: impl_side_invalidation_funnel",
                     impl_side_invalidation_funnel_);
   state->SetInteger("consecutive_checkerboard_animations",
                     consecutive_checkerboard_animations_);
   state->SetInteger("pending_submit_frames_", pending_submit_frames_);
   state->SetInteger("submit_frames_with_current_compositor_frame_sink",
                     submit_frames_with_current_compositor_frame_sink_);
@@ skipping 162 matching lines @@
     return false;
 
   // If we want to force activation, do so ASAP.
   if (PendingActivationsShouldBeForced())
     return true;
 
   // At this point, only activate if we are ready to activate.
   return pending_tree_is_ready_for_activation_;
 }
 
+bool SchedulerStateMachine::CouldDoIdleWork() const {
+  if (needs_begin_main_frame_ || send_begin_main_frame_funnel_)

[Dan Elphick, 2017/03/21 11:23:51]

I made this change here because needs_begin_main_frame gets reset after it's
handled. So essentially we'd get idle work after every main frame.

I've tested the two cases we had though and they still work after this change.

[Sami, 2017/03/21 11:35:21]

I wonder if we should look at begin_main_frame_state_ instead? What states does
it cycle through? Basically we want to avoid doing any extra idle work if
there's a BeginMainFrame in any part of the pipeline I think (perhaps that means
we should look at pending trees too)

[Sami, 2017/03/21 11:36:39]

Just to clarify: the problem with looking at the funnel is that it's really a
rate limiting mechanism for BeginMainFrames, and if we decide to allow more
BeginMainFrames in the future it wouldn't be sufficient here anymore.

[Dan Elphick, 2017/03/21 15:56:25]

I've renamed the funnel as discussed in comments elsewhere.

+    return false;
+
+  // We can not perform commits if we are not visible.
+  if (!visible_)
+    return false;
+
+  // There are no BeginImplFrames while BeginFrameSource is paused,
+  // so should also stop BeginMainFrames.
+  if (begin_frame_source_paused_)
+    return false;
+
+  // Do not make a new commits when it is deferred.
+  if (defer_commits_)
+    return false;
+
+  return true;
+}
+
+bool SchedulerStateMachine::ShouldDoIdleWork() const {
+  if (!CouldDoIdleWork())
+    return false;
+
+  // Do not do idle work too many times in a single frame or before
+  // the first BeginFrame.
+  if (do_idle_work_funnel_)
+    return false;
+
+  // Only send BeginMainFrame when there isn't another commit pending already.
+  // Other parts of the state machine indirectly defer the BeginMainFrame
+  // by transitioning to WAITING commit states rather than going
+  // immediately to IDLE.
+  if (begin_main_frame_state_ != BEGIN_MAIN_FRAME_STATE_IDLE)
+    return false;
+
+  // MFBA is disabled and we are waiting for previous activation.
+  if (!settings_.main_frame_before_activation_enabled && has_pending_tree_)
+    return false;
+
+  // We are waiting for previous frame to be drawn, submitted and acked.
+  if (settings_.commit_to_active_tree &&
+      (active_tree_needs_first_draw_ || IsDrawThrottled())) {
+    return false;
+  }
+
+  // Don't send BeginMainFrame early if we are prioritizing the active tree
+  // because of ImplLatencyTakesPriority.
+  if (ImplLatencyTakesPriority() &&
+      (has_pending_tree_ || active_tree_needs_first_draw_)) {
+    return false;
+  }
+
+  // We should not send BeginMainFrame while we are in the idle state since we
+  // might have new user input arriving soon. It's okay to send BeginMainFrame
+  // for the synchronous compositor because the main thread is always high
+  // latency in that case.
+  // TODO(brianderson): Allow sending BeginMainFrame while idle when the main
+  // thread isn't consuming user input for non-synchronous compositor.
+  if (!settings_.using_synchronous_renderer_compositor &&
+      begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_IDLE) {
+    return false;
+  }
+
+  // We need a new commit for the forced redraw. This honors the
+  // single commit per interval because the result will be swapped to screen.
+  if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_COMMIT)
+    return true;
+
+  // We shouldn't normally accept commits if there isn't an CompositorFrameSink.
+  if (!HasInitializedCompositorFrameSink())
+    return false;
+
+  if (!settings_.main_frame_while_submit_frame_throttled_enabled) {
+    // Throttle the BeginMainFrames on CompositorFrameAck unless we just
+    // submitted a frame to potentially improve impl-thread latency over
+    // main-thread throughput.
+    // TODO(brianderson): Remove this restriction to improve throughput or
+    // make it conditional on ImplLatencyTakesPriority.
+    bool just_submitted_in_deadline =
+        begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
+        did_submit_in_last_frame_;
+    if (IsDrawThrottled() && !just_submitted_in_deadline)
+      return false;
+  }
+
+  if (skip_next_begin_main_frame_to_reduce_latency_)
+    return false;
+
+  return true;
+}
+
 bool SchedulerStateMachine::CouldSendBeginMainFrame() const {
   if (!needs_begin_main_frame_)
     return false;
 
   // We can not perform commits if we are not visible.
   if (!visible_)
     return false;
 
   // There are no BeginImplFrames while BeginFrameSource is paused,
   // so should also stop BeginMainFrames.
@@ skipping 146 matching lines @@
       return ACTION_DRAW_FORCED;
     else
       return ACTION_DRAW_IF_POSSIBLE;
   }
   if (ShouldPerformImplSideInvalidation())
     return ACTION_PERFORM_IMPL_SIDE_INVALIDATION;
   if (ShouldPrepareTiles())
     return ACTION_PREPARE_TILES;
   if (ShouldSendBeginMainFrame())
     return ACTION_SEND_BEGIN_MAIN_FRAME;
+  if (ShouldDoIdleWork())
+    return ACTION_DO_IDLE_WORK;
   if (ShouldInvalidateCompositorFrameSink())
     return ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK;
   if (ShouldBeginCompositorFrameSinkCreation())
     return ACTION_BEGIN_COMPOSITOR_FRAME_SINK_CREATION;
   return ACTION_NONE;
 }
 
 bool SchedulerStateMachine::ShouldPerformImplSideInvalidation() const {
   if (!needs_impl_side_invalidation_)
     return false;
@@ skipping 78 matching lines @@
   DCHECK(!begin_frame_source_paused_);
   DCHECK(!send_begin_main_frame_funnel_);
   begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_SENT;
   needs_begin_main_frame_ = false;
   send_begin_main_frame_funnel_ = true;
   last_frame_number_begin_main_frame_sent_ = current_frame_number_;
   last_begin_frame_sequence_number_begin_main_frame_sent_ =
       begin_frame_sequence_number_;
 }
 
+void SchedulerStateMachine::WillDoIdleWork() {
+  DCHECK(!has_pending_tree_ || settings_.main_frame_before_activation_enabled);
+  DCHECK(visible_);
+  DCHECK(!begin_frame_source_paused_);
+  DCHECK(!do_idle_work_funnel_);
+  do_idle_work_funnel_ = true;
+}
+
 void SchedulerStateMachine::WillCommit(bool commit_has_no_updates) {
   bool can_have_pending_tree =
       commit_has_no_updates &&
       (settings_.main_frame_before_activation_enabled ||
        current_pending_tree_is_impl_side_);
   DCHECK(!has_pending_tree_ || can_have_pending_tree);
   commit_count_++;
   last_commit_had_no_updates_ = commit_has_no_updates;
   begin_main_frame_state_ = BEGIN_MAIN_FRAME_STATE_IDLE;
 
@@ skipping 335 matching lines @@
 
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME;
   current_frame_number_++;
 
   last_commit_had_no_updates_ = false;
   did_draw_in_last_frame_ = false;
   did_submit_in_last_frame_ = false;
   needs_one_begin_impl_frame_ = false;
 
   // Clear funnels for any actions we perform during the frame.
+  do_idle_work_funnel_ = false;
   send_begin_main_frame_funnel_ = false;
   invalidate_compositor_frame_sink_funnel_ = false;
   impl_side_invalidation_funnel_ = false;
 
   // "Drain" the PrepareTiles funnel.
   if (prepare_tiles_funnel_ > 0)
     prepare_tiles_funnel_--;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadline() {
@@ skipping 275 matching lines @@
     case COMPOSITOR_FRAME_SINK_ACTIVE:
     case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT:
     case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc