TaskScheduler: Avoid Sequence refcount bump in GetWork()

base/task_scheduler/scheduler_thread_pool_impl.cc

 // Copyright 2016 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 "base/task_scheduler/scheduler_thread_pool_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 258 matching lines @@
     }
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 void SchedulerThreadPoolImpl::ReEnqueueSequence(
     scoped_refptr<Sequence> sequence,
     const SequenceSortKey& sequence_sort_key) {
-  shared_priority_queue_.BeginTransaction()->Push(
-      WrapUnique(new PriorityQueue::SequenceAndSortKey(std::move(sequence),
-                                                       sequence_sort_key)));
+  shared_priority_queue_.BeginTransaction()->Push(std::move(sequence),
+                                                  sequence_sort_key);
 
   // The thread calling this method just ran a Task from |sequence| and will
   // soon try to get another Sequence from which to run a Task. If the thread
   // belongs to this pool, it will get that Sequence from
   // |shared_priority_queue_|. When that's the case, there is no need to wake up
   // another thread after |sequence| is inserted in |shared_priority_queue_|. If
   // we did wake up another thread, we would waste resources by having more
   // threads trying to get a Sequence from |shared_priority_queue_| than the
   // number of Sequences in it.
   if (tls_current_thread_pool.Get().Get() != this)
@@ skipping 48 matching lines @@
 
   const bool sequence_was_empty = sequence->PushTask(std::move(task));
   if (sequence_was_empty) {
     // Insert |sequence| in |priority_queue| if it was empty before |task| was
     // inserted into it. Otherwise, one of these must be true:
     // - |sequence| is already in a PriorityQueue (not necessarily
     //   |shared_priority_queue_|), or,
     // - A worker thread is running a Task from |sequence|. It will insert
     //   |sequence| in a PriorityQueue once it's done running the Task.
     const auto sequence_sort_key = sequence->GetSortKey();
-    priority_queue->BeginTransaction()->Push(
-        WrapUnique(new PriorityQueue::SequenceAndSortKey(std::move(sequence),
-                                                         sequence_sort_key)));
+    priority_queue->BeginTransaction()->Push(std::move(sequence),
+                                             sequence_sort_key);
 
     // Wake up a worker thread to process |sequence|.
     if (worker_thread)
       worker_thread->WakeUp();
     else
       WakeUpOneThread();
   }
 }
 
 SchedulerThreadPoolImpl::SchedulerWorkerThreadDelegateImpl::
@@ skipping 25 matching lines @@
 
 scoped_refptr<Sequence>
 SchedulerThreadPoolImpl::SchedulerWorkerThreadDelegateImpl::GetWork(
     SchedulerWorkerThread* worker_thread) {
   DCHECK(ContainsWorkerThread(outer_->worker_threads_, worker_thread));
 
   scoped_refptr<Sequence> sequence;
   {
     std::unique_ptr<PriorityQueue::Transaction> shared_transaction(
         outer_->shared_priority_queue_.BeginTransaction());
-    const auto& shared_sequence_and_sort_key = shared_transaction->Peek();
-
     std::unique_ptr<PriorityQueue::Transaction> single_threaded_transaction(
         single_threaded_priority_queue_.BeginTransaction());
-    const auto& single_threaded_sequence_and_sort_key =
-        single_threaded_transaction->Peek();
 
-    if (shared_sequence_and_sort_key.is_null() &&
-        single_threaded_sequence_and_sort_key.is_null()) {
+    if (shared_transaction->IsEmpty() &&
+        single_threaded_transaction->IsEmpty()) {
       single_threaded_transaction.reset();
 
       // |shared_transaction| is kept alive while |worker_thread| is added to
       // |idle_worker_threads_stack_| to avoid this race:
       // 1. This thread creates a Transaction, finds |shared_priority_queue_|
       //    empty and ends the Transaction.
       // 2. Other thread creates a Transaction, inserts a Sequence into
       //    |shared_priority_queue_| and ends the Transaction. This can't happen
       //    if the Transaction of step 1 is still active because because there
       //    can only be one active Transaction per PriorityQueue at a time.
       // 3. Other thread calls WakeUpOneThread(). No thread is woken up because
       //    |idle_worker_threads_stack_| is empty.
       // 4. This thread adds itself to |idle_worker_threads_stack_| and goes to
       //    sleep. No thread runs the Sequence inserted in step 2.
       outer_->AddToIdleWorkerThreadsStack(worker_thread);
       return nullptr;
     }
 
     // True if both PriorityQueues have Sequences and the Sequence at the top of
     // the shared PriorityQueue is more important.
     const bool shared_sequence_is_more_important =
-        !shared_sequence_and_sort_key.is_null() &&
-        !single_threaded_sequence_and_sort_key.is_null() &&
-        shared_sequence_and_sort_key.sort_key >
-            single_threaded_sequence_and_sort_key.sort_key;
+        !shared_transaction->IsEmpty() &&
+        !single_threaded_transaction->IsEmpty() &&
+        shared_transaction->PeekSortKey() >
+            single_threaded_transaction->PeekSortKey();
 
-    if (single_threaded_sequence_and_sort_key.is_null() ||
+    if (single_threaded_transaction->IsEmpty() ||
         shared_sequence_is_more_important) {
-      sequence = shared_sequence_and_sort_key.sequence;
-      shared_transaction->Pop();
+      sequence = shared_transaction->PopSequence();
       last_sequence_is_single_threaded_ = false;
     } else {
-      DCHECK(!single_threaded_sequence_and_sort_key.is_null());
-      sequence = single_threaded_sequence_and_sort_key.sequence;
-      single_threaded_transaction->Pop();
+      DCHECK(!single_threaded_transaction->IsEmpty());
+      sequence = single_threaded_transaction->PopSequence();
       last_sequence_is_single_threaded_ = true;
     }
   }
   DCHECK(sequence);
 
   outer_->RemoveFromIdleWorkerThreadsStack(worker_thread);
   return sequence;
 }
 
 void SchedulerThreadPoolImpl::SchedulerWorkerThreadDelegateImpl::
     ReEnqueueSequence(scoped_refptr<Sequence> sequence) {
   if (last_sequence_is_single_threaded_) {
     // A single-threaded Sequence is always re-enqueued in the single-threaded
     // PriorityQueue from which it was extracted.
     const SequenceSortKey sequence_sort_key = sequence->GetSortKey();
     single_threaded_priority_queue_.BeginTransaction()->Push(
-        WrapUnique(new PriorityQueue::SequenceAndSortKey(std::move(sequence),
-                                                         sequence_sort_key)));
+        std::move(sequence), sequence_sort_key);
   } else {
     // |re_enqueue_sequence_callback_| will determine in which PriorityQueue
     // |sequence| must be enqueued.
     re_enqueue_sequence_callback_.Run(std::move(sequence));
   }
 }
 
 SchedulerThreadPoolImpl::SchedulerThreadPoolImpl(
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager)
@@ skipping 59 matching lines @@
 }
 
 void SchedulerThreadPoolImpl::RemoveFromIdleWorkerThreadsStack(
     SchedulerWorkerThread* worker_thread) {
   AutoSchedulerLock auto_lock(idle_worker_threads_stack_lock_);
   idle_worker_threads_stack_.Remove(worker_thread);
 }
 
 }  // namespace internal
 }  // namespace base