cc: Heuristic for Renderer latency recovery

cc/scheduler/scheduler.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.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
@@ skipping 442 matching lines @@
       state_machine_.MainThreadIsInHighLatencyMode();
   TRACE_EVENT2("cc,benchmark", "Scheduler::BeginImplFrame", "args",
                args.AsValue(), "main_thread_is_high_latency",
                main_thread_is_in_high_latency_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "MainThreadLatency", main_thread_is_in_high_latency_mode);
 
   BeginFrameArgs adjusted_args = args;
   adjusted_args.deadline -= compositor_timing_history_->DrawDurationEstimate();
 
-  if (!state_machine_.impl_latency_takes_priority() &&
-      main_thread_is_in_high_latency_mode &&
-      CanCommitAndActivateBeforeDeadline()) {
+  if (ShouldRecoverMainLatency(adjusted_args)) {
+    TRACE_EVENT_INSTANT0("cc", "SkipBeginMainFrameToReduceLatency",
+                         TRACE_EVENT_SCOPE_THREAD);
     state_machine_.SetSkipNextBeginMainFrameToReduceLatency();
+  } else if (ShouldRecoverImplLatency(adjusted_args)) {
+    TRACE_EVENT_INSTANT0("cc", "SkipBeginImplFrameToReduceLatency",
+                         TRACE_EVENT_SCOPE_THREAD);
+    frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
+    return;
   }
 
   BeginImplFrame(adjusted_args);
 
   // The deadline will be scheduled in ProcessScheduledActions.
   state_machine_.OnBeginImplFrameDeadlinePending();
   ProcessScheduledActions();
 }
 
 void Scheduler::BeginImplFrameSynchronous(const BeginFrameArgs& args) {
@@ skipping 31 matching lines @@
 
 void Scheduler::ScheduleBeginImplFrameDeadline() {
   // The synchronous compositor does not post a deadline task.
   DCHECK(!settings_.using_synchronous_renderer_compositor);
 
   begin_impl_frame_deadline_task_.Cancel();
   begin_impl_frame_deadline_task_.Reset(begin_impl_frame_deadline_closure_);
 
   begin_impl_frame_deadline_mode_ =
       state_machine_.CurrentBeginImplFrameDeadlineMode();
-
   base::TimeTicks deadline;
   switch (begin_impl_frame_deadline_mode_) {
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_NONE:
       // No deadline.
       return;
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE:
       // We are ready to draw a new active tree immediately.
       // We don't use Now() here because it's somewhat expensive to call.
       deadline = base::TimeTicks();
       break;
@@ skipping 161 matching lines @@
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat> Scheduler::AsValue()
     const {
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
   AsValueInto(state.get());
   return state;
 }
 
 void Scheduler::AsValueInto(base::trace_event::TracedValue* state) const {
+  base::TimeTicks now = Now();
+
   state->BeginDictionary("state_machine");
   state_machine_.AsValueInto(state);
   state->EndDictionary();
 
   // Only trace frame sources when explicitly enabled - http://crbug.com/420607
   bool frame_tracing_enabled = false;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
       &frame_tracing_enabled);
   if (frame_tracing_enabled) {
     state->BeginDictionary("frame_source_");
     frame_source_->AsValueInto(state);
     state->EndDictionary();
   }
 
   state->BeginDictionary("scheduler_state");
   state->SetDouble("estimated_parent_draw_time_ms",
                    estimated_parent_draw_time_.InMillisecondsF());
   state->SetBoolean("last_set_needs_begin_frame_",
                     frame_source_->NeedsBeginFrames());
   state->SetInteger("begin_retro_frame_args",
                     static_cast<int>(begin_retro_frame_args_.size()));
   state->SetBoolean("begin_retro_frame_task",
                     !begin_retro_frame_task_.IsCancelled());
   state->SetBoolean("begin_impl_frame_deadline_task",
                     !begin_impl_frame_deadline_task_.IsCancelled());
   state->SetString("inside_action",
                    SchedulerStateMachine::ActionToString(inside_action_));
+
   state->BeginDictionary("begin_impl_frame_args");
-  begin_impl_frame_tracker_.AsValueInto(Now(), state);
+  begin_impl_frame_tracker_.AsValueInto(now, state);
   state->EndDictionary();
+
+  state->SetString("begin_impl_frame_deadline_mode_",
+                   SchedulerStateMachine::BeginImplFrameDeadlineModeToString(
+                       begin_impl_frame_deadline_mode_));
   state->EndDictionary();
 
   state->BeginDictionary("compositor_timing_history");
   compositor_timing_history_->AsValueInto(state);
   state->EndDictionary();
 }
 
 void Scheduler::UpdateCompositorTimingHistoryRecordingEnabled() {
   compositor_timing_history_->SetRecordingEnabled(
       state_machine_.HasInitializedOutputSurface() && state_machine_.visible());
 }
 
-bool Scheduler::CanCommitAndActivateBeforeDeadline() const {
-  BeginFrameArgs args =
-      begin_impl_frame_tracker_.DangerousMethodCurrentOrLast();
+bool Scheduler::ShouldRecoverMainLatency(const BeginFrameArgs& args) const {
+  DCHECK(!settings_.using_synchronous_renderer_compositor);
 
+  if (!state_machine_.MainThreadIsInHighLatencyMode())
+    return false;
+
+  // When prioritizing impl thread latency, we currently put the
+  // main thread in a high latency mode. Don't try to fight it.
+  if (state_machine_.impl_latency_takes_priority())
+    return false;
+
+  return CanCommitAndActivateBeforeDeadline(args);
+}
+
+bool Scheduler::ShouldRecoverImplLatency(const BeginFrameArgs& args) const {
+  DCHECK(!settings_.using_synchronous_renderer_compositor);
+
+  // If we are swap throttled at the BeginFrame, that means the impl thread is
+  // very likely in a high latency mode.
+  bool impl_thread_is_likely_high_latency = state_machine_.SwapThrottled();
+  if (!impl_thread_is_likely_high_latency)
+    return false;
+
+  // The deadline may be in the past if our draw time is too long.
+  bool frame_time_is_before_deadline = args.frame_time < args.deadline;
+
+  // When prioritizing impl thread latency, the deadline doesn't wait
+  // for the main thread.
+  if (state_machine_.impl_latency_takes_priority())
+    return frame_time_is_before_deadline;
+
+  // If we only have impl-side updates, the deadline doesn't wait for
+  // the main thread.
+  if (state_machine_.OnlyImplSideUpdatesExpected())
+    return frame_time_is_before_deadline;
+
+  // If the active tree hasn't been drawn at the BeginFrame, it means
+  // the main thread is in a high latency mode but was still
+  // fast enough to give us a new active tree before this BeginFrame.
+  if (state_machine_.active_tree_needs_first_draw())

[brianderson, 2015/07/09 05:44:06]

Hmm. I think there are a lot of issues with this case. I'm going to remove it
and leave hairy cases like this for future improvements. As a heuristic, I think
it's too aggressive and will skip frames we don't want to be skipped - for
example when the main thread is 30fps and impl thread is 60fps this decision
could oscillate too much.

[brianderson, 2015/07/09 17:55:37]

Removed.

+    return frame_time_is_before_deadline;
+
+  // If we get here, we know the main thread is in a low-latency mode relative
+  // to the impl thread. In this case, only try to also recover impl thread
+  // latency if both the main and impl threads can run serially before the
+  // deadline.
+  return CanCommitAndActivateBeforeDeadline(args);
+}
+
+bool Scheduler::CanCommitAndActivateBeforeDeadline(
+    const BeginFrameArgs& args) const {
   // Check if the main thread computation and commit can be finished before the
   // impl thread's deadline.
   base::TimeTicks estimated_draw_time =
       args.frame_time +
       compositor_timing_history_->BeginMainFrameToCommitDurationEstimate() +
       compositor_timing_history_->CommitToReadyToActivateDurationEstimate() +
       compositor_timing_history_->ActivateDurationEstimate();
 
-  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
-               "CanCommitAndActivateBeforeDeadline",
-               "time_left_after_drawing_ms",
-               (args.deadline - estimated_draw_time).InMillisecondsF(), "state",
-               AsValue());
-
   return estimated_draw_time < args.deadline;
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT ||
           state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED);
 }
 
 }  // namespace cc