[scheduler] Implement time-based cpu throttling.

third_party/WebKit/Source/platform/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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/base/task_queue_selector.h"
 #include "platform/scheduler/base/virtual_time_domain.h"
 #include "platform/scheduler/child/scheduler_tqm_delegate.h"
 #include "platform/scheduler/renderer/auto_advancing_virtual_time_domain.h"
+#include "platform/scheduler/renderer/task_queue_throttler.h"
 #include "platform/scheduler/renderer/web_view_scheduler_impl.h"
 #include "platform/scheduler/renderer/webthread_impl_for_renderer_scheduler.h"
 
 namespace blink {
 namespace scheduler {
 namespace {
 // The run time of loading tasks is strongly bimodal.  The vast majority are
 // very cheap, but there are usually a handful of very expensive tasks (e.g ~1
 // second on a mobile device) so we take a very pessimistic view when estimating
 // the cost of loading tasks.
@@ skipping 49 matching lines @@
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskRunner()),
       main_thread_only_(this,
                         compositor_task_runner_,
                         helper_.scheduler_tqm_delegate().get(),
                         helper_.scheduler_tqm_delegate()->NowTicks()),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
-  throttling_helper_.reset(new ThrottlingHelper(this, "renderer.scheduler"));
+  task_queue_throttler_.reset(
+      new TaskQueueThrottler(this, "renderer.scheduler"));
   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");
@@ skipping 92 matching lines @@
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
     : last_input_type(blink::WebInputEvent::Undefined) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 void RendererSchedulerImpl::Shutdown() {
   base::TimeTicks now = tick_clock()->NowTicks();
   MainThreadOnly().background_main_thread_load_tracker.RecordIdle(now);
   MainThreadOnly().foreground_main_thread_load_tracker.RecordIdle(now);
 
-  throttling_helper_.reset();
+  task_queue_throttler_.reset();
   helper_.Shutdown();
   MainThreadOnly().was_shutdown = true;
   MainThreadOnly().rail_mode_observer = nullptr;
 }
 
 std::unique_ptr<blink::WebThread> RendererSchedulerImpl::CreateMainThread() {
   return base::MakeUnique<WebThreadImplForRendererScheduler>(this);
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskRunner() {
@@ skipping 32 matching lines @@
       TaskQueue::Spec(name).SetShouldMonitorQuiescence(true).SetTimeDomain(
           MainThreadOnly().use_virtual_time ? GetVirtualTimeDomain()
                                             : nullptr)));
   loading_task_runners_.insert(loading_task_queue);
   loading_task_queue->SetQueueEnabled(
       MainThreadOnly().current_policy.loading_queue_policy.is_enabled);
   loading_task_queue->SetQueuePriority(
       MainThreadOnly().current_policy.loading_queue_policy.priority);
   if (MainThreadOnly().current_policy.loading_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
-    throttling_helper_->IncreaseThrottleRefCount(loading_task_queue.get());
+    task_queue_throttler_->IncreaseThrottleRefCount(loading_task_queue.get());
   }
   loading_task_queue->AddTaskObserver(
       &MainThreadOnly().loading_task_cost_estimator);
   return loading_task_queue;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewTimerTaskRunner(
     const char* name) {
   helper_.CheckOnValidThread();
   // TODO(alexclarke): Consider using ApplyTaskQueuePolicy() for brevity.
   scoped_refptr<TaskQueue> timer_task_queue(
       helper_.NewTaskQueue(TaskQueue::Spec(name)
                                .SetShouldMonitorQuiescence(true)
                                .SetShouldReportWhenExecutionBlocked(true)
                                .SetTimeDomain(MainThreadOnly().use_virtual_time
                                                   ? GetVirtualTimeDomain()
                                                   : nullptr)));
   timer_task_runners_.insert(timer_task_queue);
   timer_task_queue->SetQueueEnabled(
       MainThreadOnly().current_policy.timer_queue_policy.is_enabled);
   timer_task_queue->SetQueuePriority(
       MainThreadOnly().current_policy.timer_queue_policy.priority);
   if (MainThreadOnly().current_policy.timer_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
-    throttling_helper_->IncreaseThrottleRefCount(timer_task_queue.get());
+    task_queue_throttler_->IncreaseThrottleRefCount(timer_task_queue.get());
   }
   timer_task_queue->AddTaskObserver(
       &MainThreadOnly().timer_task_cost_estimator);
   return timer_task_queue;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewUnthrottledTaskRunner(
     const char* name) {
   helper_.CheckOnValidThread();
   scoped_refptr<TaskQueue> unthrottled_task_queue(helper_.NewTaskQueue(
       TaskQueue::Spec(name).SetShouldMonitorQuiescence(true).SetTimeDomain(
           MainThreadOnly().use_virtual_time ? GetVirtualTimeDomain()
                                             : nullptr)));
   unthrottled_task_runners_.insert(unthrottled_task_queue);
   return unthrottled_task_queue;
 }
 
 std::unique_ptr<RenderWidgetSchedulingState>
 RendererSchedulerImpl::NewRenderWidgetSchedulingState() {
   return render_widget_scheduler_signals_.NewRenderWidgetSchedulingState();
 }
 
 void RendererSchedulerImpl::OnUnregisterTaskQueue(
     const scoped_refptr<TaskQueue>& task_queue) {
-  if (throttling_helper_.get())
-    throttling_helper_->UnregisterTaskQueue(task_queue.get());
+  if (task_queue_throttler_)
+    task_queue_throttler_->UnregisterTaskQueue(task_queue.get());
 
   if (loading_task_runners_.find(task_queue) != loading_task_runners_.end()) {
     task_queue->RemoveTaskObserver(
         &MainThreadOnly().loading_task_cost_estimator);
     loading_task_runners_.erase(task_queue);
   } else if (timer_task_runners_.find(task_queue) !=
              timer_task_runners_.end()) {
     task_queue->RemoveTaskObserver(&MainThreadOnly().timer_task_cost_estimator);
     timer_task_runners_.erase(task_queue);
   } else if (unthrottled_task_runners_.find(task_queue) !=
@@ skipping 90 matching lines @@
     control_task_runner_->PostDelayedTask(
         FROM_HERE, end_renderer_hidden_idle_period_closure_.callback(),
         end_idle_when_hidden_delay);
     MainThreadOnly().renderer_hidden = true;
   } else {
     MainThreadOnly().renderer_hidden = false;
     EndIdlePeriod();
   }
 
   // TODO(alexclarke): Should we update policy here?
-  TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
-      TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
-      this, AsValue(helper_.scheduler_tqm_delegate()->NowTicks()));
+  CreateTraceEventObjectSnapshot();
 }
 
 void RendererSchedulerImpl::SetHasVisibleRenderWidgetWithTouchHandler(
     bool has_visible_render_widget_with_touch_handler) {
   helper_.CheckOnValidThread();
   if (has_visible_render_widget_with_touch_handler ==
       MainThreadOnly().has_visible_render_widget_with_touch_handler)
     return;
 
   MainThreadOnly().has_visible_render_widget_with_touch_handler =
@@ skipping 526 matching lines @@
   if (MainThreadOnly().use_virtual_time) {
     new_policy.compositor_queue_policy.time_domain_type =
         TimeDomainType::VIRTUAL;
     new_policy.default_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
     new_policy.loading_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
     new_policy.timer_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
   }
 
   // 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));
+  CreateTraceEventObjectSnapshotLocked();
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "use_case",
                  use_case);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "rail_mode",
                  new_policy.rail_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "touchstart_expected_soon",
                  MainThreadOnly().touchstart_expected_soon);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "expensive_task_policy", expensive_task_policy);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
