[scheduler] Implement time-based cpu throttling.

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc

Index: third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
index babb10cae27e56de7bba049a0950a5a8d0b504da..a7c8e9642329f5c452a60c5cd06bd8ece1e9c9be 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
@@ -86,7 +86,8 @@ RendererSchedulerImpl::RendererSchedulerImpl(
                         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(
@@ -199,7 +200,7 @@ void RendererSchedulerImpl::Shutdown() {
   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;
@@ -252,7 +253,7 @@ scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskRunner(
       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);
@@ -277,7 +278,7 @@ scoped_refptr<TaskQueue> RendererSchedulerImpl::NewTimerTaskRunner(
       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);
@@ -302,8 +303,8 @@ RendererSchedulerImpl::NewRenderWidgetSchedulingState() {
 
 void RendererSchedulerImpl::OnUnregisterTaskQueue(
     const scoped_refptr<TaskQueue>& task_queue) {
-  if (throttling_helper_.get())
-    throttling_helper_->UnregisterTaskQueue(task_queue.get());
+  if (task_queue_throttler_.get())
+    task_queue_throttler_->UnregisterTaskQueue(task_queue.get());
 
   if (loading_task_runners_.find(task_queue) != loading_task_runners_.end()) {
     task_queue->RemoveTaskObserver(
@@ -414,9 +415,7 @@ void RendererSchedulerImpl::SetAllRenderWidgetsHidden(bool hidden) {
   }
 
   // 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(
@@ -963,9 +962,7 @@ void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
 
   // 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",
@@ -1027,8 +1024,8 @@ void RendererSchedulerImpl::ApplyTaskQueuePolicy(
     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)
@@ -1037,10 +1034,10 @@ void RendererSchedulerImpl::ApplyTaskQueuePolicy(
   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_);
@@ -1185,6 +1182,18 @@ RendererSchedulerImpl::AsValue(base::TimeTicks optional_now) const {
   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) {
@@ -1293,6 +1302,10 @@ RendererSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
   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);
 }
 
@@ -1461,13 +1474,19 @@ void RendererSchedulerImpl::OnTriedToExecuteBlockedTask(
   }
 }
 
-void RendererSchedulerImpl::ReportTaskTime(double start_time, double end_time) {
+void RendererSchedulerImpl::ReportTaskTime(TaskQueue* task_queue,
+                                           double start_time,
+                                           double end_time) {
   base::TimeTicks start_time_ticks =
       MonotonicTimeInSecondsToTimeTicks(start_time);
   base::TimeTicks end_time_ticks = MonotonicTimeInSecondsToTimeTicks(end_time);

[alex clarke (OOO till 29th), 2016/09/12 17:45:26]

:(

I'm not keen on these conversions. I may get rid of them if you don't get there
first ;)

Please add a TODO(alexclarke): Remove conversions

[altimin, 2016/09/14 11:23:15]

The problem is that ReportTaskTime interface was exposed to outside Blink world,
and splitting it in two is costly and adds a lot of overhead. We should change
doubles to base::TimeTicks throughout Blink, but I don't think that it's a good
idea to do it in this patch.

 
   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(
@@ -1475,6 +1494,7 @@ void RendererSchedulerImpl::ReportTaskTime(double start_time, double end_time) {
   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);
@@ -1516,7 +1536,7 @@ void RendererSchedulerImpl::EnableVirtualTime() {
   for (const scoped_refptr<TaskQueue>& task_queue : unthrottled_task_runners_)
     task_queue->SetTimeDomain(time_domain);
 
-  throttling_helper_->EnableVirtualTime();
+  task_queue_throttler_->EnableVirtualTime();
 
   ForceUpdatePolicy();
 }