[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 = std::queue<Task>();
   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() && !BlockedByFenceLocked());
+    any_thread().task_queue_manager->OnQueueHasImmediateWork(
+        this, ensure_do_work_posted);
+    any_thread().time_domain->OnQueueHasImmediateWork(this);
   }
+
   any_thread().immediate_incoming_queue.emplace(
-      posted_from, task, desired_run_time, sequence_number, nestable, sequence_number);
-  any_thread().task_queue_manager->DidQueueTask( any_thread().immediate_incoming_queue.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;
+
+  base::AutoLock lock(any_thread_lock_);
+  if (any_thread().immediate_incoming_queue.empty())
+    return;
+
+  main_thread_only().immediate_work_queue->SwapLocked(
+      any_thread().immediate_incoming_queue);
+}
+
+void TaskQueueImpl::OnImmediateWorkQueueHasBecomeEmpty(
+    std::queue<TaskQueueImpl::Task>* work_queue) {
+  base::AutoLock lock(any_thread_lock_);
+  DCHECK(work_queue->empty());
+
+  if (any_thread().immediate_incoming_queue.empty())
+    return;
+
+  std::swap(any_thread().immediate_incoming_queue, *work_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);
   main_thread_only().time_domain = time_domain;
 }
 
 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 75 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 {
+  any_thread_lock_.AssertAcquired();
+
   if (!main_thread_only().current_fence)
     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())
     return true;
@@ skipping 131 matching lines @@
 std::unique_ptr<TaskQueueImpl::QueueEnabledVoter>
 TaskQueueImpl::CreateQueueEnabledVoter() {
   main_thread_only().voter_refcount++;
   main_thread_only().is_enabled_refcount++;
   return base::MakeUnique<QueueEnabledVoterImpl>(this);
 }
 
 }  // namespace internal
 }  // namespace scheduler
 }  // namespace blink