Separate the create and start phases in SchedulerSingleThreadTaskRunnerManager.

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 188 matching lines @@
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager)
     : name_(name),
       priority_hint_(priority_hint),
       re_enqueue_sequence_callback_(std::move(re_enqueue_sequence_callback)),
       idle_workers_stack_lock_(shared_priority_queue_.container_lock()),
       idle_workers_stack_cv_for_testing_(
           idle_workers_stack_lock_.CreateConditionVariable()),
       join_for_testing_returned_(WaitableEvent::ResetPolicy::MANUAL,
                                  WaitableEvent::InitialState::NOT_SIGNALED),
-#if DCHECK_IS_ON()
-      workers_created_(WaitableEvent::ResetPolicy::MANUAL,
-                       WaitableEvent::InitialState::NOT_SIGNALED),
-#endif
       // Mimics the UMA_HISTOGRAM_LONG_TIMES macro.
       detach_duration_histogram_(Histogram::FactoryTimeGet(
           kDetachDurationHistogramPrefix + name_ + kPoolNameSuffix,
           TimeDelta::FromMilliseconds(1),
           TimeDelta::FromHours(1),
           50,
           HistogramBase::kUmaTargetedHistogramFlag)),
       // Mimics the UMA_HISTOGRAM_COUNTS_1000 macro. When a worker runs more
       // than 1000 tasks before detaching, there is no need to know the exact
       // number of tasks that ran.
@@ skipping 15 matching lines @@
           HistogramBase::kUmaTargetedHistogramFlag)),
       task_tracker_(task_tracker),
       delayed_task_manager_(delayed_task_manager) {
   DCHECK(task_tracker_);
   DCHECK(delayed_task_manager_);
 }
 
 void SchedulerWorkerPoolImpl::Start(const SchedulerWorkerPoolParams& params) {
   suggested_reclaim_time_ = params.suggested_reclaim_time();
 
-  std::vector<SchedulerWorker*> workers_to_wake_up;
-
   {
     AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
 
 #if DCHECK_IS_ON()
-    DCHECK(!workers_created_.IsSignaled());
+    DCHECK(!workers_created_.IsSet());
 #endif
 
     DCHECK(workers_.empty());
     workers_.resize(params.max_threads());
 
     // The number of workers created alive is |num_wake_ups_before_start_|, plus
     // one if the standby thread policy is ONE (in order to start with one alive
     // idle worker).
     const int num_alive_workers =
         num_wake_ups_before_start_ +
         (params.standby_thread_policy() ==
                  SchedulerWorkerPoolParams::StandbyThreadPolicy::ONE
              ? 1
              : 0);
 
     // Create workers in reverse order of index so that the worker with the
     // highest index is at the bottom of the idle stack.
     for (int index = params.max_threads() - 1; index >= 0; --index) {
-      const SchedulerWorker::InitialState initial_state =
-          index < num_alive_workers ? SchedulerWorker::InitialState::ALIVE
-                                    : SchedulerWorker::InitialState::DETACHED;
-      scoped_refptr<SchedulerWorker> worker = SchedulerWorker::Create(
+      workers_[index] = make_scoped_refptr(new SchedulerWorker(
           params.priority_hint(),
           MakeUnique<SchedulerWorkerDelegateImpl>(
               this, re_enqueue_sequence_callback_, index),
-          task_tracker_, initial_state, params.backward_compatibility());
-      if (!worker)
-        break;
+          task_tracker_, params.backward_compatibility(),
+          index < num_alive_workers ? SchedulerWorker::InitialState::ALIVE
+                                    : SchedulerWorker::InitialState::DETACHED));
 
-      if (index < num_wake_ups_before_start_)
-        workers_to_wake_up.push_back(worker.get());
-      else
-        idle_workers_stack_.Push(worker.get());
-
-      workers_[index] = std::move(worker);
+      // Put workers that won't be woken up at the end of this method on the
+      // idle stack.
+      if (index >= num_wake_ups_before_start_)
+        idle_workers_stack_.Push(workers_[index].get());
     }
 
 #if DCHECK_IS_ON()
-    workers_created_.Signal();
+    workers_created_.Set();
 #endif
-
-    CHECK(!workers_.empty());
   }
 
-  for (SchedulerWorker* worker : workers_to_wake_up)
-    worker->WakeUp();
+  // Start all workers. CHECK that the first worker can be started (assume that
+  // failure means that threads can't be created on this machine). Wake up one
+  // worker for each wake up that occurred before Start().
+  for (size_t index = 0; index < workers_.size(); ++index) {
+    const bool start_success = workers_[index]->Start();
+    CHECK(start_success || index > 0);
+    if (static_cast<int>(index) < num_wake_ups_before_start_)
+      workers_[index]->WakeUp();
+  }
 }
 
 SchedulerWorkerPoolImpl::~SchedulerWorkerPoolImpl() {
   // SchedulerWorkerPool should never be deleted in production unless its
   // initialization failed.
   DCHECK(join_for_testing_returned_.IsSignaled() || workers_.empty());
 }
 
 scoped_refptr<TaskRunner> SchedulerWorkerPoolImpl::CreateTaskRunnerWithTraits(
     const TaskTraits& traits) {
@@ skipping 80 matching lines @@
 }
 
 void SchedulerWorkerPoolImpl::GetHistograms(
     std::vector<const HistogramBase*>* histograms) const {
   histograms->push_back(detach_duration_histogram_);
   histograms->push_back(num_tasks_between_waits_histogram_);
 }
 
 int SchedulerWorkerPoolImpl::GetMaxConcurrentTasksDeprecated() const {
 #if DCHECK_IS_ON()
-  DCHECK(workers_created_.IsSignaled());
+  DCHECK(workers_created_.IsSet());
 #endif
   return workers_.size();
 }
 
 void SchedulerWorkerPoolImpl::WaitForAllWorkersIdleForTesting() {
 #if DCHECK_IS_ON()
-  DCHECK(workers_created_.IsSignaled());
+  DCHECK(workers_created_.IsSet());
 #endif
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
   while (idle_workers_stack_.Size() < workers_.size())
     idle_workers_stack_cv_for_testing_->Wait();
 }
 
 void SchedulerWorkerPoolImpl::JoinForTesting() {
 #if DCHECK_IS_ON()
-  DCHECK(workers_created_.IsSignaled());
+  DCHECK(workers_created_.IsSet());
 #endif
   DCHECK(!CanWorkerDetachForTesting() || suggested_reclaim_time_.is_max())
       << "Workers can detach during join.";
   for (const auto& worker : workers_)
     worker->JoinForTesting();
 
   DCHECK(!join_for_testing_returned_.IsSignaled());
   join_for_testing_returned_.Signal();
 }
 
@@ skipping 18 matching lines @@
     : outer_(outer),
       re_enqueue_sequence_callback_(re_enqueue_sequence_callback),
       index_(index) {}
 
 SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
     ~SchedulerWorkerDelegateImpl() = default;
 
 void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::OnMainEntry(
     SchedulerWorker* worker) {
 #if DCHECK_IS_ON()
-  // Wait for |outer_->workers_created_| to avoid traversing
-  // |outer_->workers_| while it is being filled by Initialize().
-  outer_->workers_created_.Wait();
+  DCHECK(outer_->workers_created_.IsSet());
   DCHECK(ContainsWorker(outer_->workers_, worker));
 #endif
-
   DCHECK_EQ(num_tasks_since_last_wait_, 0U);
 
   if (!last_detach_time_.is_null()) {
     outer_->detach_duration_histogram_->AddTime(TimeTicks::Now() -
                                                 last_detach_time_);
   }
 
   PlatformThread::SetName(
       StringPrintf("TaskScheduler%sWorker%d", outer_->name_.c_str(), index_));
 
@@ skipping 98 matching lines @@
   did_detach_since_last_get_work_ = true;
   last_detach_time_ = TimeTicks::Now();
 }
 
 void SchedulerWorkerPoolImpl::WakeUpOneWorker() {
   SchedulerWorker* worker = nullptr;
   {
     AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
 
 #if DCHECK_IS_ON()
-    DCHECK_EQ(workers_.empty(), !workers_created_.IsSignaled());
+    DCHECK_EQ(workers_.empty(), !workers_created_.IsSet());
 #endif
 
     if (workers_.empty())
       ++num_wake_ups_before_start_;
     else
       worker = idle_workers_stack_.Pop();
   }
 
   if (worker)
     worker->WakeUp();
@@ skipping 27 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