TaskScheduler [7] SchedulerThreadPool

base/task_scheduler/scheduler_thread_pool.h

+// 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.
+
+#ifndef BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_H_
+#define BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_H_
+
+#include <stddef.h>
+
+#include <memory>
+#include <stack>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/synchronization/condition_variable.h"
+#include "base/task_runner.h"
+#include "base/task_scheduler/priority_queue.h"
+#include "base/task_scheduler/scheduler_lock.h"
+#include "base/task_scheduler/scheduler_worker_thread.h"
+#include "base/task_scheduler/sequence.h"
+#include "base/task_scheduler/task_traits.h"
+#include "base/threading/platform_thread.h"
+#include "base/threading/thread_local.h"
+
+namespace base {
+namespace internal {
+
+struct SequenceSortKey;
+class TaskTracker;
+
+// A pool of threads that run Tasks. This class is thread-safe.
+class BASE_EXPORT SchedulerThreadPool {
+ public:
+  // Creates a SchedulerThreadPool with up to |max_threads| threads of priority
+  // |thread_priority|. |ran_task_from_sequence_callback| is invoked after a
+  // thread of this thread pool tries to run a Task from a Sequence.
+  // |task_tracker| is used to handle shutdown behavior of Tasks. Returns
+  // nullptr when it's not possible to create a thread pool with at least one
+  // thread.
+  static std::unique_ptr<SchedulerThreadPool> CreateThreadPool(
+      ThreadPriority thread_priority,
+      size_t max_threads,
+      const SchedulerWorkerThread::RanTaskFromSequenceCallback&
+          ran_task_from_sequence_callback,
+      TaskTracker* task_tracker);
+
+  // Destroying a SchedulerThreadPool in production is not allowed; it is always
+  // leaked. In tests, it can only be destroyed after JoinForTesting() has
+  // returned.
+  ~SchedulerThreadPool();
+
+  // Returns a TaskRunner whose PostTask invocations will result in scheduling
+  // Tasks with |traits| and |execution_mode| in this thread pool.
+  scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
+      const TaskTraits& traits,
+      ExecutionMode execution_mode);
+
+  // Reinserts |sequence| into this thread pool's shared priority queue with

[danakj, 2016/04/05 00:27:59]

Can you explain in the comment why this method is "Reinsert" instead of just
"Insert", like it implies things are already inserted somewhere, so when would
this be called?

[fdoray, 2016/04/06 19:31:02]

Renamed ReinsertSequence -> InsertSequenceAfterTaskRan. This method must be
called from a worker thread that just ran a Task from |sequence|. That means
that |sequence| has already been in a PriorityQueue in the past, hence the use
of "Reinsert" in the previous patch set.

+  // |sequence_sort_key|.
+  void ReinsertSequence(scoped_refptr<Sequence> sequence,
+                        const SequenceSortKey& sequence_sort_key);
+
+  // Waits until all threads are idle.
+  void WaitForAllWorkerThreadsIdleForTesting();
+
+  // Joins all threads of this thread pool. Tasks that are already running are
+  // allowed to complete their execution. This can only be called once.
+  void JoinForTesting();
+
+ private:
+  SchedulerThreadPool(ThreadPriority thread_priority,
+                      size_t max_threads,
+                      const SchedulerWorkerThread::RanTaskFromSequenceCallback&
+                          ran_task_from_sequence_callback,
+                      TaskTracker* task_tracker);
+
+  // Wakes up one thread from this thread pool if they aren't all busy.
+  void WakeUpOneThread();
+
+  // Adds |worker_thread| to |idle_worker_threads_stack_|.
+  void AddToIdleSchedulerWorkerThreadsStack(

[danakj, 2016/04/05 00:27:59]

Quite the mouthful. Maybe just AddToIdleWorkerThreadsStack?

[fdoray, 2016/04/06 19:31:02]

Done.

+      SchedulerWorkerThread* worker_thread);
+
+  // Invoked when a sequence is inserted in |shared_priority_queue_|.
+  void SequenceInsertedInSharedPriorityQueueCallback();
+
+  // Invoked when the main function of a worker thread is entered.
+  void MainEntryCallback() const;
+
+  // Invoked by a worker thread to get a Sequence from which to run a Task.
+  scoped_refptr<Sequence> GetWorkCallback(SchedulerWorkerThread* worker_thread);
+
+  // PriorityQueue from which all threads of this thread pool get work.
+  PriorityQueue shared_priority_queue_;
+
+  // All worker threads owned by this thread pool. This is only modified by the
+  // constructor.
+  std::vector<std::unique_ptr<SchedulerWorkerThread>> worker_threads_;
+
+  // True if WakeUpOneThread() shouldn't be called when a Sequence is inserted
+  // in |shared_priority_queue_| by a given thread.
+  ThreadLocalBoolean no_wake_up_on_sequence_insertion_;
+
+  // Synchronizes access to |idle_worker_threads_stack_| and
+  // |idle_worker_threads_cv_|.
+  SchedulerLock idle_worker_threads_stack_lock_;
+
+  // Stack of idle worker threads. The last worker thread that became idle is on
+  // top of the stack.
+  std::stack<SchedulerWorkerThread*> idle_worker_threads_stack_;
+
+  // Signaled when all worker threads become idle.
+  std::unique_ptr<ConditionVariable> idle_worker_threads_stack_cv_;
+
+  // Synchronizes access to |join_for_testing_returned_|.
+  SchedulerLock join_for_testing_returned_lock_;
+
+  // True once JoinForTesting() has returned.
+  bool join_for_testing_returned_ = false;
+
+  TaskTracker* const task_tracker_;
+
+  DISALLOW_COPY_AND_ASSIGN(SchedulerThreadPool);
+};
+
+// Helper for posting |task| to the provided |sequence| and |priority_queue|
+// conditional on |task_tracker|. Exposed for testing.
+void BASE_EXPORT PostTaskHelper(std::unique_ptr<Task> task,
+                                scoped_refptr<Sequence> sequence,
+                                PriorityQueue* priority_queue,
+                                TaskTracker* task_tracker);
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_H_