content: Implement dynamic priorities for raster threads.

content/renderer/raster_worker_pool.cc

Index: content/renderer/raster_worker_pool.cc
diff --git a/content/renderer/raster_worker_pool.cc b/content/renderer/raster_worker_pool.cc
index e8ed13bf8cad0012e91abc13f9b2d6d3b23b117a..f9ecdcb7981c8331ee7a67610d741d6a376dee06 100644
--- a/content/renderer/raster_worker_pool.cc
+++ b/content/renderer/raster_worker_pool.cc
@@ -19,19 +19,29 @@ namespace {
 
 // A thread which forwards to RasterWorkerPool::Run with the runnable
 // categories.
-class RasterWorkerPoolThread : public base::SimpleThread {
+class RasterWorkerPoolThread : public base::DynamicPriorityThread,
+                               public cc::TaskWorker {
  public:
-  RasterWorkerPoolThread(const std::string& name_prefix,
+  RasterWorkerPoolThread(const DynamicPriorityThread::PrioritySet& priorities,
+                         const std::string& name_prefix,
                          const Options& options,
                          RasterWorkerPool* pool,
                          std::vector<cc::TaskCategory> categories,
                          base::ConditionVariable* has_ready_to_run_tasks_cv)
-      : SimpleThread(name_prefix, options),
+      : DynamicPriorityThread(priorities, name_prefix, options),
         pool_(pool),
         categories_(categories),
         has_ready_to_run_tasks_cv_(has_ready_to_run_tasks_cv) {}
 
-  void Run() override { pool_->Run(categories_, has_ready_to_run_tasks_cv_); }
+  // Overridden from cc::TaskWorker:
+  bool TaskSpeedup() override { Speedup(); }
+  bool TaskSlowdown() override { SlowDown(); }
+  bool TaskDone() override { RestoreDefaultPriority(); }
+
+  // Overridden from base::DynamicPriorityThread:
+  void Run() override {
+    pool_->Run(this, categories_, has_ready_to_run_tasks_cv_);
+  }
 
  private:
   RasterWorkerPool* const pool_;
@@ -41,6 +51,24 @@ class RasterWorkerPoolThread : public base::SimpleThread {
 
 }  // namespace
 
+void RasterWorkerPool::AdjustWorkerPriorityForTask(cc::Task* task,
+                                                   uint16_t old_category,
+                                                   uint16_t new_category) {
+  if (old_category == new_category)
+    return;
+
+  // TODO(prashant.n): Handle slowing down of tasks either by setting background
+  // priority for worker OR cancelling the task.
+  if (new_category == cc::TASK_CATEGORY_NONCONCURRENT_FOREGROUND ||
+      new_category == cc::TASK_CATEGORY_FOREGROUND) {
+    if (task->GetWorker()->TaskSpeedup()) {
+      // LOG(ERROR) << "\nPRAS:: [" << std::hex << runner << "]  "
+      //            << runner->GetPrioritySetForDebugging()
+      //            << ".  Runner speeded up ^^^^^^^^^";
+    }
+  }
+}
+
 // A sequenced task runner which posts tasks to a RasterWorkerPool.
 class RasterWorkerPool::RasterWorkerPoolSequencedTaskRunner
     : public base::SequencedTaskRunner {
@@ -118,7 +146,8 @@ class RasterWorkerPool::RasterWorkerPoolSequencedTaskRunner
 };
 
 RasterWorkerPool::RasterWorkerPool()
-    : namespace_token_(GetNamespaceToken()),
+    : work_queue_(this),
+      namespace_token_(GetNamespaceToken()),
       has_ready_to_run_foreground_tasks_cv_(&lock_),
       has_ready_to_run_background_tasks_cv_(&lock_),
       has_namespaces_with_finished_running_tasks_cv_(&lock_),
@@ -133,8 +162,18 @@ void RasterWorkerPool::Start(int num_threads) {
   foreground_categories.push_back(cc::TASK_CATEGORY_NONCONCURRENT_FOREGROUND);
   foreground_categories.push_back(cc::TASK_CATEGORY_FOREGROUND);
 
+  base::DynamicPriorityThread::PrioritySet only_foreground(
+      base::ThreadPriority::NORMAL, base::ThreadPriority::NORMAL,
+      base::ThreadPriority::NORMAL);
+
+  base::DynamicPriorityThread::PrioritySet dynamic_background(
+      base::ThreadPriority::BACKGROUND, base::ThreadPriority::BACKGROUND,
+      base::ThreadPriority::NORMAL);
+
+  // Create N normal priority threads and 1 background priority dynamic thread.
   for (int i = 0; i < num_threads; i++) {
     scoped_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
+        only_foreground,
         base::StringPrintf("CompositorTileWorker%u",
                            static_cast<unsigned>(threads_.size() + 1))
             .c_str(),
@@ -155,6 +194,7 @@ void RasterWorkerPool::Start(int num_threads) {
 #endif
 
   scoped_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
+      dynamic_background,
       base::StringPrintf("CompositorTileWorker%u",
                          static_cast<unsigned>(threads_.size() + 1))
           .c_str(),
@@ -225,12 +265,13 @@ bool RasterWorkerPool::RunsTasksOnCurrentThread() const {
   return true;
 }
 
-void RasterWorkerPool::Run(const std::vector<cc::TaskCategory>& categories,
+void RasterWorkerPool::Run(cc::TaskWorker* worker,
+                           const std::vector<cc::TaskCategory>& categories,
                            base::ConditionVariable* has_ready_to_run_tasks_cv) {
   base::AutoLock lock(lock_);
 
   while (true) {
-    if (!RunTaskWithLockAcquired(categories)) {
+    if (!RunTaskWithLockAcquired(worker, categories)) {
       // We are no longer running tasks, which may allow another category to
       // start running. Signal other worker threads.
       SignalHasReadyToRunTasksWithLockAcquired();
@@ -318,7 +359,6 @@ void RasterWorkerPool::CollectCompletedTasks(
     cc::Task::Vector* completed_tasks) {
   TRACE_EVENT0("disabled-by-default-cc.debug",
                "RasterWorkerPool::CollectCompletedTasks");
-
   {
     base::AutoLock lock(lock_);
     CollectCompletedTasksWithLockAcquired(token, completed_tasks);
@@ -333,10 +373,11 @@ void RasterWorkerPool::CollectCompletedTasksWithLockAcquired(
 }
 
 bool RasterWorkerPool::RunTaskWithLockAcquired(
+    cc::TaskWorker* worker,
     const std::vector<cc::TaskCategory>& categories) {
   for (const auto& category : categories) {
     if (ShouldRunTaskForCategoryWithLockAcquired(category)) {
-      RunTaskInCategoryWithLockAcquired(category);
+      RunTaskInCategoryWithLockAcquired(worker, category);
       return true;
     }
   }
@@ -344,6 +385,7 @@ bool RasterWorkerPool::RunTaskWithLockAcquired(
 }
 
 void RasterWorkerPool::RunTaskInCategoryWithLockAcquired(
+    cc::TaskWorker* worker,
     cc::TaskCategory category) {
   TRACE_EVENT0("toplevel", "TaskGraphRunner::RunTask");
 
@@ -352,6 +394,9 @@ void RasterWorkerPool::RunTaskInCategoryWithLockAcquired(
   auto prioritized_task = work_queue_.GetNextTaskToRun(category);
   cc::Task* task = prioritized_task.task;
 
+  // Attach the worker to the task.
+  AutoDetachTaskWorker task_worker(task, worker);
+
   // There may be more work available, so wake up another worker thread.
   SignalHasReadyToRunTasksWithLockAcquired();