diff options
Diffstat (limited to 'chromium/cc/resources/worker_pool.h')
-rw-r--r-- | chromium/cc/resources/worker_pool.h | 143 |
1 files changed, 143 insertions, 0 deletions
diff --git a/chromium/cc/resources/worker_pool.h b/chromium/cc/resources/worker_pool.h new file mode 100644 index 00000000000..c26ed077eb6 --- /dev/null +++ b/chromium/cc/resources/worker_pool.h @@ -0,0 +1,143 @@ +// Copyright 2013 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 CC_RESOURCES_WORKER_POOL_H_ +#define CC_RESOURCES_WORKER_POOL_H_ + +#include <deque> +#include <string> +#include <vector> + +#include "base/cancelable_callback.h" +#include "base/memory/ref_counted.h" +#include "base/memory/scoped_ptr.h" +#include "base/memory/weak_ptr.h" +#include "base/message_loop/message_loop.h" +#include "cc/base/cc_export.h" +#include "cc/base/scoped_ptr_hash_map.h" + +namespace cc { +namespace internal { + +class CC_EXPORT WorkerPoolTask + : public base::RefCountedThreadSafe<WorkerPoolTask> { + public: + virtual void RunOnWorkerThread(unsigned thread_index) = 0; + virtual void CompleteOnOriginThread() = 0; + + void DidSchedule(); + void WillRun(); + void DidRun(); + void WillComplete(); + void DidComplete(); + + bool HasFinishedRunning() const; + bool HasCompleted() const; + + protected: + friend class base::RefCountedThreadSafe<WorkerPoolTask>; + + WorkerPoolTask(); + virtual ~WorkerPoolTask(); + + private: + bool did_schedule_; + bool did_run_; + bool did_complete_; +}; + +class CC_EXPORT GraphNode { + public: + typedef std::vector<GraphNode*> Vector; + + GraphNode(internal::WorkerPoolTask* task, unsigned priority); + ~GraphNode(); + + WorkerPoolTask* task() { return task_; } + + void add_dependent(GraphNode* dependent) { + DCHECK(dependent); + dependents_.push_back(dependent); + } + const Vector& dependents() const { return dependents_; } + + unsigned priority() const { return priority_; } + + unsigned num_dependencies() const { return num_dependencies_; } + void add_dependency() { ++num_dependencies_; } + void remove_dependency() { + DCHECK(num_dependencies_); + --num_dependencies_; + } + + private: + WorkerPoolTask* task_; + Vector dependents_; + unsigned priority_; + unsigned num_dependencies_; + + DISALLOW_COPY_AND_ASSIGN(GraphNode); +}; + +} // namespace internal +} // namespace cc + +#if defined(COMPILER_GCC) +namespace BASE_HASH_NAMESPACE { +template <> struct hash<cc::internal::WorkerPoolTask*> { + size_t operator()(cc::internal::WorkerPoolTask* ptr) const { + return hash<size_t>()(reinterpret_cast<size_t>(ptr)); + } +}; +} // namespace BASE_HASH_NAMESPACE +#endif // COMPILER + +namespace cc { + +// A worker thread pool that runs tasks provided by task graph and +// guarantees completion of all pending tasks at shutdown. +class CC_EXPORT WorkerPool { + public: + virtual ~WorkerPool(); + + // Tells the worker pool to shutdown and returns once all pending tasks have + // completed. + virtual void Shutdown(); + + // Force a check for completed tasks. + virtual void CheckForCompletedTasks(); + + protected: + // A task graph contains a unique set of tasks with edges between + // dependencies pointing in the direction of the dependents. Each task + // need to be assigned a unique priority and a run count that matches + // the number of dependencies. + typedef ScopedPtrHashMap<internal::WorkerPoolTask*, internal::GraphNode> + GraphNodeMap; + typedef GraphNodeMap TaskGraph; + + WorkerPool(size_t num_threads, const std::string& thread_name_prefix); + + // Schedule running of tasks in |graph|. Any previously scheduled tasks + // that are not already running will be canceled. Canceled tasks don't run + // but completion of them is still processed. + void SetTaskGraph(TaskGraph* graph); + + private: + class Inner; + friend class Inner; + + typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector; + + void ProcessCompletedTasks(const TaskVector& completed_tasks); + + bool in_dispatch_completion_callbacks_; + + // Hide the gory details of the worker pool in |inner_|. + const scoped_ptr<Inner> inner_; +}; + +} // namespace cc + +#endif // CC_RESOURCES_WORKER_POOL_H_ |