[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);
-    }
+    any_thread().task_queue_manager->OnQueueHasImmediateWork(this);
+    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::OnIncomingImmediateTaskAvailable() {

[Sami, 2016/12/05 17:52:54]

I think having this method makes sense but the name feels misleading because
it's not called synchronously in response to an immediate task becoming
available, and hence needs to do some extra checking. Should we call this
something like ReloadImmediateWorkQueue()? (Could have Maybe in there too if you
prefer.)

[alex clarke (OOO till 29th), 2016/12/06 17:37:54]

Done.

+  // Note a call to OnImmediateWorkQueueHasBecomeEmpty could have got here first
+  // so there may not actually be any work to do.
+  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 55 matching lines @@
   }
 
   // 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());
   }
 }
 
-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;
-}
-
 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.
   // TODO(alexclarke): We should find another way of tracing this
   if (base::PlatformThread::CurrentId() != thread_id_)
@@ skipping 120 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