Force events to be non blocking if main thread is unresponsive.

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;
+// Maximum task queueing time before the main thread is considered unresponsive.
+const base::TimeDelta kMainThreadUnresponsiveQueueingTime =
+    base::TimeDelta::FromMilliseconds(1000);
 }  // 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_,
+      main_thread_only_(compositor_task_runner_,
                         helper_.scheduler_tqm_delegate().get()),
+      any_thread_(this),
       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 27 matching lines @@
   if (virtual_time_domain_)
     UnregisterTimeDomain(virtual_time_domain_.get());
 
   // 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)
     : 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),
       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),
       loading_tasks_seem_expensive(false),
       timer_tasks_seem_expensive(false),
       touchstart_expected_soon(false),
       have_seen_a_begin_main_frame(false),
       have_reported_blocking_intervention_in_current_policy(false),
       have_reported_blocking_intervention_since_navigation(false),
       has_visible_render_widget_with_touch_handler(false),
       begin_frame_not_expected_soon(false),
       in_idle_period_for_testing(false),
       use_virtual_time(false),
       rail_mode_observer(nullptr) {}
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
-RendererSchedulerImpl::AnyThread::AnyThread()
-    : awaiting_touch_start_response(false),
+RendererSchedulerImpl::AnyThread::AnyThread(
+    RendererSchedulerImpl* renderer_scheduler_impl)
+    : queueing_time_estimator(renderer_scheduler_impl,
+                              base::TimeDelta::FromSeconds(1)),
+      awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
       default_gesture_prevented(true),
       have_seen_touchstart(false) {}
 
 RendererSchedulerImpl::AnyThread::~AnyThread() {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
     : last_input_type(blink::WebInputEvent::Undefined) {}
@@ skipping 1169 matching lines @@
   default_loading_task_runner_->SetBlameContext(blame_context);
   default_timer_task_runner_->SetBlameContext(blame_context);
   compositor_task_runner_->SetBlameContext(blame_context);
   idle_helper_.IdleTaskRunner()->SetBlameContext(blame_context);
 }
 
 void RendererSchedulerImpl::SetRAILModeObserver(RAILModeObserver* observer) {
   MainThreadOnly().rail_mode_observer = observer;
 }
 
+bool RendererSchedulerImpl::
+    ShouldForceEventsNonBlockingForUnresponsiveMainThread() const {
+  base::TimeTicks now = base::TimeTicks::Now();
+  base::TimeDelta estimated_queueing_time;
+
+  {
+    base::AutoLock lock(any_thread_lock_);
+
+    estimated_queueing_time =
+        AnyThread()
+            .queueing_time_estimator.EstimateQueueingTimeIncludingCurrentTask(
+                now);
+  }
+
+  return estimated_queueing_time > kMainThreadUnresponsiveQueueingTime;
+}
+
 void RendererSchedulerImpl::RegisterTimeDomain(TimeDomain* time_domain) {
   helper_.RegisterTimeDomain(time_domain);
 }
 
 void RendererSchedulerImpl::UnregisterTimeDomain(TimeDomain* time_domain) {
   helper_.UnregisterTimeDomain(time_domain);
 }
 
 base::TickClock* RendererSchedulerImpl::tick_clock() const {
   return helper_.scheduler_tqm_delegate().get();
@@ skipping 49 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::ReportTaskStartTime(base::TimeTicks start_time) {
+  base::AutoLock lock(any_thread_lock_);

[Sami, 2016/08/24 14:56:01]

This makes us take two locks for every task we execute which seems high to me
(even if they should generally be uncontented). I wonder if there's a way to
avoid that? How stale an estimate would still work?

[tdresser, 2016/08/24 17:22:50]

I think there are basically two options here:

The problem case is when the main thread is running an extremely long task, and
then partway through that task, the compositor thread needs to know the
estimated queueing time. This requires knowing the start time of that extremely
long task.

Either we lock, and ask when the task started, or we get the main thread to post
over to the compositor when each task started.

An estimate whose staleness is bounded in milliseconds would be fine. An
estimate whose staleness is bounded in number of main thread tasks is not. 

I should be able to get us down to a single lock per task, instead of two, if we
think that's adequate.

Do you have any other ideas?

[Sami, 2016/08/25 12:48:44]

Do you think this happens often enough that we actually need to handle this
case? It feels like hitting a long task without also seeing other long tasks on
the page prior to that is pretty rare, and getting a jank in that case is
probably fine.
Another thought I had is to do an atomic store to a variable that is sampled by
the compositor thread. Much cheaper than a lock, but still not entirely free.

[tdresser, 2016/08/25 15:27:12]

One of the biggest cases we want to address with this intervention is the very
first scroll on a page. I think this does happen often enough that we need to
address it.

We could do an atomic store of the task start time.

What I really want here is an atomic base::TimeTicks – I'm not sure what atomics
look like in chromium, can you point me in the right direction?

+  AnyThread().queueing_time_estimator.OnTopLevelTaskStarted(start_time);
+}
+
 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);
+  {
+    base::AutoLock lock(any_thread_lock_);
+    AnyThread().queueing_time_estimator.OnTopLevelTaskCompleted(start_time,
+                                                                end_time);
+  }
+  MainThreadOnly().long_task_tracker.RecordLongTask(start_time,
+                                                    end_time - start_time);
+
   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