@@ skipping 41 matching lines @@
 
   DCHECK(compositor_task_runner_->IsQueueEnabled());
   MainThreadOnly().current_policy = new_policy;
 }
 
 void RendererSchedulerImpl::ApplyTaskQueuePolicy(
     TaskQueue* task_queue,
     const TaskQueuePolicy& old_task_queue_policy,
     const TaskQueuePolicy& new_task_queue_policy) const {
   if (old_task_queue_policy.is_enabled != new_task_queue_policy.is_enabled) {
-    throttling_helper_->SetQueueEnabled(task_queue,
-                                        new_task_queue_policy.is_enabled);
+    task_queue_throttler_->SetQueueEnabled(task_queue,
+                                           new_task_queue_policy.is_enabled);
   }
 
   if (old_task_queue_policy.priority != new_task_queue_policy.priority)
     task_queue->SetQueuePriority(new_task_queue_policy.priority);
 
   if (old_task_queue_policy.time_domain_type !=
       new_task_queue_policy.time_domain_type) {
     if (old_task_queue_policy.time_domain_type == TimeDomainType::THROTTLED) {
-      throttling_helper_->DecreaseThrottleRefCount(task_queue);
+      task_queue_throttler_->DecreaseThrottleRefCount(task_queue);
     } else if (new_task_queue_policy.time_domain_type ==
                TimeDomainType::THROTTLED) {
-      throttling_helper_->IncreaseThrottleRefCount(task_queue);
+      task_queue_throttler_->IncreaseThrottleRefCount(task_queue);
     } else if (new_task_queue_policy.time_domain_type ==
                TimeDomainType::VIRTUAL) {
       DCHECK(virtual_time_domain_);
       task_queue->SetTimeDomain(virtual_time_domain_.get());
     }
   }
 }
 
 RendererSchedulerImpl::UseCase RendererSchedulerImpl::ComputeCurrentUseCase(
     base::TimeTicks now,
@@ skipping 124 matching lines @@
   // Note that this will only take effect for the next backgrounded signal.
   MainThreadOnly().timer_queue_suspension_when_backgrounded_enabled = enabled;
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 RendererSchedulerImpl::AsValue(base::TimeTicks optional_now) const {
   base::AutoLock lock(any_thread_lock_);
   return AsValueLocked(optional_now);
 }
 
+void RendererSchedulerImpl::CreateTraceEventObjectSnapshot() const {
+  TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
+      TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
+      this, AsValue(helper_.scheduler_tqm_delegate()->NowTicks()));
+}
+
+void RendererSchedulerImpl::CreateTraceEventObjectSnapshotLocked() const {
+  TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
+      TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
+      this, AsValueLocked(helper_.scheduler_tqm_delegate()->NowTicks()));
+}
+
 // static
 const char* RendererSchedulerImpl::ExpensiveTaskPolicyToString(
     ExpensiveTaskPolicy expensive_task_policy) {
   switch (expensive_task_policy) {
     case ExpensiveTaskPolicy::RUN:
       return "RUN";
     case ExpensiveTaskPolicy::BLOCK:
       return "BLOCK";
     case ExpensiveTaskPolicy::THROTTLE:
       return "THROTTLE";
@@ skipping 88 matching lines @@
           .InMillisecondsF());
   state->SetBoolean("in_idle_period", AnyThread().in_idle_period);
 
   state->SetString(
       "expensive_task_policy",
       ExpensiveTaskPolicyToString(MainThreadOnly().expensive_task_policy));
 
   AnyThread().user_model.AsValueInto(state.get());
   render_widget_scheduler_signals_.AsValueInto(state.get());
 
+  state->BeginDictionary("task_queue_throttler");
+  task_queue_throttler_->AsValueInto(state.get(), optional_now);
+  state->EndDictionary();
+
   return std::move(state);
 }
 
 void RendererSchedulerImpl::OnIdlePeriodStarted() {
   base::AutoLock lock(any_thread_lock_);
   AnyThread().in_idle_period = true;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::OnIdlePeriodEnded() {
@@ skipping 148 matching lines @@
         true;
     BroadcastIntervention(
         "Blink deferred a task in order to make scrolling smoother. "
         "Your timer and network tasks should take less than 50ms to run "
         "to avoid this. Please see "
         "https://developers.google.com/web/tools/chrome-devtools/profile/evaluate-performance/rail"
         " and https://crbug.com/574343#c40 for more information.");
   }
 }
 
-void RendererSchedulerImpl::ReportTaskTime(double start_time, double end_time) {
+void RendererSchedulerImpl::ReportTaskTime(TaskQueue* task_queue,
+                                           double start_time,
+                                           double end_time) {
+  // TODO(scheduler-dev): Remove conversions when Blink starts using
+  // base::TimeTicks instead of doubles for time.
   base::TimeTicks start_time_ticks =
       MonotonicTimeInSecondsToTimeTicks(start_time);
   base::TimeTicks end_time_ticks = MonotonicTimeInSecondsToTimeTicks(end_time);
 
   MainThreadOnly().queueing_time_estimator.OnToplevelTaskCompleted(
       start_time_ticks, end_time_ticks);
+
+  task_queue_throttler()->OnTaskRunTimeReported(task_queue, start_time_ticks,
+                                                end_time_ticks);
+
   // We want to measure thread time here, but for efficiency reasons
   // we stick with wall time.
   MainThreadOnly().foreground_main_thread_load_tracker.RecordTaskTime(
       start_time_ticks, end_time_ticks);
   MainThreadOnly().background_main_thread_load_tracker.RecordTaskTime(
       start_time_ticks, end_time_ticks);
   // TODO(altimin): Per-page metrics should also be considered.
   UMA_HISTOGRAM_CUSTOM_COUNTS("RendererScheduler.TaskTime",
                               (end_time_ticks - start_time_ticks).InMicroseconds(), 1,
                               1000000, 50);
@@ skipping 28 matching lines @@
 }
 
 void RendererSchedulerImpl::EnableVirtualTime() {
   MainThreadOnly().use_virtual_time = true;
 
   // The |unthrottled_task_runners_| are not actively managed by UpdatePolicy().
   AutoAdvancingVirtualTimeDomain* time_domain = GetVirtualTimeDomain();
   for (const scoped_refptr<TaskQueue>& task_queue : unthrottled_task_runners_)
     task_queue->SetTimeDomain(time_domain);
 
-  throttling_helper_->EnableVirtualTime();
+  task_queue_throttler_->EnableVirtualTime();
 
   ForceUpdatePolicy();
 }
 
 // static
 const char* RendererSchedulerImpl::UseCaseToString(UseCase use_case) {
   switch (use_case) {
     case UseCase::NONE:
       return "none";
     case UseCase::COMPOSITOR_GESTURE:
@@ skipping 26 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink