scheduler: Disable expensive timers during main thread user input

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/child/scheduler_task_runner_delegate.h"
 #include "components/scheduler/child/task_queue_impl.h"
 #include "components/scheduler/child/task_queue_selector.h"
 
 namespace scheduler {
+namespace {
+const int kTimerTaskEstimationSampleCount = 4 * 60;
+const double kTimerTaskEstimationPercentile = 80;
+const int kShortIdlePeriodDurationSampleCount = 10;
+const double kShortIdlePeriodDurationPercentile = 20;
+}
 
 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",
@@ skipping 14 matching lines @@
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
       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()));
 
+  timer_task_runner_->AddTaskObserver(
+      &MainThreadOnly().timer_task_cost_estimator_);
+
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 }
 
 RendererSchedulerImpl::~RendererSchedulerImpl() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
+  timer_task_runner_->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::MainThreadOnly::MainThreadOnly()
-    : current_policy_(Policy::NORMAL),
+    : timer_task_cost_estimator_(kTimerTaskEstimationSampleCount,
+                                 kTimerTaskEstimationPercentile),
+      short_idle_period_duration_(kShortIdlePeriodDurationSampleCount),
+      current_policy_(Policy::NORMAL),
       timer_queue_suspend_count_(0),
       renderer_hidden_(false),
-      was_shutdown_(false) {
-}
+      was_shutdown_(false) {}
+
+RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
     : pending_main_thread_input_event_count_(0),
       awaiting_touch_start_response_(false),
       in_idle_period_(false),
-      begin_main_frame_on_critical_path_(false) {
-}
+      begin_main_frame_on_critical_path_(false),
+      timer_tasks_seem_expensive_(false) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
     : last_input_type_(blink::WebInputEvent::Undefined) {
 }
 
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {
 }
 
 void RendererSchedulerImpl::Shutdown() {
   helper_.Shutdown();
@@ skipping 63 matching lines @@
   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);
+    MainThreadOnly().expected_short_idle_period_duration_ =
+        MainThreadOnly().short_idle_period_duration_.Percentile(
+            kShortIdlePeriodDurationPercentile);
   }
 }
 
 void RendererSchedulerImpl::BeginFrameNotExpectedSoon() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::BeginFrameNotExpectedSoon");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown())
     return;
 
@@ skipping 236 matching lines @@
 
 void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
   if (helper_.IsShutdown())
     return;
 
   base::TimeTicks now = helper_.Now();
   policy_may_need_update_.SetWhileLocked(false);
 
+  AnyThread().timer_tasks_seem_expensive_ =
+      MainThreadOnly().expected_short_idle_period_duration_ >
+          base::TimeDelta() &&
+      MainThreadOnly().timer_task_cost_estimator_.expected_task_duration() >
+          MainThreadOnly().expected_short_idle_period_duration_;
+
   base::TimeDelta new_policy_duration;
   Policy new_policy = ComputeNewPolicy(now, &new_policy_duration);
   if (new_policy_duration > base::TimeDelta()) {
     MainThreadOnly().current_policy_expiration_time_ =
         now + new_policy_duration;
     delayed_update_policy_runner_.SetDeadline(FROM_HERE, new_policy_duration,
                                               now);
   } else {
     MainThreadOnly().current_policy_expiration_time_ = base::TimeTicks();
   }
@@ skipping 46 matching lines @@
       new_policy != Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY) {
     DCHECK(loading_task_runner_->IsQueueEnabled());
   }
   MainThreadOnly().current_policy_ = new_policy;
 
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(now));
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.policy", MainThreadOnly().current_policy_);
+  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
+                 "RendererScheduler.timer_tasks_seem_expensive",
+                 AnyThread().timer_tasks_seem_expensive_);
 }
 
 bool RendererSchedulerImpl::InputSignalsSuggestCompositorPriority(
     base::TimeTicks now) const {
   base::TimeDelta unused_policy_duration;
   switch (ComputeNewPolicy(now, &unused_policy_duration)) {
     case Policy::TOUCHSTART_PRIORITY:
     case Policy::COMPOSITOR_PRIORITY:
     case Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY:
       return true;
 
     default:
       break;
   }
   return false;
 }
 
 RendererSchedulerImpl::Policy RendererSchedulerImpl::ComputeNewPolicy(
     base::TimeTicks now,
     base::TimeDelta* new_policy_duration) const {
   any_thread_lock_.AssertAcquired();
   // Above all else we want to be responsive to user input.
   *new_policy_duration = TimeLeftInInputEscalatedPolicy(now);
   if (*new_policy_duration > base::TimeDelta()) {
     if (AnyThread().awaiting_touch_start_response_)
       return Policy::TOUCHSTART_PRIORITY;
     // If BeginMainFrame is on the critical path, we want to try and prevent
-    // timers and loading tasks from running shortly before BeginMainFrame is
-    // due to be posted from the compositor, because they can delay
-    // BeginMainFrame's execution. We do this by limiting execution of timers to
-    // idle periods, provided there has been at least one idle period recently.
-    //
-    // TODO(alexclarke): It's a shame in_idle_period_,
-    // begin_main_frame_on_critical_path_ and last_idle_period_end_time_ are in
-    // the AnyThread struct.  Find a way to migrate them to MainThreadOnly.
-    if (!AnyThread().in_idle_period_ &&
-        AnyThread().begin_main_frame_on_critical_path_ &&
-        HadAnIdlePeriodRecently(now)) {
+    // timers and loading tasks from running if we think they might be
+    // expensive.
+    // TODO(skyostil): Consider removing in_idle_period_ and
+    // HadAnIdlePeriodRecently() unless we need them here.
+    if (AnyThread().timer_tasks_seem_expensive_ &&
+        AnyThread().begin_main_frame_on_critical_path_) {
       return Policy::COMPOSITOR_CRITICAL_PATH_PRIORITY;
     }
     return Policy::COMPOSITOR_PRIORITY;
   }
 
   if (AnyThread().rails_loading_priority_deadline_ > now) {
     *new_policy_duration = AnyThread().rails_loading_priority_deadline_ - now;
     return Policy::LOADING_PRIORITY;
   }
 
@@ skipping 101 matching lines @@
                     base::TimeTicks()).InMillisecondsF());
   state->SetDouble("last_idle_period_end_time",
                    (AnyThread().last_idle_period_end_time_ - base::TimeTicks())
                        .InMillisecondsF());
   state->SetInteger("pending_main_thread_input_event_count",
                     AnyThread().pending_main_thread_input_event_count_);
   state->SetBoolean("awaiting_touch_start_response",
                     AnyThread().awaiting_touch_start_response_);
   state->SetBoolean("begin_main_frame_on_critical_path",
                     AnyThread().begin_main_frame_on_critical_path_);
+  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_short_idle_period_duration",
+      MainThreadOnly().expected_short_idle_period_duration_.InMillisecondsF());
+  state->SetBoolean("timer_tasks_seem_expensive",
+                    AnyThread().timer_tasks_seem_expensive_);
   state->SetDouble("estimated_next_frame_begin",
                    (MainThreadOnly().estimated_next_frame_begin_ -
                     base::TimeTicks()).InMillisecondsF());
   state->SetBoolean("in_idle_period", AnyThread().in_idle_period_);
 
   return state;
 }
 
 void RendererSchedulerImpl::OnIdlePeriodStarted() {
   base::AutoLock lock(any_thread_lock_);
@@ skipping 16 matching lines @@
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 bool RendererSchedulerImpl::HadAnIdlePeriodRecently(base::TimeTicks now) const {
   return (now - AnyThread().last_idle_period_end_time_) <=
          base::TimeDelta::FromMilliseconds(
              kIdlePeriodStarvationThresholdMillis);
 }
 
 }  // namespace scheduler