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 88 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, base::TimeDelta::FromSeconds(1), 1)),

[tdresser, 2017/05/08 17:58:15]

We'll want this to behave the same with a step size other than 1, won't we? Can
we change this to something other than 1 to get test coverage of this?

Alternatively, we should have a bunch more testing of the multi step path.

[Liquan (Max) Gu, 2017/05/10 15:14:21]

Does 5 steps per window sound good?

[tdresser, 2017/05/10 18:54:31]

Hmmm. Eventually, we'll want something much greater than 5.
Let's go with 20 for now?

       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 1543 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;
+  QueueingTimeEstimator::State queueing_time_estimator_state(1);

[tdresser, 2017/05/08 17:58:14]

Same as above.

[Liquan (Max) Gu, 2017/05/10 15:14:21]

It seems unnecessary to define it seperately.

[tdresser, 2017/05/10 18:54:31]

Acknowledged.

 
   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 =
@@ skipping 273 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink