Implement Shared SingleThreadTaskRunners in the Task Scheduler

base/task_scheduler/scheduler_single_thread_task_runner_manager.h

 // Copyright 2017 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.
 
 #ifndef BASE_TASK_SCHEDULER_SCHEDULER_SINGLE_THREAD_TASK_RUNNER_MANAGER_H_
 #define BASE_TASK_SCHEDULER_SCHEDULER_SINGLE_THREAD_TASK_RUNNER_MANAGER_H_
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/task_scheduler/environment_config.h"
 #include "base/task_scheduler/scheduler_lock.h"
+#include "base/task_scheduler/single_thread_task_runner_thread_mode.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 
 namespace base {
 
 class TaskTraits;
 class SingleThreadTaskRunner;
 
 namespace internal {
 
 class DelayedTaskManager;
 class SchedulerWorker;
 class TaskTracker;
 
 namespace {
 
 class SchedulerWorkerDelegate;
 
 }  // namespace
 
-// Manages a pool of threads which are each associated with one
-// SingleThreadTaskRunner.
+// Manages a pool of threads which are each associated with one or more
+// SingleThreadTaskRunners.
+//
+// SingleThreadTaskRunners are shared by reusing a single dedicated
+// SingleThreadTaskRunners for each COM+Trait combination. These

[fdoray, 2017/05/24 13:25:45]

SingleThreadTaskRunnerThreadMode::SHARED (make it clear that this doesn't apply
to DEDICATED) SingleThreadTaskRunners with the same *task environment* (not
traits) and COM state run their tasks on the same thread. These shared threads
(the threads are joined, not the SingleThreadTaskRunners) are only reclaimed
during JoinForTesting(), even if all external references to the
SingleThreadTaskRunners are released before that.

[robliao, 2017/05/24 18:28:32]

Went with 
// SingleThreadTaskRunners using SingleThreadTaskRunnerThreadMode::SHARED, are
// backed by shared SchedulerWorkers for each COM+task environment combination.
// These workers are only reclaimed during JoinForTesting().

+// SingleThreadTaskRunners are only reclaimed during JoinForTesting().
+// Otherwise, no resources are freed even if the shared SingleThreadTaskRunner
+// reference count goes to 1.
 //
 // No threads are created (and hence no tasks can run) before Start() is called.
 //
 // This class is thread-safe.
 class BASE_EXPORT SchedulerSingleThreadTaskRunnerManager final {
  public:
   SchedulerSingleThreadTaskRunnerManager(
       TaskTracker* task_tracker,
       DelayedTaskManager* delayed_task_manager);
   ~SchedulerSingleThreadTaskRunnerManager();
 
   // Starts threads for existing SingleThreadTaskRunners and allows threads to
   // be started when SingleThreadTaskRunners are created in the future.
   void Start();
 
-  // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a
-  // dedicated thread named "TaskSchedulerSingleThread" + |name| +  index.
-  // |priority_hint| is the preferred thread priority; the actual thread
-  // priority depends on shutdown state and platform capabilities.
+  // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a thread
+  // named "TaskSchedulerSingleThread[Shared]" + |name| +  index. "Shared" will
+  // be in the thread name when |thread_mode| is SHARED. |priority_hint| is the
+  // preferred thread priority. The actual thread priority depends on shutdown
+  // state and platform capabilities. If |thread_mode| is DEDICATED, a thread
+  // will be dedicated to the returned task runner, otherwise it could be shared
+  // with other SingleThreadTaskRunners.
   scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
       const std::string& name,
       ThreadPriority priority_hint,
-      const TaskTraits& traits);
+      const TaskTraits& traits,
+      SingleThreadTaskRunnerThreadMode thread_mode);
 
 #if defined(OS_WIN)
-  // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a
-  // dedicated COM STA thread named "TaskSchedulerSingleThreadCOMSTA" + |name| +
-  // index. |priority_hint| is the preferred thread priority; the actual thread
-  // priority depends on shutdown state and platform capabilities.
+  // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a COM
+  // STA thread named "TaskSchedulerSingleThreadCOMSTA[Shared]" + |name| +
+  // index. "Shared" will be in the thread name when |thread_mode| is SHARED.
+  // |priority_hint| is the preferred thread priority. The actual thread
+  // priority depends on shutdown state and platform capabilities. If
+  // |thread_mode| is DEDICATED, a thread will be dedicated to the returned task
+  // runner, otherwise it could be shared with other SingleThreadTaskRunners.
   scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunnerWithTraits(
       const std::string& name,
       ThreadPriority priority_hint,
-      const TaskTraits& traits);
+      const TaskTraits& traits,
+      SingleThreadTaskRunnerThreadMode thread_mode);
 #endif  // defined(OS_WIN)
 
   void JoinForTesting();
 
  private:
   class SchedulerSingleThreadTaskRunner;
 
   template <typename DelegateType>
-  scoped_refptr<SingleThreadTaskRunner>
+  scoped_refptr<SchedulerSingleThreadTaskRunner> CreateTaskRunnerWithTraitsImpl(
+      const std::string& name,
+      ThreadPriority priority_hint,
+      const TaskTraits& traits,
+      SingleThreadTaskRunnerThreadMode thread_mode);
+
+  template <typename DelegateType>
+  scoped_refptr<SchedulerSingleThreadTaskRunner>
   CreateSingleThreadTaskRunnerWithDelegate(const std::string& name,
                                            ThreadPriority priority_hint,
                                            const TaskTraits& traits);
 
   template <typename DelegateType>
   std::unique_ptr<SchedulerWorkerDelegate> CreateSchedulerWorkerDelegate(
       const std::string& name,
       int id);
 
   template <typename DelegateType>
   SchedulerWorker* CreateAndRegisterSchedulerWorker(
       const std::string& name,
       ThreadPriority priority_hint);
 
+  template <typename DelegateType>
+  scoped_refptr<SchedulerSingleThreadTaskRunner>& GetSharedTaskRunnerForTraits(
+      const TaskTraits& traits);
+
   void UnregisterSchedulerWorker(SchedulerWorker* worker);
 
+  void ReleaseSharedTaskRunners();
+
   TaskTracker* const task_tracker_;
   DelayedTaskManager* const delayed_task_manager_;
 
-  // Synchronizes access to |workers_|, |next_worker_id_| and |started_|.
-  SchedulerLock lock_;
-  std::vector<scoped_refptr<SchedulerWorker>> workers_;
-  int next_worker_id_ = 0;
-
-  // Set to true when Start() is called.
-  bool started_ = false;
-
 #if DCHECK_IS_ON()
   subtle::Atomic32 workers_unregistered_during_join_ = 0;
 #endif
 
+  // Synchronizes access to all members below.
+  SchedulerLock lock_;
+  std::vector<scoped_refptr<SchedulerWorker>> workers_;
+  int next_worker_id_ = 0;
+
+  scoped_refptr<SchedulerSingleThreadTaskRunner> shared_task_runners_[4];
+
+#if defined(OS_WIN)
+  scoped_refptr<SchedulerSingleThreadTaskRunner> shared_com_task_runners_[4];
+#endif  // defined(OS_WIN)
+
+  // Set to true when Start() is called.
+  bool started_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(SchedulerSingleThreadTaskRunnerManager);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_SCHEDULER_SINGLE_THREAD_TASK_RUNNER_MANAGER_H_