scheduler: Tell v8 about the current RAIL mode

components/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 "components/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 114 matching lines @@
       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),
       expensive_task_blocking_allowed(true),
-      in_idle_period_for_testing(false) {}
+      in_idle_period_for_testing(false),
+      rail_mode_observer(nullptr) {}
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
     : 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) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 void RendererSchedulerImpl::Shutdown() {
   throttling_helper_.reset();
   helper_.Shutdown();
   MainThreadOnly().was_shutdown = true;
+  MainThreadOnly().rail_mode_observer = nullptr;
 }
 
 std::unique_ptr<blink::WebThread> RendererSchedulerImpl::CreateMainThread() {
   return base::WrapUnique(new WebThreadImplForRendererScheduler(this));
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskRunner() {
   return helper_.DefaultTaskRunner();
 }
 
@@ skipping 556 matching lines @@
   // Avoid prioritizing main thread compositing (e.g., rAF) if it is extremely
   // slow, because that can cause starvation in other task sources.
   bool main_thread_compositing_is_fast =
       MainThreadOnly().idle_time_estimator.GetExpectedIdleDuration(
           MainThreadOnly().compositor_frame_interval) >
       MainThreadOnly().compositor_frame_interval *
           kFastCompositingIdleTimeThreshold;
 
   Policy new_policy;
   ExpensiveTaskPolicy expensive_task_policy = ExpensiveTaskPolicy::RUN;
+
+  if (MainThreadOnly().begin_frame_not_expected_soon)
+    new_policy.rail_mode = v8::PERFORMANCE_DEFAULT;

[ulan, 2016/06/28 13:09:08]

Looks like we will never get idle mode in foreground tab. Is it correct?
Would it make sense to set the mode to idle here? (I think telemetry defines
idle as not RAL)

[rmcilroy, 2016/06/28 13:16:34]

Sami and I chatted a bit about this. Are you sure you want Idle signal as
whenever not RAL - this will be most of the time, and I'm assuming you want to
use the Idle signal for something like the memory reducer (which currently
happens only when the page goes inactive - i.e., in the background or no frames
for a significant period of time).

[ulan, 2016/06/28 13:30:43]

Indeed, idle defined as "page goes inactive" would be much more useful signal
for us than idle defined as "not RAL". I guess it is difficult to detect "page
goes inactive" for foreground tab?

[Sami, 2016/06/28 13:53:18]

It shouldn't be too difficult, but we just have to define what "I" actually
means. I've added a TODO -- let's talk about what the most useful signal is
(both for v8 and speed-infra).

[ulan, 2016/06/28 14:47:25]

Thank you! Related note: we discussed DEFAULT mode with Hannes and Michael. The
transition from RAIL to DEFAULT is problematic and adds unnecessary complexity.
Effectively we will have RAILD instead of RAIL, but our heuristics for DEFAULT
will probably be the same as for A.

We are going to remove DEFAULT mode and make A the default.

[Sami, 2016/06/28 15:01:37]

Right, I was wondering about the difference between those two. I can make the
same change in my patch. It does, however, mean that we're most of the time in
ANIMATE mode.  Would it be worth switching to IDLE when we're not actively
drawing and after a delay to INACTIVE that Ross suggested? Or should we just
stay in ANIMATE and go to IDLE after a longer delay?

+  else
+    new_policy.rail_mode = v8::PERFORMANCE_ANIMATION;
+
   switch (use_case) {
     case UseCase::COMPOSITOR_GESTURE:
       if (touchstart_expected_soon) {
+        new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
         expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
         new_policy.compositor_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       } else {
         // What we really want to do is priorize loading tasks, but that doesn't
         // seem to be safe. Instead we do that by proxy by deprioritizing
         // compositor tasks. This should be safe since we've already gone to the
         // pain of fixing ordering issues with them.
         new_policy.compositor_queue_policy.priority =
             TaskQueue::BEST_EFFORT_PRIORITY;
       }
       break;
 
     case UseCase::SYNCHRONIZED_GESTURE:
       new_policy.compositor_queue_policy.priority =
           main_thread_compositing_is_fast ? TaskQueue::HIGH_PRIORITY
                                           : TaskQueue::NORMAL_PRIORITY;
       if (touchstart_expected_soon) {
+        new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
         expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       } else {
+        new_policy.rail_mode = v8::PERFORMANCE_ANIMATION;
         expensive_task_policy = ExpensiveTaskPolicy::THROTTLE;
       }
       break;
 
     case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
       // In main thread input handling scenarios we don't have perfect knowledge
       // about which things we should be prioritizing, so we don't attempt to
       // block expensive tasks because we don't know whether they were integral
       // to the page's functionality or not.
+      new_policy.rail_mode = v8::PERFORMANCE_ANIMATION;
       new_policy.compositor_queue_policy.priority =
           main_thread_compositing_is_fast ? TaskQueue::HIGH_PRIORITY
                                           : TaskQueue::NORMAL_PRIORITY;
       break;
 
     case UseCase::MAIN_THREAD_GESTURE:
       // A main thread gesture is for example a scroll gesture which is handled
       // by the main thread. Since we know the established gesture type, we can
       // be a little more aggressive about prioritizing compositing and input
       // handling over other tasks.
       new_policy.compositor_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       if (touchstart_expected_soon) {
+        new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
         expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       } else {
+        new_policy.rail_mode = v8::PERFORMANCE_ANIMATION;
         expensive_task_policy = ExpensiveTaskPolicy::THROTTLE;
       }
       break;
 
     case UseCase::TOUCHSTART:
+      new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
       new_policy.compositor_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       new_policy.loading_queue_policy.is_enabled = false;
       new_policy.timer_queue_policy.is_enabled = false;
       // NOTE this is a nop due to the above.
       expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       break;
 
     case UseCase::NONE:
       // It's only safe to block tasks that if we are expecting a compositor
       // driven gesture.
       if (touchstart_expected_soon &&
           AnyThread().last_gesture_was_compositor_driven) {
+        new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
         expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       }
       break;
 
     case UseCase::LOADING:
+      new_policy.rail_mode = v8::PERFORMANCE_LOAD;

[ulan, 2016/06/28 13:09:08]

The CL description says "A future patch will add support for the load mode."
Is this path currently unreachable?

[Sami, 2016/06/28 13:53:18]

Yes, we currently don't enter the loading use case (there's a TODO elsewhere in
this file). My tentative plan is to stay in L until first contentful/meaningful
paint (There's a slight chicken and egg problem here since we want to
deprioritize rendering during loading, but you need to render to get *out* of L.
I think we just need to experiment a bit more.)

       new_policy.loading_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       new_policy.default_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       break;
 
     default:
       NOTREACHED();
   }
 
+  if (MainThreadOnly().renderer_hidden)
+    new_policy.rail_mode = v8::PERFORMANCE_IDLE;
+
   if (expensive_task_policy == ExpensiveTaskPolicy::BLOCK &&
       (!MainThreadOnly().expensive_task_blocking_allowed ||
        !MainThreadOnly().have_seen_a_begin_main_frame ||
        MainThreadOnly().navigation_task_expected_count > 0)) {
     expensive_task_policy = ExpensiveTaskPolicy::RUN;
   }
 
   switch (expensive_task_policy) {
     case ExpensiveTaskPolicy::RUN:
       break;
@@ skipping 30 matching lines @@
     DCHECK(!new_policy.timer_queue_policy.is_enabled);
   }
 
   // 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));
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "use_case",
                  use_case);
+  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "rail_mode",
+                 new_policy.rail_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "touchstart_expected_soon",
                  MainThreadOnly().touchstart_expected_soon);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "expensive_task_policy", expensive_task_policy);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.loading_tasks_seem_expensive",
                  MainThreadOnly().loading_tasks_seem_expensive);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.timer_tasks_seem_expensive",
@@ skipping 22 matching lines @@
   }
   MainThreadOnly().have_reported_blocking_intervention_in_current_policy =
       false;
 
   // TODO(alexclarke): We shouldn't have to prioritize the default queue, but it
   // appears to be necessary since the order of loading tasks and IPCs (which
   // are mostly dispatched on the default queue) need to be preserved.
   ApplyTaskQueuePolicy(helper_.DefaultTaskRunner().get(),
                        MainThreadOnly().current_policy.default_queue_policy,
                        new_policy.default_queue_policy);
+  if (MainThreadOnly().rail_mode_observer &&
+      new_policy.rail_mode != MainThreadOnly().current_policy.rail_mode) {
+    MainThreadOnly().rail_mode_observer->OnRAILModeChanged(
+        new_policy.rail_mode);
+  }
 
   DCHECK(compositor_task_runner_->IsQueueEnabled());
   MainThreadOnly().current_policy = new_policy;
 }
 
 void RendererSchedulerImpl::ApplyTaskQueuePolicy(
     TaskQueue* task_queue,
     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) {
@@ skipping 176 matching lines @@
 
   if (optional_now.is_null())
     optional_now = helper_.scheduler_tqm_delegate()->NowTicks();
   std::unique_ptr<base::trace_event::TracedValue> state(
       new base::trace_event::TracedValue());
   state->SetBoolean(
       "has_visible_render_widget_with_touch_handler",
       MainThreadOnly().has_visible_render_widget_with_touch_handler);
   state->SetString("current_use_case",
                    UseCaseToString(MainThreadOnly().current_use_case));
+  state->SetString("rail_mode",
+                   RAILModeToString(MainThreadOnly().current_policy.rail_mode));
   state->SetBoolean("expensive_task_blocking_allowed",
                     MainThreadOnly().expensive_task_blocking_allowed);
   state->SetBoolean("loading_tasks_seem_expensive",
                     MainThreadOnly().loading_tasks_seem_expensive);
   state->SetBoolean("timer_tasks_seem_expensive",
                     MainThreadOnly().timer_tasks_seem_expensive);
   state->SetBoolean("begin_frame_not_expected_soon",
                     MainThreadOnly().begin_frame_not_expected_soon);
   state->SetBoolean("touchstart_expected_soon",
                     MainThreadOnly().touchstart_expected_soon);
@@ skipping 159 matching lines @@
   // Per-frame task runners (loading, timers, etc.) are configured with a more
   // specific blame context by WebFrameSchedulerImpl.
   control_task_runner_->SetBlameContext(blame_context);
   DefaultTaskRunner()->SetBlameContext(blame_context);
   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;
+}
+
 void RendererSchedulerImpl::RegisterTimeDomain(TimeDomain* time_domain) {
   helper_.RegisterTimeDomain(time_domain);
 }
 
 void RendererSchedulerImpl::UnregisterTimeDomain(TimeDomain* time_domain) {
   helper_.UnregisterTimeDomain(time_domain);
 }
 
 void RendererSchedulerImpl::SetExpensiveTaskBlockingAllowed(bool allowed) {
   MainThreadOnly().expensive_task_blocking_allowed = allowed;
 }
 
 base::TickClock* RendererSchedulerImpl::tick_clock() const {
   return helper_.scheduler_tqm_delegate().get();
 }
 
 void RendererSchedulerImpl::AddWebViewScheduler(
     WebViewSchedulerImpl* web_view_scheduler) {
-  MainThreadOnly().web_view_schedulers_.insert(web_view_scheduler);
+  MainThreadOnly().web_view_schedulers.insert(web_view_scheduler);
 }
 
 void RendererSchedulerImpl::RemoveWebViewScheduler(
     WebViewSchedulerImpl* web_view_scheduler) {
-  DCHECK(MainThreadOnly().web_view_schedulers_.find(web_view_scheduler) !=
-         MainThreadOnly().web_view_schedulers_.end());
-  MainThreadOnly().web_view_schedulers_.erase(web_view_scheduler);
+  DCHECK(MainThreadOnly().web_view_schedulers.find(web_view_scheduler) !=
+         MainThreadOnly().web_view_schedulers.end());
+  MainThreadOnly().web_view_schedulers.erase(web_view_scheduler);
 }
 
 void RendererSchedulerImpl::BroadcastConsoleWarning(
     const std::string& message) {
   helper_.CheckOnValidThread();
-  for (auto& web_view_scheduler : MainThreadOnly().web_view_schedulers_)
+  for (auto& web_view_scheduler : MainThreadOnly().web_view_schedulers)
     web_view_scheduler->AddConsoleWarning(message);
 }
 
 void RendererSchedulerImpl::OnTriedToExecuteBlockedTask(
     const TaskQueue& queue,
     const base::PendingTask& task) {
   if (!MainThreadOnly().expensive_task_blocking_allowed ||
       MainThreadOnly().current_use_case == UseCase::TOUCHSTART ||
       MainThreadOnly().longest_jank_free_task_duration <
           base::TimeDelta::FromMilliseconds(kRailsResponseTimeMillis) ||
@@ skipping 23 matching lines @@
         true;
     BroadcastConsoleWarning(
         "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.");
   }
 }
 
+// static
+const char* RendererSchedulerImpl::UseCaseToString(UseCase use_case) {
+  switch (use_case) {
+    case UseCase::NONE:
+      return "none";
+    case UseCase::COMPOSITOR_GESTURE:
+      return "compositor_gesture";
+    case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
+      return "main_thread_custom_input_handling";
+    case UseCase::SYNCHRONIZED_GESTURE:
+      return "synchronized_gesture";
+    case UseCase::TOUCHSTART:
+      return "touchstart";
+    case UseCase::LOADING:
+      return "loading";
+    case UseCase::MAIN_THREAD_GESTURE:
+      return "main_thread_gesture";
+    default:
+      NOTREACHED();
+      return nullptr;
+  }
+}
+
+// static
+const char* RendererSchedulerImpl::RAILModeToString(v8::RAILMode rail_mode) {
+  switch (rail_mode) {
+    case v8::PERFORMANCE_DEFAULT:
+      return "default";
+    case v8::PERFORMANCE_RESPONSE:
+      return "response";
+    case v8::PERFORMANCE_ANIMATION:
+      return "animation";
+    case v8::PERFORMANCE_IDLE:
+      return "idle";
+    case v8::PERFORMANCE_LOAD:
+      return "load";
+    default:
+      NOTREACHED();
+      return nullptr;
+  }
+}
+
 }  // namespace scheduler