Add Thread Standby Policy SchedulerWorkerPoolImpl

base/task_scheduler/scheduler_worker_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_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 295 matching lines @@
 std::unique_ptr<SchedulerWorkerPoolImpl> SchedulerWorkerPoolImpl::Create(
     const SchedulerWorkerPoolParams& params,
     const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager) {
   std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool(
       new SchedulerWorkerPoolImpl(params.name(),
                                   params.io_restriction(),
                                   params.suggested_reclaim_time(),
                                   task_tracker, delayed_task_manager));
-  if (worker_pool->Initialize(params.priority_hint(), params.max_threads(),
-                              re_enqueue_sequence_callback)) {
+  if (worker_pool->Initialize(
+          params.priority_hint(), params.standby_thread_policy(),
+          params.max_threads(), re_enqueue_sequence_callback)) {
     return worker_pool;
   }
   return nullptr;
 }
 
 scoped_refptr<TaskRunner> SchedulerWorkerPoolImpl::CreateTaskRunnerWithTraits(
     const TaskTraits& traits) {
   return make_scoped_refptr(new SchedulerParallelTaskRunner(traits, this));
 }
 
@@ skipping 117 matching lines @@
     worker->JoinForTesting();
 
   DCHECK(!join_for_testing_returned_.IsSignaled());
   join_for_testing_returned_.Signal();
 }
 
 void SchedulerWorkerPoolImpl::DisallowWorkerDetachmentForTesting() {
   worker_detachment_disallowed_.Set();
 }
 
+size_t SchedulerWorkerPoolImpl::NumberOfAliveWorkersForTesting() {
+  size_t num_alive_workers = 0;
+  for (const auto& worker : workers_) {
+    if (worker->ThreadAliveForTesting())
+      ++num_alive_workers;
+  }
+  return num_alive_workers;
+}
+
 SchedulerWorkerPoolImpl::SchedulerSingleThreadTaskRunner::
     SchedulerSingleThreadTaskRunner(const TaskTraits& traits,
                                     SchedulerWorkerPool* worker_pool,
                                     SchedulerWorker* worker)
     : traits_(traits),
       worker_pool_(worker_pool),
       worker_(worker) {
   DCHECK(worker_pool_);
   DCHECK(worker_);
   static_cast<SchedulerWorkerDelegateImpl*>(worker_->delegate())->
@@ skipping 244 matching lines @@
           50,
           HistogramBase::kUmaTargetedHistogramFlag)),
       task_tracker_(task_tracker),
       delayed_task_manager_(delayed_task_manager) {
   DCHECK(task_tracker_);
   DCHECK(delayed_task_manager_);
 }
 
 bool SchedulerWorkerPoolImpl::Initialize(
     ThreadPriority priority_hint,
+    SchedulerWorkerPoolParams::StandbyThreadPolicy standby_thread_policy,
     size_t max_threads,
     const ReEnqueueSequenceCallback& re_enqueue_sequence_callback) {
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
 
   DCHECK(workers_.empty());
   workers_.resize(max_threads);
 
   // Create workers and push them to the idle stack in reverse order of index.
   // This ensures that they are woken up in order of index and that the ALIVE
   // worker is on top of the stack.
   for (int index = max_threads - 1; index >= 0; --index) {
+    const bool is_standby_lazy =
+        standby_thread_policy ==
+        SchedulerWorkerPoolParams::StandbyThreadPolicy::LAZY;
     const SchedulerWorker::InitialState initial_state =
-        (index == 0) ? SchedulerWorker::InitialState::ALIVE
-                     : SchedulerWorker::InitialState::DETACHED;
+        (index == 0 && !is_standby_lazy)
+            ? SchedulerWorker::InitialState::ALIVE
+            : SchedulerWorker::InitialState::DETACHED;
     std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
         priority_hint,
         MakeUnique<SchedulerWorkerDelegateImpl>(
             this, re_enqueue_sequence_callback, &shared_priority_queue_, index),
         task_tracker_, initial_state);
     if (!worker)
       break;
     idle_workers_stack_.Push(worker.get());
     workers_[index] = std::move(worker);
   }
 
 #if DCHECK_IS_ON()
   workers_created_.Signal();
 #endif
 
   return !workers_.empty();
 }
 
 void SchedulerWorkerPoolImpl::WakeUpWorker(SchedulerWorker* worker) {
   DCHECK(worker);
   RemoveFromIdleWorkersStack(worker);
   worker->WakeUp();
+  // TOOD(robliao): Honor StandbyThreadPolicy::ONE here and consider adding
+  // hysteresis to the CanDetach check. See https://crbug.com/666041.
 }
 
 void SchedulerWorkerPoolImpl::WakeUpOneWorker() {
   SchedulerWorker* worker;
   {
     AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
     worker = idle_workers_stack_.Pop();
   }
   if (worker)
     worker->WakeUp();
@@ skipping 25 matching lines @@
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
   idle_workers_stack_.Remove(worker);
 }
 
 bool SchedulerWorkerPoolImpl::CanWorkerDetachForTesting() {
   return !worker_detachment_disallowed_.IsSet();
 }
 
 }  // namespace internal
 }  // namespace base