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 111 matching lines @@
 
 base::TimeTicks Scheduler::Now() const {
   base::TimeTicks now = gfx::FrameTime::Now();
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.now"),
                "Scheduler::Now",
                "now",
                now);
   return now;
 }
 
+void Scheduler::SetAuthoritativeVSyncInterval(const base::TimeDelta& interval) {
+  authoritative_vsync_interval_ = interval;
+  if (vsync_observer_)
+    vsync_observer_->OnUpdateVSyncParameters(last_vsync_timebase_, interval);
+}
+
 void Scheduler::CommitVSyncParameters(base::TimeTicks timebase,
                                       base::TimeDelta interval) {
+  TRACE_EVENT2("cc", "Scheduler::CommitVSyncParameters", "timebase",
+               (timebase - base::TimeTicks()).InSecondsF(), "interval",
+               interval.InSecondsF());
+
   if (authoritative_vsync_interval_ != base::TimeDelta()) {
     interval = authoritative_vsync_interval_;
   } else if (interval == base::TimeDelta()) {
     // TODO(brianderson): We should not be receiving 0 intervals.
     interval = BeginFrameArgs::DefaultInterval();
   }
 
   last_vsync_timebase_ = timebase;
 
   if (vsync_observer_)
@@ skipping 236 matching lines @@
     BeginImplFrameWithDeadline(adjusted_args);
   }
   return true;
 }
 
 void Scheduler::SetChildrenNeedBeginFrames(bool children_need_begin_frames) {
   state_machine_.SetChildrenNeedBeginFrames(children_need_begin_frames);
   ProcessScheduledActions();
 }
 
-void Scheduler::SetAuthoritativeVSyncInterval(const base::TimeDelta& interval) {
-  authoritative_vsync_interval_ = interval;
-  if (vsync_observer_)
-    vsync_observer_->OnUpdateVSyncParameters(last_vsync_timebase_, interval);
-}
-
 void Scheduler::SetVideoNeedsBeginFrames(bool video_needs_begin_frames) {
   state_machine_.SetVideoNeedsBeginFrames(video_needs_begin_frames);
   ProcessScheduledActions();
 }
 
 void Scheduler::OnDrawForOutputSurface() {
   DCHECK(settings_.using_synchronous_renderer_compositor);
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   DCHECK(!BeginImplFrameDeadlinePending());
@@ skipping 85 matching lines @@
                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);
 
   advance_commit_state_task_.Cancel();
 
   begin_impl_frame_args_ = args;
   begin_impl_frame_args_.deadline -= client_->DrawDurationEstimate();
 
+  // Prioritize skipping the main thread's latency first so we can keep the
+  // main and impl threads synchronized. Then skip an impl frame if it makes
+  // sense. This avoids skipping both at the same time to avoid strange
+  // interactions/oscillations since CanDrawBeforeDeadline() depends on
+  // whether the main thread is in a high latency mode or not.
   if (!state_machine_.impl_latency_takes_priority() &&
       main_thread_is_in_high_latency_mode &&
       CanCommitAndActivateBeforeDeadline()) {
     state_machine_.SetSkipNextBeginMainFrameToReduceLatency();
+  } else if (CanDrawBeforeDeadline() &&
+             state_machine_.swaps_are_likely_high_latency()) {
+    // Skip this BeginImplFrame by returning early.
+    state_machine_.DidSkipBeginImplFrameToReduceLatency();
+    return;

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

BeginFrameSource::DidFinishFrame needs to be called if we're finishing the frame
here.

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

Ah, good catch!

I should make sure this logic interacts well with the
BackToBackBeginFrameSource.

   }
 
   BeginImplFrame();
 
   // The deadline will be scheduled in ProcessScheduledActions.
   state_machine_.OnBeginImplFrameDeadlinePending();
   ProcessScheduledActions();
 }
 
 void Scheduler::BeginImplFrameSynchronous(const BeginFrameArgs& args) {
@@ skipping 291 matching lines @@
 bool Scheduler::CanCommitAndActivateBeforeDeadline() const {
   // Check if the main thread computation and commit can be finished before the
   // impl thread's deadline.
   base::TimeTicks estimated_draw_time =
       begin_impl_frame_args_.frame_time +
       client_->BeginMainFrameToCommitDurationEstimate() +
       client_->CommitToActivateDurationEstimate();
 
   TRACE_EVENT2(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
-      "CanCommitAndActivateBeforeDeadline",
-      "time_left_after_drawing_ms",
+      "CanCommitAndActivateBeforeDeadline", "est_time_left_after_drawing_ms",
       (begin_impl_frame_args_.deadline - estimated_draw_time).InMillisecondsF(),
-      "state",
-      AsValue());
+      "state", AsValue());
 
   return estimated_draw_time < begin_impl_frame_args_.deadline;
 }
 
+bool Scheduler::CanDrawBeforeDeadline() const {
+  bool main_thread_is_in_high_latency_mode =
+      state_machine_.MainThreadIsInHighLatencyMode();
+
+  // Check if the main thread computation and commit can be finished before the
+  // impl thread's deadline.
+  base::TimeTicks estimated_draw_time = begin_impl_frame_args_.frame_time;
+  if (!main_thread_is_in_high_latency_mode) {

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

This should depend on if we care about main thread latency i.e. some combination
of impl_latency_takes_priority and needs_commit.

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

main_thread_is_in_high_latency_mode will become true if
impl_latency_takes_priority is true, so that part is covered already.

I definitely should take into account needs_commit / commit state / and whether
there is a pending tree though! Thanks for catching that.

[brianderson, 2015/05/12 22:19:00]

Actually, I think I do need to look into impl_latency_takes_priority like you
say. I'm going to reuse the begin_impl_frame_deadline_mode_ you added a while
back to help me here.

+    estimated_draw_time += client_->BeginMainFrameToCommitDurationEstimate() +
+                           client_->CommitToActivateDurationEstimate();
+  }
+
+  base::TimeDelta time_left_after_drawing =
+      begin_impl_frame_args_.deadline - estimated_draw_time;
+
+  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
+               "CanDrawBeforeDeadline", "time_left_after_drawing_ms",
+               time_left_after_drawing.InMillisecondsF(), "state", AsValue());
+
+  // Ideally we could use a threshold of 0, but our deadlines are currently
+  // just estimates, so we are extra careful not to skip frames if we aren't
+  // absolutely sure the Impl thread can run in a low latency mode.
+  // TODO(mithro): Replace this with SwapNack logic.
+  base::TimeDelta threshold = BeginFrameArgs::DefaultEstimatedParentDrawTime();

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

begin_impl_frame_args_.deadline already has the parent draw time adjusted.

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

I should probably rename CanDrawBeforeDeadline to CanRecoverImplLatency.

I tried explaining why I didn't use a threshold of 0 in the comment above.

The intent is to only attempt latency recovery when BeginImplFrame->draw takes
less than 1/3 the vsync (assuming our fixed deadline estimates). If that
happens, and we don't get a swap ack until after > 2/3 of the remaining vsync
later (the next BeginFrame), we are almost certainly in a high latency mode.

If we use a threshold of 0, I'm worried about races where we think we can draw
before the deadline, but can't actually make it.

+
+  return time_left_after_drawing > threshold;
+}
+
 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