EQT: Change Expected Queuing Time from per-second to sliding window

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 32 matching lines @@
 // 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;
 constexpr base::TimeDelta kThreadLoadTrackerReportingInterval =
     base::TimeDelta::FromMinutes(1);
 constexpr base::TimeDelta kThreadLoadTrackerWaitingPeriodBeforeReporting =
     base::TimeDelta::FromMinutes(2);
 // We do not throttle anything while audio is played and shortly after that.
 constexpr base::TimeDelta kThrottlingDelayAfterAudioIsPlayed =
     base::TimeDelta::FromSeconds(5);
+constexpr base::TimeDelta kQueueingTimeWindowDuration =
+    base::TimeDelta::FromSeconds(1);
 
 void ReportForegroundRendererTaskLoad(base::TimeTicks time, double load) {
   if (!blink::RuntimeEnabledFeatures::timerThrottlingForBackgroundTabsEnabled())
     return;
 
   int load_percentage = static_cast<int>(load * 100);
   DCHECK_LE(load_percentage, 100);
 
   UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.ForegroundRendererMainThreadLoad",
                            load_percentage);
@@ skipping 30 matching lines @@
       compositor_task_queue_(
           helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR)
                                    .SetShouldMonitorQuiescence(true))),
       compositor_task_queue_enabled_voter_(
           compositor_task_queue_->CreateQueueEnabledVoter()),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskQueue()),
       seqlock_queueing_time_estimator_(
-          QueueingTimeEstimator(this, base::TimeDelta::FromSeconds(1))),
+          QueueingTimeEstimator(this, kQueueingTimeWindowDuration, 20)),
       main_thread_only_(this,
                         compositor_task_queue_,
                         helper_.scheduler_tqm_delegate().get(),
                         helper_.scheduler_tqm_delegate()->NowTicks()),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   task_queue_throttler_.reset(new TaskQueueThrottler(this));
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
@@ skipping 1572 matching lines @@
 void RendererSchedulerImpl::SetRAILModeObserver(RAILModeObserver* observer) {
   GetMainThreadOnly().rail_mode_observer = observer;
 }
 
 bool RendererSchedulerImpl::MainThreadSeemsUnresponsive(
     base::TimeDelta main_thread_responsiveness_threshold) {
   base::TimeTicks now = tick_clock()->NowTicks();
   base::TimeDelta estimated_queueing_time;
 
   bool can_read = false;
-  QueueingTimeEstimator::State queueing_time_estimator_state;
 
   base::subtle::Atomic32 version;
   seqlock_queueing_time_estimator_.seqlock.TryRead(&can_read, &version);
 
   // If we fail to determine if the main thread is busy, assume whether or not
   // it's busy hasn't change since the last time we asked.
   if (!can_read)
     return GetCompositorThreadOnly().main_thread_seems_unresponsive;
 
-  queueing_time_estimator_state =
+  QueueingTimeEstimator::State queueing_time_estimator_state =
       seqlock_queueing_time_estimator_.data.GetState();
 
   // If we fail to determine if the main thread is busy, assume whether or not
   // it's busy hasn't change since the last time we asked.
   if (seqlock_queueing_time_estimator_.seqlock.ReadRetry(version))
     return GetCompositorThreadOnly().main_thread_seems_unresponsive;
 
   QueueingTimeEstimator queueing_time_estimator(queueing_time_estimator_state);
 
   estimated_queueing_time =
@@ skipping 130 matching lines @@
     TaskTimeObserver* task_time_observer) {
   helper_.AddTaskTimeObserver(task_time_observer);
 }
 
 void RendererSchedulerImpl::RemoveTaskTimeObserver(
     TaskTimeObserver* task_time_observer) {
   helper_.RemoveTaskTimeObserver(task_time_observer);
 }
 
 void RendererSchedulerImpl::OnQueueingTimeForWindowEstimated(
-    base::TimeDelta queueing_time) {
+    base::TimeDelta queueing_time,
+    base::TimeTicks window_start_time) {
+  // RendererScheduler reports the queueing time once per window's duration.
+  //          |stepEQT|stepEQT|stepEQT|stepEQT|stepEQT|stepEQT|
+  // Report:  |-------window EQT------|
+  // Discard:         |-------window EQT------|
+  // Discard:                 |-------window EQT------|
+  // Report:                          |-------window EQT------|
+  if (window_start_time -
+          GetMainThreadOnly().uma_last_queueing_time_report_window_start_time <
+      kQueueingTimeWindowDuration) {
+    return;
+  }
   UMA_HISTOGRAM_TIMES("RendererScheduler.ExpectedTaskQueueingDuration",
                       queueing_time);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "estimated_queueing_time_for_window",
                  queueing_time.InMillisecondsF());
+  GetMainThreadOnly().uma_last_queueing_time_report_window_start_time =
+      window_start_time;
 }
 
 AutoAdvancingVirtualTimeDomain* RendererSchedulerImpl::GetVirtualTimeDomain() {
   if (!virtual_time_domain_) {
     virtual_time_domain_.reset(
         new AutoAdvancingVirtualTimeDomain(tick_clock()->NowTicks()));
     RegisterTimeDomain(virtual_time_domain_.get());
   }
   return virtual_time_domain_.get();
 }
@@ skipping 119 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink