A better idle time estimator

components/scheduler/renderer/renderer_scheduler_impl.cc

 // Copyright 2014 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 "components/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_selector.h"
 #include "components/scheduler/child/scheduler_task_runner_delegate.h"
 
 namespace scheduler {
 namespace {
 const int kLoadingTaskEstimationSampleCount = 200;
 const double kLoadingTaskEstimationPercentile = 90;
 const int kTimerTaskEstimationSampleCount = 200;
 const double kTimerTaskEstimationPercentile = 90;
 const int kShortIdlePeriodDurationSampleCount = 10;
-const double kShortIdlePeriodDurationPercentile = 20;
+const double kShortIdlePeriodDurationPercentile = 50;
 }
 
 RendererSchedulerImpl::RendererSchedulerImpl(
     scoped_refptr<SchedulerTaskRunnerDelegate> main_task_runner)
     : helper_(main_task_runner,
               "renderer.scheduler",
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
               TRACE_DISABLED_BY_DEFAULT("renderer.scheduler.debug")),
       idle_helper_(&helper_,
                    this,
                    "renderer.scheduler",
                    TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                    "RendererSchedulerIdlePeriod",
                    base::TimeDelta()),
       control_task_runner_(helper_.ControlTaskRunner()),
       compositor_task_runner_(
           helper_.NewTaskQueue(TaskQueue::Spec("compositor_tq")
                                    .SetShouldMonitorQuiescence(true))),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
+      main_thread_only_(compositor_task_runner_),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr()));
 
   suspend_timers_when_backgrounded_closure_.Reset(
       base::Bind(&RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded,
                  weak_factory_.GetWeakPtr()));
 
   default_loading_task_runner_ = NewLoadingTaskRunner("default_loading_tq");
   default_timer_task_runner_ = NewTimerTaskRunner("default_timer_tq");
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
-  // Make sure that we don't initially assume there is no idle time.
-  MainThreadOnly().short_idle_period_duration.InsertSample(
-      cc::BeginFrameArgs::DefaultInterval());
-
   helper_.SetObserver(this);
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
   for (const scoped_refptr<TaskQueue>& loading_queue : loading_task_runners_) {
     loading_queue->RemoveTaskObserver(
         &MainThreadOnly().loading_task_cost_estimator);
   }
   for (const scoped_refptr<TaskQueue>& timer_queue : timer_task_runners_) {
     timer_queue->RemoveTaskObserver(
         &MainThreadOnly().timer_task_cost_estimator);
   }
 
   // Ensure the renderer scheduler was shut down explicitly, because otherwise
   // we could end up having stale pointers to the Blink heap which has been
   // terminated by this point.
   DCHECK(MainThreadOnly().was_shutdown);
 }
 
 RendererSchedulerImpl::Policy::Policy()
     : compositor_queue_priority(TaskQueue::NORMAL_PRIORITY),
       loading_queue_priority(TaskQueue::NORMAL_PRIORITY),
       timer_queue_priority(TaskQueue::NORMAL_PRIORITY),
       default_queue_priority(TaskQueue::NORMAL_PRIORITY) {}
 
-RendererSchedulerImpl::MainThreadOnly::MainThreadOnly()
+RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
+    const scoped_refptr<TaskQueue>& compositor_task_runner)
     : loading_task_cost_estimator(kLoadingTaskEstimationSampleCount,
                                   kLoadingTaskEstimationPercentile),
       timer_task_cost_estimator(kTimerTaskEstimationSampleCount,
                                 kTimerTaskEstimationPercentile),
-      short_idle_period_duration(kShortIdlePeriodDurationSampleCount),
+      idle_time_estimator(compositor_task_runner,
+                          kShortIdlePeriodDurationSampleCount,
+                          kShortIdlePeriodDurationPercentile),
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
       navigation_task_expected_count(0),
       renderer_hidden(false),
       renderer_backgrounded(false),
       timer_queue_suspension_when_backgrounded_enabled(false),
       timer_queue_suspended_when_backgrounded(false),
       was_shutdown(false),
       loading_tasks_seem_expensive(false),
       timer_tasks_seem_expensive(false),
