[Try # 3] Scheduler refactoring to virtually eliminate redundant DoWorks

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc

 // Copyright 2015 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/base/task_queue_impl.h"
 
 #include "base/format_macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/blame_context.h"
@@ skipping 136 matching lines @@
     : task_queue_manager(task_queue_manager), time_domain(time_domain) {}
 
 TaskQueueImpl::AnyThread::~AnyThread() {}
 
 TaskQueueImpl::MainThreadOnly::MainThreadOnly(
     TaskQueueManager* task_queue_manager,
     TaskQueueImpl* task_queue,
     TimeDomain* time_domain)
     : task_queue_manager(task_queue_manager),
       time_domain(time_domain),
-      delayed_work_queue(new WorkQueue(task_queue, "delayed")),
-      immediate_work_queue(new WorkQueue(task_queue, "immediate")),
+      delayed_work_queue(
+          new WorkQueue(task_queue, "delayed", WorkQueue::QueueType::DELAYED)),
+      immediate_work_queue(new WorkQueue(task_queue,
+                                         "immediate",
+                                         WorkQueue::QueueType::IMMEDIATE)),
       set_index(0),
       is_enabled_refcount(0),
       voter_refcount(0),
       blame_context(nullptr),
       current_fence(0) {}
 
 TaskQueueImpl::MainThreadOnly::~MainThreadOnly() {}
 
 void TaskQueueImpl::UnregisterTaskQueue() {
   base::AutoLock lock(any_thread_lock_);
   if (main_thread_only().time_domain)
     main_thread_only().time_domain->UnregisterQueue(this);
   if (!any_thread().task_queue_manager)
     return;
   any_thread().time_domain = nullptr;
   main_thread_only().time_domain = nullptr;
   any_thread().task_queue_manager->UnregisterTaskQueue(this);
 
   any_thread().task_queue_manager = nullptr;
   main_thread_only().task_queue_manager = nullptr;
   main_thread_only().delayed_incoming_queue = std::priority_queue<Task>();
   any_thread().immediate_incoming_queue.clear();
   main_thread_only().immediate_work_queue.reset();
   main_thread_only().delayed_work_queue.reset();
 }
 
 bool TaskQueueImpl::RunsTasksOnCurrentThread() const {
-  base::AutoLock lock(any_thread_lock_);
   return base::PlatformThread::CurrentId() == thread_id_;
 }
 
 bool TaskQueueImpl::PostDelayedTask(const tracked_objects::Location& from_here,
                                     const base::Closure& task,
                                     base::TimeDelta delay) {
   if (delay.is_zero())
     return PostImmediateTaskImpl(from_here, task, TaskType::NORMAL);
 
   return PostDelayedTaskImpl(from_here, task, delay, TaskType::NORMAL);
@@ skipping 121 matching lines @@
   }
   TraceQueueSize(false);
 }
 
 void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(
     const tracked_objects::Location& posted_from,
     const base::Closure& task,
     base::TimeTicks desired_run_time,
     EnqueueOrder sequence_number,
     bool nestable) {
-  if (any_thread().immediate_incoming_queue.empty())
-    any_thread().time_domain->RegisterAsUpdatableTaskQueue(this);
   // If the |immediate_incoming_queue| is empty we need a DoWork posted to make
   // it run.
   if (any_thread().immediate_incoming_queue.empty()) {
-    // There's no point posting a DoWork for a disabled queue, however we can
-    // only tell if it's disabled from the main thread.
-    if (base::PlatformThread::CurrentId() == thread_id_) {
-      if (IsQueueEnabled() && !BlockedByFenceLocked())
-        any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
-    } else {
-      any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
-    }
+    // There's no point posting a DoWork for a blocked or disabled queue,
+    // although we can only determine that on the main thread.
+    bool ensure_do_work_posted =
+        !RunsTasksOnCurrentThread() ||
+        (IsQueueEnabled() && !main_thread_only().current_fence);
+    any_thread().task_queue_manager->OnQueueHasIncomingImmediateWork(
+        this, ensure_do_work_posted);
+    any_thread().time_domain->OnQueueHasImmediateWork(this);
   }
   any_thread().immediate_incoming_queue.emplace_back(
       posted_from, task, desired_run_time, sequence_number, nestable,
       sequence_number);
   any_thread().task_queue_manager->DidQueueTask(
       any_thread().immediate_incoming_queue.back());
   TraceQueueSize(true);
 }
 
+void TaskQueueImpl::ReloadImmediateWorkQueueIfEmpty() {
+  if (!main_thread_only().immediate_work_queue->Empty())
+    return;
+
+  main_thread_only().immediate_work_queue->ReloadEmptyImmediateQueue();
+}
+
+WTF::Deque<TaskQueueImpl::Task> TaskQueueImpl::TakeImmediateIncomingQueue() {
+  base::AutoLock lock(any_thread_lock_);
+  WTF::Deque<TaskQueueImpl::Task> queue;
+  queue.swap(any_thread().immediate_incoming_queue);
+  return queue;
+}
+
 bool TaskQueueImpl::IsEmpty() const {
   if (!main_thread_only().delayed_work_queue->Empty() ||
       !main_thread_only().delayed_incoming_queue.empty() ||
       !main_thread_only().immediate_work_queue->Empty()) {
     return false;
   }
 
   base::AutoLock lock(any_thread_lock_);
   return any_thread().immediate_incoming_queue.empty();
 }
@@ skipping 29 matching lines @@
   return !any_thread().immediate_incoming_queue.empty();
 }
 
 base::Optional<base::TimeTicks> TaskQueueImpl::GetNextScheduledWakeUp() {
   if (main_thread_only().delayed_incoming_queue.empty())
     return base::nullopt;
 
   return main_thread_only().delayed_incoming_queue.top().delayed_run_time;
 }
 
-void TaskQueueImpl::WakeUpForDelayedWork(LazyNow* lazy_now) {
+base::Optional<base::TimeTicks> TaskQueueImpl::WakeUpForDelayedWork(
+    LazyNow* lazy_now) {
   // Enqueue all delayed tasks that should be running now, skipping any that
   // have been canceled.
   while (!main_thread_only().delayed_incoming_queue.empty()) {
     Task& task =
         const_cast<Task&>(main_thread_only().delayed_incoming_queue.top());
     if (task.task.IsCancelled()) {
       main_thread_only().delayed_incoming_queue.pop();
       continue;
     }
     if (task.delayed_run_time > lazy_now->Now())
       break;
     task.set_enqueue_order(
         main_thread_only().task_queue_manager->GetNextSequenceNumber());
     main_thread_only().delayed_work_queue->Push(std::move(task));
     main_thread_only().delayed_incoming_queue.pop();
   }
 
   // Make sure the next wake up is scheduled.
-  if (!main_thread_only().delayed_incoming_queue.empty()) {
-    main_thread_only().time_domain->ScheduleDelayedWork(
-        this, main_thread_only().delayed_incoming_queue.top().delayed_run_time,
-        lazy_now->Now());
-  }
-}
+  if (!main_thread_only().delayed_incoming_queue.empty())
+    return main_thread_only().delayed_incoming_queue.top().delayed_run_time;
 
-bool TaskQueueImpl::MaybeUpdateImmediateWorkQueues() {
-  if (!main_thread_only().task_queue_manager)
-    return false;
-
-  if (!main_thread_only().immediate_work_queue->Empty())
-    return true;
-
-  base::AutoLock lock(any_thread_lock_);
-  main_thread_only().immediate_work_queue->SwapLocked(
-      any_thread().immediate_incoming_queue);
-  // |immediate_work_queue| is now empty so updates are no longer required.
-  return false;
+  return base::Optional<base::TimeTicks>();
 }
 
 void TaskQueueImpl::TraceQueueSize(bool is_locked) const {
   bool is_tracing;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(disabled_by_default_tracing_category_,
                                      &is_tracing);
   if (!is_tracing)
     return;
 
   // It's only safe to access the work queues from the main thread.
@@ skipping 122 matching lines @@
     // another way of asserting that UnregisterTaskQueue has not been called.
     DCHECK(any_thread().time_domain);
     if (!any_thread().time_domain)
       return;
     DCHECK(main_thread_checker_.CalledOnValidThread());
     if (time_domain == main_thread_only().time_domain)
       return;
 
     any_thread().time_domain = time_domain;
   }
-  // We rely here on TimeDomain::MigrateQueue being thread-safe to use with
-  // TimeDomain::Register/UnregisterAsUpdatableTaskQueue.
-  main_thread_only().time_domain->MigrateQueue(this, time_domain);
+
+  base::TimeTicks wake_up_time =
+      main_thread_only().time_domain->MigrateQueue(this, time_domain);
   main_thread_only().time_domain = time_domain;
+
+  if (!wake_up_time.is_null())
+    time_domain->ScheduleDelayedWork(this, wake_up_time, time_domain->Now());
 }
 
 TimeDomain* TaskQueueImpl::GetTimeDomain() const {
   if (base::PlatformThread::CurrentId() == thread_id_)
     return main_thread_only().time_domain;
 
   base::AutoLock lock(any_thread_lock_);
   return any_thread().time_domain;
 }
 
@@ skipping 72 matching lines @@
   }
 
   base::AutoLock lock(any_thread_lock_);
   if (any_thread().immediate_incoming_queue.empty())
     return true;
 
   return any_thread().immediate_incoming_queue.front().enqueue_order() >
          main_thread_only().current_fence;
 }
 
-bool TaskQueueImpl::BlockedByFenceLocked() const {
-  if (!main_thread_only().current_fence)
+bool TaskQueueImpl::ImmediateTaskCouldRun() const {
+  if (!IsQueueEnabled())
     return false;
 
-  if (!main_thread_only().immediate_work_queue->BlockedByFence() ||
-      !main_thread_only().delayed_work_queue->BlockedByFence()) {
-    return false;
-  }
-
-  if (any_thread().immediate_incoming_queue.empty())
+  if (!main_thread_only().current_fence)
     return true;
 
-  return any_thread().immediate_incoming_queue.front().enqueue_order() >
+  base::AutoLock lock(any_thread_lock_);
+  // If |immediate_incoming_queue| is empty then any task posted is guaranteed
+  // to be blocked by the fence.
+  if (any_thread().immediate_incoming_queue.empty())
+    return false;
+
+  return any_thread().immediate_incoming_queue.front().enqueue_order() <
          main_thread_only().current_fence;
 }
 
 EnqueueOrder TaskQueueImpl::GetFenceForTest() const {
   return main_thread_only().current_fence;
 }
 
 // static
 void TaskQueueImpl::QueueAsValueInto(const WTF::Deque<Task>& queue,
                                      base::trace_event::TracedValue* state) {
@@ skipping 94 matching lines @@
   bool is_enabled = IsQueueEnabled();
   if (was_enabled != is_enabled)
     EnableOrDisableWithSelector(is_enabled);
 }
 
 void TaskQueueImpl::EnableOrDisableWithSelector(bool enable) {
   if (!main_thread_only().task_queue_manager)
     return;
 
   if (enable) {
-    // Note it's the job of the selector to tell the TaskQueueManager if
-    // a DoWork needs posting.
+    // Note the selector calls TaskQueueManager::OnTaskQueueEnabled which posts
+    // a DoWork if needed.
     main_thread_only().task_queue_manager->selector_.EnableQueue(this);
   } else {
     main_thread_only().task_queue_manager->selector_.DisableQueue(this);
   }
 }
 
 std::unique_ptr<TaskQueueImpl::QueueEnabledVoter>
 TaskQueueImpl::CreateQueueEnabledVoter() {
   main_thread_only().voter_refcount++;
   main_thread_only().is_enabled_refcount++;
   return base::MakeUnique<QueueEnabledVoterImpl>(this);
 }
 
 void TaskQueueImpl::SweepCanceledDelayedTasks(base::TimeTicks now) {
   if (main_thread_only().delayed_incoming_queue.empty())
     return;
 
   base::TimeTicks first_task_runtime =
       main_thread_only().delayed_incoming_queue.top().delayed_run_time;
 
-  // TODO(alexclarke): Let this remove all tasks once the DoWork refactor has
-  // landed.
+  // Remove canceled tasks.
   std::priority_queue<Task> remaining_tasks;
   while (!main_thread_only().delayed_incoming_queue.empty()) {
-    if (!main_thread_only().delayed_incoming_queue.top().task.IsCancelled() ||
-        main_thread_only().delayed_incoming_queue.top().delayed_run_time ==
-            first_task_runtime) {
+    if (!main_thread_only().delayed_incoming_queue.top().task.IsCancelled()) {
       remaining_tasks.push(std::move(
           const_cast<Task&>(main_thread_only().delayed_incoming_queue.top())));
     }
     main_thread_only().delayed_incoming_queue.pop();
   }
+
   main_thread_only().delayed_incoming_queue = std::move(remaining_tasks);
+
+  // Re-schedule delayed call to WakeUpForDelayedWork if needed.
+  if (main_thread_only().delayed_incoming_queue.empty()) {
+    main_thread_only().time_domain->CancelDelayedWork(this);
+  } else if (first_task_runtime !=
+             main_thread_only().delayed_incoming_queue.top().delayed_run_time) {
+    main_thread_only().time_domain->ScheduleDelayedWork(
+        this, main_thread_only().delayed_incoming_queue.top().delayed_run_time,
+        main_thread_only().time_domain->Now());
+  }
+}
+
+void TaskQueueImpl::PushImmediateIncomingTaskForTest(
+    TaskQueueImpl::Task&& task) {
+  base::AutoLock lock(any_thread_lock_);
+  any_thread().immediate_incoming_queue.push_back(std::move(task));
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink