[scheduler] Monitor renderer load level.

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"
@@ skipping 18 matching lines @@
 // the cost of loading tasks.
 const int kLoadingTaskEstimationSampleCount = 1000;
 const double kLoadingTaskEstimationPercentile = 99;
 const int kTimerTaskEstimationSampleCount = 1000;
 const double kTimerTaskEstimationPercentile = 99;
 const int kShortIdlePeriodDurationSampleCount = 10;
 const double kShortIdlePeriodDurationPercentile = 50;
 // Amount of idle time left in a frame (as a ratio of the vsync interval) above
 // which main thread compositing can be considered fast.
 const double kFastCompositingIdleTimeThreshold = .2;
+
+void ReportForegroundRendererTaskLoad(base::TimeTicks time, double load) {
+  UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.ForegroundRendererMainThreadLoad",
+                           static_cast<int>(load * 100));
+  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
+                 "RendererScheduler.ForegroundRendererLoad", load);
+}
+
+void ReportBackgroundRendererTaskLoad(base::TimeTicks time, double load) {
+  UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.BackgroundRendererMainThreadLoad",
+                           static_cast<int>(load * 100));
+  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
+                 "RendererScheduler.BackgroundRendererLoad", load);
+}
+
 }  // namespace
 
 RendererSchedulerImpl::RendererSchedulerImpl(
     scoped_refptr<SchedulerTqmDelegate> 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()),
       render_widget_scheduler_signals_(this),
       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_(this,
                         compositor_task_runner_,
-                        helper_.scheduler_tqm_delegate().get()),
+                        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"));
   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,
@@ skipping 29 matching lines @@
 
   // 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(
     RendererSchedulerImpl* renderer_scheduler_impl,
     const scoped_refptr<TaskQueue>& compositor_task_runner,
-    base::TickClock* time_source)
+    base::TickClock* time_source,
+    base::TimeTicks now)
     : loading_task_cost_estimator(time_source,
                                   kLoadingTaskEstimationSampleCount,
                                   kLoadingTaskEstimationPercentile),
       timer_task_cost_estimator(time_source,
                                 kTimerTaskEstimationSampleCount,
                                 kTimerTaskEstimationPercentile),
       queueing_time_estimator(renderer_scheduler_impl,
                               base::TimeDelta::FromSeconds(1)),
       idle_time_estimator(compositor_task_runner,
                           time_source,
                           kShortIdlePeriodDurationSampleCount,
                           kShortIdlePeriodDurationPercentile),
+      background_main_thread_load_tracker(
+          now,
+          base::Bind(&ReportBackgroundRendererTaskLoad)),
+      foreground_main_thread_load_tracker(
+          now,
+          base::Bind(&ReportForegroundRendererTaskLoad)),
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
       navigation_task_expected_count(0),
       expensive_task_policy(ExpensiveTaskPolicy::RUN),
       renderer_hidden(false),
       renderer_backgrounded(false),
       renderer_suspended(false),
       timer_queue_suspension_when_backgrounded_enabled(false),
       timer_queue_suspended_when_backgrounded(false),
       was_shutdown(false),
@@ skipping 20 matching lines @@
       have_seen_touchstart(false) {}
 
 RendererSchedulerImpl::AnyThread::~AnyThread() {}
 
 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();
   helper_.Shutdown();
   MainThreadOnly().was_shutdown = true;
   MainThreadOnly().rail_mode_observer = nullptr;
 }
 
 std::unique_ptr<blink::WebThread> RendererSchedulerImpl::CreateMainThread() {
   return base::MakeUnique<WebThreadImplForRendererScheduler>(this);
 }
 
@@ skipping 222 matching lines @@
 }
 
 void RendererSchedulerImpl::OnRendererBackgrounded() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererBackgrounded");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || MainThreadOnly().renderer_backgrounded)
     return;
 
   MainThreadOnly().renderer_backgrounded = true;
+
+  base::TimeTicks now = tick_clock()->NowTicks();
+  MainThreadOnly().foreground_main_thread_load_tracker.Pause(now);
+  MainThreadOnly().background_main_thread_load_tracker.Resume(now);
+
   if (!MainThreadOnly().timer_queue_suspension_when_backgrounded_enabled)
     return;
 
   suspend_timers_when_backgrounded_closure_.Cancel();
   base::TimeDelta suspend_timers_when_backgrounded_delay =
       base::TimeDelta::FromMilliseconds(
           kSuspendTimersWhenBackgroundedDelayMillis);
   control_task_runner_->PostDelayedTask(
       FROM_HERE, suspend_timers_when_backgrounded_closure_.callback(),
       suspend_timers_when_backgrounded_delay);
 }
 
 void RendererSchedulerImpl::OnRendererForegrounded() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererForegrounded");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || !MainThreadOnly().renderer_backgrounded)
     return;
 
   MainThreadOnly().renderer_backgrounded = false;
   MainThreadOnly().renderer_suspended = false;
+
+  base::TimeTicks now = tick_clock()->NowTicks();
+  MainThreadOnly().foreground_main_thread_load_tracker.Resume(now);
+  MainThreadOnly().background_main_thread_load_tracker.Pause(now);
+
   suspend_timers_when_backgrounded_closure_.Cancel();
   ResumeTimerQueueWhenForegrounded();
 }
 
 void RendererSchedulerImpl::SuspendRenderer() {
   helper_.CheckOnValidThread();
   DCHECK(MainThreadOnly().renderer_backgrounded);
   if (helper_.IsShutdown())
     return;
   suspend_timers_when_backgrounded_closure_.Cancel();
@@ skipping 967 matching lines @@
         " and https://crbug.com/574343#c40 for more information.");
   }
 }
 
 void RendererSchedulerImpl::ReportTaskTime(base::TimeTicks start_time,
                                            base::TimeTicks end_time) {
   MainThreadOnly().queueing_time_estimator.OnToplevelTaskCompleted(start_time,
                                                                    end_time);
   MainThreadOnly().long_task_tracker.RecordLongTask(
       start_time, end_time - start_time);
+  // 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, end_time);
+  MainThreadOnly().background_main_thread_load_tracker.RecordTaskTime(
+      start_time, end_time);
+  // TODO(altimin): Per-page metrics should also be considered.
   UMA_HISTOGRAM_CUSTOM_COUNTS("RendererScheduler.TaskTime",
                               (end_time - start_time).InMicroseconds(), 1,
                               1000000, 50);
 }
 
 LongTaskTracker::LongTaskTiming RendererSchedulerImpl::GetLongTaskTiming() {
   return MainThreadOnly().long_task_tracker.GetLongTaskTiming();
 }
 
 void RendererSchedulerImpl::OnQueueingTimeForWindowEstimated(
@@ skipping 62 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink