Index: base/task_scheduler/scheduler_thread_pool.h |
diff --git a/base/task_scheduler/scheduler_thread_pool.h b/base/task_scheduler/scheduler_thread_pool.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..9fac0e82b956a0d03517516c682d7c2d9b332976 |
--- /dev/null |
+++ b/base/task_scheduler/scheduler_thread_pool.h |
@@ -0,0 +1,139 @@ |
+// 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/callback.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" |
+ |
+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: |
+ // Callback invoked when a Sequence isn't empty after a worker thread pops a |
+ // Task from it. |
+ using EnqueueSequenceCallback = Callback<void(scoped_refptr<Sequence>)>; |
+ |
+ // Creates a SchedulerThreadPool with up to |max_threads| threads of priority |
+ // |thread_priority|. |enqueue_sequence_callback| will be invoked after a |
+ // thread of this thread pool tries to run a Task. |task_tracker| is used to |
+ // handle shutdown behavior of Tasks. Returns nullptr on failure to create a |
+ // thread pool with at least one thread. |
+ static std::unique_ptr<SchedulerThreadPool> CreateThreadPool( |
+ ThreadPriority thread_priority, |
+ size_t max_threads, |
+ const EnqueueSequenceCallback& enqueue_sequence_callback, |
+ TaskTracker* task_tracker); |
+ |
+ // Destroying a SchedulerThreadPool returned by CreateThreadPool() is not |
+ // allowed in production; 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); |
+ |
+ // Inserts |sequence| into this thread pool's shared priority queue with |
+ // |sequence_sort_key|. Must only be called from a worker thread to put |
+ // |sequence| back into a PriorityQueue after running a Task from it. The |
+ // worker thread doesn't have to belong to this thread pool. |
+ void EnqueueSequence(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: |
+ class SchedulerWorkerThreadDelegateImpl |
gab
2016/04/08 17:56:00
May even be able to only fwd-decl here?
fdoray
2016/04/08 19:00:05
Done.
|
+ : public SchedulerWorkerThread::Delegate { |
+ public: |
+ SchedulerWorkerThreadDelegateImpl( |
+ SchedulerThreadPool* outer, |
+ const EnqueueSequenceCallback enqueue_sequence_callback); |
+ ~SchedulerWorkerThreadDelegateImpl() override; |
+ |
+ // SchedulerWorkerThread::Delegate: |
+ void OnMainEntry() override; |
+ scoped_refptr<Sequence> GetWork( |
+ SchedulerWorkerThread* worker_thread) override; |
+ void EnqueueSequence(scoped_refptr<Sequence> sequence) override; |
+ |
+ private: |
+ SchedulerThreadPool* outer_; |
+ const EnqueueSequenceCallback enqueue_sequence_callback_; |
+ }; |
gab
2016/04/08 17:56:00
DISALLOW_COPY_AND_ASSIGN
fdoray
2016/04/08 19:00:05
Done.
|
+ |
+ SchedulerThreadPool(const EnqueueSequenceCallback& enqueue_sequence_callback, |
+ TaskTracker* task_tracker); |
+ |
+ bool Initialize(ThreadPriority thread_priority, size_t max_threads); |
+ |
+ // Wakes up the last thread from this thread pool to go idle, if any. |
+ void WakeUpOneThread(); |
+ |
+ // Adds |worker_thread| to |idle_worker_threads_stack_|. |
+ void AddToIdleWorkerThreadsStack(SchedulerWorkerThread* worker_thread); |
+ |
+ // PriorityQueue from which all threads of this thread pool get work. |
+ PriorityQueue shared_priority_queue_; |
+ |
+ // Synchronizes access to |worker_threads_|, |idle_worker_threads_stack_| and |
+ // |idle_worker_threads_cv_|. Has |shared_priority_queue_|'s lock as its |
+ // predecessor so that a thread can be pushed to |idle_worker_threads_stack_| |
+ // within the scope of a Transaction (more details in GetWork()). |
+ SchedulerLock worker_threads_lock_; |
+ |
+ // All worker threads owned by this thread pool. |
+ std::vector<std::unique_ptr<SchedulerWorkerThread>> worker_threads_; |
+ |
+ // Stack of idle worker threads. |
+ std::stack<SchedulerWorkerThread*> idle_worker_threads_stack_; |
+ |
+ // Signaled when all worker threads become idle. |
+ std::unique_ptr<ConditionVariable> idle_worker_threads_stack_cv_for_testing_; |
+ |
+ // Signaled once JoinForTesting() has returned. |
+ WaitableEvent join_for_testing_returned_; |
+ |
+ // Delegate for all worker threads in this pool. |
+ SchedulerWorkerThreadDelegateImpl worker_thread_delegate_; |
+ |
+ TaskTracker* const task_tracker_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(SchedulerThreadPool); |
+}; |
+ |
+} // namespace internal |
+} // namespace base |
+ |
+#endif // BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_H_ |