@@ skipping 100 matching lines @@
 void RendererSchedulerImpl::WillBeginFrame(const cc::BeginFrameArgs& args) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::WillBeginFrame", "args", args.AsValue());
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
   EndIdlePeriod();
   MainThreadOnly().estimated_next_frame_begin = args.frame_time + args.interval;
   MainThreadOnly().have_seen_a_begin_main_frame = true;
+  MainThreadOnly().compositor_frame_interval = args.interval;
   {
     base::AutoLock lock(any_thread_lock_);
     AnyThread().begin_main_frame_on_critical_path = args.on_critical_path;
   }
 }
 
 void RendererSchedulerImpl::DidCommitFrameToCompositor() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::DidCommitFrameToCompositor");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
   base::TimeTicks now(helper_.Now());
   if (now < MainThreadOnly().estimated_next_frame_begin) {
     // TODO(rmcilroy): Consider reducing the idle period based on the runtime of
     // the next pending delayed tasks (as currently done in for long idle times)
     idle_helper_.StartIdlePeriod(
         IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, now,
         MainThreadOnly().estimated_next_frame_begin);
-    MainThreadOnly().short_idle_period_duration.InsertSample(
-        MainThreadOnly().estimated_next_frame_begin - now);
-  } else {
-    // There was no idle time :(
-    MainThreadOnly().short_idle_period_duration.InsertSample(base::TimeDelta());
   }
 
-  MainThreadOnly().expected_short_idle_period_duration =
-      MainThreadOnly().short_idle_period_duration.Percentile(
-          kShortIdlePeriodDurationPercentile);
+  MainThreadOnly().idle_time_estimator.DidCommitFrameToCompositor();
 }
 
 void RendererSchedulerImpl::BeginFrameNotExpectedSoon() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::BeginFrameNotExpectedSoon");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
   idle_helper_.EnableLongIdlePeriod();
+  {
+    base::AutoLock lock(any_thread_lock_);
+    AnyThread().begin_main_frame_on_critical_path = false;
+  }
 }
 
 void RendererSchedulerImpl::OnRendererHidden() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererHidden");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || MainThreadOnly().renderer_hidden)
     return;
 
   idle_helper_.EnableLongIdlePeriod();
@@ skipping 279 matching lines @@
 
   // TODO(alexclarke): We should wire up a signal from blink to let us know if
   // there are any touch handlers registerd or not, and only call
   // TouchStartExpectedSoon if there is at least one.  NOTE a TouchStart will
   // only actually get sent if there is a touch handler.
   base::TimeDelta touchstart_expected_flag_valid_for_duration;
   bool touchstart_expected_soon = AnyThread().user_model.IsGestureExpectedSoon(
       use_case, now, &touchstart_expected_flag_valid_for_duration);
   MainThreadOnly().touchstart_expected_soon = touchstart_expected_soon;
 
+  base::TimeDelta expected_idle_duration =
+      MainThreadOnly().idle_time_estimator.GetExpectedIdleDuration(
+          MainThreadOnly().compositor_frame_interval);
+  MainThreadOnly().expected_idle_duration = expected_idle_duration;
+
   bool loading_tasks_seem_expensive =
       MainThreadOnly().loading_task_cost_estimator.expected_task_duration() >
-      MainThreadOnly().expected_short_idle_period_duration;
+      expected_idle_duration;
   MainThreadOnly().loading_tasks_seem_expensive = loading_tasks_seem_expensive;
 
   bool timer_tasks_seem_expensive =
       MainThreadOnly().timer_task_cost_estimator.expected_task_duration() >
-      MainThreadOnly().expected_short_idle_period_duration;
+      expected_idle_duration;
   MainThreadOnly().timer_tasks_seem_expensive = timer_tasks_seem_expensive;
 
   // The |new_policy_duration| is the minimum of |expected_use_case_duration|
   // and |touchstart_expected_flag_valid_for_duration| unless one is zero in
   // which case we choose the other.
   base::TimeDelta new_policy_duration = expected_use_case_duration;
   if (new_policy_duration == base::TimeDelta() ||
       (touchstart_expected_flag_valid_for_duration > base::TimeDelta() &&
        new_policy_duration > touchstart_expected_flag_valid_for_duration)) {
     new_policy_duration = touchstart_expected_flag_valid_for_duration;
@@ skipping 52 matching lines @@
   if (!MainThreadOnly().have_seen_a_begin_main_frame)
     block_expensive_tasks = false;
 
   // Don't block expensive tasks if we are expecting a navigation.
   if (MainThreadOnly().navigation_task_expected_count > 0)
     block_expensive_tasks = false;
 
   if (block_expensive_tasks && loading_tasks_seem_expensive)
     new_policy.loading_queue_priority = TaskQueue::DISABLED_PRIORITY;
 
-  if (MainThreadOnly().timer_queue_suspend_count != 0 ||
+  if ((block_expensive_tasks && timer_tasks_seem_expensive) ||
+      MainThreadOnly().timer_queue_suspend_count != 0 ||
       MainThreadOnly().timer_queue_suspended_when_backgrounded) {
     new_policy.timer_queue_priority = TaskQueue::DISABLED_PRIORITY;
   }
 
   // Tracing is done before the early out check, because it's quite possible we
   // will otherwise miss this information in traces.
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(now));
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "use_case",
@@ skipping 98 matching lines @@
 TaskCostEstimator*
 RendererSchedulerImpl::GetLoadingTaskCostEstimatorForTesting() {
   return &MainThreadOnly().loading_task_cost_estimator;
 }
 
 TaskCostEstimator*
 RendererSchedulerImpl::GetTimerTaskCostEstimatorForTesting() {
   return &MainThreadOnly().timer_task_cost_estimator;
 }
 
+IdleTimeEstimator* RendererSchedulerImpl::GetIdleTimeEstimatorForTesting() {
+  return &MainThreadOnly().idle_time_estimator;
+}
+
 void RendererSchedulerImpl::SuspendTimerQueue() {
   MainThreadOnly().timer_queue_suspend_count++;
   ForceUpdatePolicy();
 #ifndef NDEBUG
   DCHECK(!default_timer_task_runner_->IsQueueEnabled());
   for (const auto& runner : timer_task_runners_) {
     DCHECK(!runner->IsQueueEnabled());
   }
 #endif
 }
@@ skipping 60 matching lines @@
                     AnyThread().begin_main_frame_on_critical_path);
   state->SetDouble("expected_loading_task_duration",
                    MainThreadOnly()
                        .loading_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   state->SetDouble("expected_timer_task_duration",
                    MainThreadOnly()
                        .timer_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   // TODO(skyostil): Can we somehow trace how accurate these estimates were?
+  state->SetDouble("expected_idle_duration",
+                   MainThreadOnly().expected_idle_duration.InMillisecondsF());
   state->SetDouble(
-      "expected_short_idle_period_duration",
-      MainThreadOnly().expected_short_idle_period_duration.InMillisecondsF());
+      "compositor_frame_interval",
+      MainThreadOnly().compositor_frame_interval.InMillisecondsF());
   state->SetDouble(
       "estimated_next_frame_begin",
       (MainThreadOnly().estimated_next_frame_begin - base::TimeTicks())
           .InMillisecondsF());
   state->SetBoolean("in_idle_period", AnyThread().in_idle_period);
   AnyThread().user_model.AsValueInto(state.get());
 
   return state;
 }
 
@@ skipping 56 matching lines @@
 
   MainThreadOnly().timer_queue_suspended_when_backgrounded = false;
   ForceUpdatePolicy();
 }
 
 void RendererSchedulerImpl::ResetForNavigationLocked() {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
   MainThreadOnly().loading_task_cost_estimator.Clear();
   MainThreadOnly().timer_task_cost_estimator.Clear();
-  MainThreadOnly().short_idle_period_duration.Clear();
-  // Make sure that we don't initially assume there is no idle time.
-  MainThreadOnly().short_idle_period_duration.InsertSample(
-      cc::BeginFrameArgs::DefaultInterval());
+  MainThreadOnly().idle_time_estimator.Clear();
   AnyThread().user_model.Reset();
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 }  // namespace scheduler