Shared Raster Worker Threads

cc/resources/worker_pool.cc

 // 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.
 
 #include "cc/resources/worker_pool.h"
 
 #include <algorithm>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
+#include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "cc/base/scoped_ptr_deque.h"
 
+
 namespace cc {
 
 namespace internal {
 
 WorkerPoolTask::WorkerPoolTask()
     : did_schedule_(false),
       did_run_(false),
       did_complete_(false) {
 }
 
@@ skipping 45 matching lines @@
 GraphNode::~GraphNode() {
 }
 
 }  // namespace internal
 
 // Internal to the worker pool. Any data or logic that needs to be
 // shared between threads lives in this class. All members are guarded
 // by |lock_|.
 class WorkerPool::Inner : public base::DelegateSimpleThread::Delegate {
  public:
+    // Required for Lazy Instantiation
+    Inner();
   Inner(size_t num_threads, const std::string& thread_name_prefix);

[reveman, 2013/11/15 17:21:41]

One ctor please.

How about we create a derived class with only a default ctor that calls this
existing Inner ctor with proper parameters to use for a global Inner instance?

The default ctor of the derived class can probably read
cc::switches::kNumRasterThreads directly unless we can think of a better place
to do that, in which case it should be a global variable that can be adjusted
using a static setter.

   virtual ~Inner();
 
   void Shutdown();
 
   // Schedule running of tasks in |graph|. Tasks previously scheduled but
   // no longer needed will be canceled unless already running. Canceled
   // tasks are moved to |completed_tasks_| without being run. The result
   // is that once scheduled, a task is guaranteed to end up in the
   // |completed_tasks_| queue even if they later get canceled by another
   // call to SetTaskGraph().
   void SetTaskGraph(TaskGraph* graph);
 
   // Collect all completed tasks in |completed_tasks|.
   void CollectCompletedTasks(TaskVector* completed_tasks);
 
+  // Required to be pulled out of Ctor, for lazy instantiation
+  void Start();
+  // For setting number of threads from WorkerPool to WorkerPool::Inner
+  void SetNumThreads(size_t val) {num_threads_ = val;}

[reveman, 2013/11/15 17:21:41]

This is not thread safe. One LTHI might change the value of num_threads_ while
another is running Start(). However, if you follow my suggestion above none of
this is needed.

+
+
  private:
   class PriorityComparator {
    public:
     bool operator()(const internal::GraphNode* a,
                     const internal::GraphNode* b) {
       // In this system, numerically lower priority is run first.
       if (a->priority() != b->priority())
         return a->priority() > b->priority();
 
       // Run task with most dependents first when priority is the same.
@@ skipping 31 matching lines @@
   TaskQueue ready_to_run_tasks_;
 
   // This set contains all currently running tasks.
   GraphNodeMap running_tasks_;
 
   // Completed tasks not yet collected by origin thread.
   TaskVector completed_tasks_;
 
   ScopedPtrDeque<base::DelegateSimpleThread> workers_;
 
+  size_t num_threads_;
+
   DISALLOW_COPY_AND_ASSIGN(Inner);
 };
 
+// Lazy Instance of WorkerPool::Inner,
+// This will enable sharing the worker thread across LTHI for same process
+base::LazyInstance<WorkerPool::Inner>  g_workerpool_inner;
+
+// Default Ctor required for Lazy Instantiation
+WorkerPool::Inner::Inner()
+    : lock_(),
+      has_ready_to_run_tasks_cv_(&lock_),
+      next_thread_index_(0),
+      shutdown_(false) {
+      }
+
 WorkerPool::Inner::Inner(
     size_t num_threads, const std::string& thread_name_prefix)
     : lock_(),
       has_ready_to_run_tasks_cv_(&lock_),
       next_thread_index_(0),
       shutdown_(false) {
   base::AutoLock lock(lock_);
-
   while (workers_.size() < num_threads) {
     scoped_ptr<base::DelegateSimpleThread> worker = make_scoped_ptr(
         new base::DelegateSimpleThread(
             this,
             thread_name_prefix +
             base::StringPrintf(
                 "Worker%u",
                 static_cast<unsigned>(workers_.size() + 1)).c_str()));
     worker->Start();
 #if defined(OS_ANDROID) || defined(OS_LINUX)
     worker->SetThreadPriority(base::kThreadPriority_Background);
 #endif
     workers_.push_back(worker.Pass());
   }
 }
 
 WorkerPool::Inner::~Inner() {
   base::AutoLock lock(lock_);
-
   DCHECK(shutdown_);
 
   DCHECK_EQ(0u, pending_tasks_.size());
   DCHECK_EQ(0u, ready_to_run_tasks_.size());
   DCHECK_EQ(0u, running_tasks_.size());
   DCHECK_EQ(0u, completed_tasks_.size());
 }
 
+// Required to be pulled out of Ctor, for lazy instantiation
+void WorkerPool::Inner::Start() {
+  base::AutoLock lock(lock_);
+
+  std::string thread_name_prefix = "CompositorRaster";
+  size_t num_threads = num_threads_;
+
+
+  while (workers_.size() < num_threads) {
+    scoped_ptr<base::DelegateSimpleThread> worker = make_scoped_ptr(
+        new base::DelegateSimpleThread(
+            this,
+            thread_name_prefix +
+            base::StringPrintf(
+                "Worker%u",
+                static_cast<unsigned>(workers_.size() + 1)).c_str()));
+      worker->Start();
+
+#if defined(OS_ANDROID) || defined(OS_LINUX)
+       worker->SetThreadPriority(base::kThreadPriority_Background);
+#endif
+       workers_.push_back(worker.Pass());
+    }
+}
+
 void WorkerPool::Inner::Shutdown() {
   {
     base::AutoLock lock(lock_);
 
     DCHECK(!shutdown_);
     shutdown_ = true;
 
     // Wake up a worker so it knows it should exit. This will cause all workers
     // to exit as each will wake up another worker before exiting.
     has_ready_to_run_tasks_cv_.Signal();
@@ skipping 167 matching lines @@
 
     // Finally add task to |completed_tasks_|.
     completed_tasks_.push_back(task);
   }
 
   // We noticed we should exit. Wake up the next worker so it knows it should
   // exit as well (because the Shutdown() code only signals once).
   has_ready_to_run_tasks_cv_.Signal();
 }
 
 WorkerPool::WorkerPool(size_t num_threads,

[reveman, 2013/11/15 17:21:41]

num_threads can't be a LTHI setting anymore as the threads are now process wide.

                        const std::string& thread_name_prefix)
-    : in_dispatch_completion_callbacks_(false),
-      inner_(make_scoped_ptr(new Inner(num_threads, thread_name_prefix))) {
+    : in_dispatch_completion_callbacks_(false) {
+    g_workerpool_inner.Pointer()->SetNumThreads(num_threads);
+    g_workerpool_inner.Pointer()->Start();

[reveman, 2013/11/15 17:21:41]

What's stopping Start() from being called multiple times?

 }
 
 WorkerPool::~WorkerPool() {
 }
 
 void WorkerPool::Shutdown() {
   TRACE_EVENT0("cc", "WorkerPool::Shutdown");
 
   DCHECK(!in_dispatch_completion_callbacks_);
-
-  inner_->Shutdown();
+  g_workerpool_inner.Pointer()->Shutdown();

[reveman, 2013/11/15 17:21:41]

You need to introduce a task namespace for each WorkerPool instance and only
shutdown the tasks related to this namespace.

 }
 
 void WorkerPool::CheckForCompletedTasks() {
   TRACE_EVENT0("cc", "WorkerPool::CheckForCompletedTasks");
 
   DCHECK(!in_dispatch_completion_callbacks_);
 
   TaskVector completed_tasks;
-  inner_->CollectCompletedTasks(&completed_tasks);
+  g_workerpool_inner.Pointer()->CollectCompletedTasks(&completed_tasks);

[reveman, 2013/11/15 17:21:41]

Same here. Task namespace needed for this to work.

   ProcessCompletedTasks(completed_tasks);
 }
 
 void WorkerPool::ProcessCompletedTasks(
     const TaskVector& completed_tasks) {
   TRACE_EVENT1("cc", "WorkerPool::ProcessCompletedTasks",
                "completed_task_count", completed_tasks.size());
 
   // Worker pool instance is not reentrant while processing completed tasks.
   in_dispatch_completion_callbacks_ = true;
 
   for (TaskVector::const_iterator it = completed_tasks.begin();
        it != completed_tasks.end();
        ++it) {
     internal::WorkerPoolTask* task = it->get();
 
     task->WillComplete();
     task->CompleteOnOriginThread();
     task->DidComplete();
   }
 
   in_dispatch_completion_callbacks_ = false;
 }
 
 void WorkerPool::SetTaskGraph(TaskGraph* graph) {
   TRACE_EVENT1("cc", "WorkerPool::SetTaskGraph",
                "num_tasks", graph->size());
 
   DCHECK(!in_dispatch_completion_callbacks_);
-
-  inner_->SetTaskGraph(graph);
-}
+  g_workerpool_inner.Pointer()->SetTaskGraph(graph);

[reveman, 2013/11/15 17:21:41]

And here. Task namespace needed for this to work.

+  }
 
 }  // namespace cc