content: Implement dynamic priorities for raster threads.

content/renderer/raster_worker_pool.cc

 // Copyright 2015 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 "content/renderer/raster_worker_pool.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/raster/task_category.h"
 
 namespace content {
 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_;
   const std::vector<cc::TaskCategory> categories_;
   base::ConditionVariable* const has_ready_to_run_tasks_cv_;
 };
 
 }  // 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 {
  public:
   explicit RasterWorkerPoolSequencedTaskRunner(
       cc::TaskGraphRunner* task_graph_runner)
       : task_graph_runner_(task_graph_runner),
         namespace_token_(task_graph_runner->GetNamespaceToken()) {}
 
   // Overridden from base::TaskRunner:
@@ skipping 57 matching lines @@
   // List of tasks currently queued up for execution.
   cc::Task::Vector tasks_;
   // Graph object used for scheduling tasks.
   cc::TaskGraph graph_;
   // Cached vector to avoid allocation when getting the list of complete
   // tasks.
   cc::Task::Vector completed_tasks_;
 };
 
 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_),
       shutdown_(false) {}
 
 void RasterWorkerPool::Start(int num_threads) {
   DCHECK(threads_.empty());
 
   // Start |num_threads| threads for foreground work, including nonconcurrent
   // foreground work.
   std::vector<cc::TaskCategory> foreground_categories;
   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(),
         base::SimpleThread::Options(), this, foreground_categories,
         &has_ready_to_run_foreground_tasks_cv_));
     thread->Start();
     threads_.push_back(std::move(thread));
   }
 
   // Start a single thread for background work.
   std::vector<cc::TaskCategory> background_categories;
   background_categories.push_back(cc::TASK_CATEGORY_BACKGROUND);
 
   // Use background priority for background thread.
   base::SimpleThread::Options thread_options;
 #if !defined(OS_MACOSX)
   thread_options.set_priority(base::ThreadPriority::BACKGROUND);
 #endif
 
   scoped_ptr<base::SimpleThread> thread(new RasterWorkerPoolThread(
+      dynamic_background,
       base::StringPrintf("CompositorTileWorker%u",
                          static_cast<unsigned>(threads_.size() + 1))
           .c_str(),
       thread_options, this, background_categories,
       &has_ready_to_run_background_tasks_cv_));
   thread->Start();
   threads_.push_back(std::move(thread));
 }
 
 void RasterWorkerPool::Shutdown() {
@@ skipping 50 matching lines @@
 
   ScheduleTasksWithLockAcquired(namespace_token_, &graph_);
   completed_tasks_.clear();
   return true;
 }
 
 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();
 
       // Exit when shutdown is set and no more tasks are pending.
       if (shutdown_)
         break;
 
       // Wait for more tasks.
       has_ready_to_run_tasks_cv->Wait();
@@ skipping 67 matching lines @@
     // up another origin thread.
     has_namespaces_with_finished_running_tasks_cv_.Signal();
   }
 }
 
 void RasterWorkerPool::CollectCompletedTasks(
     cc::NamespaceToken token,
     cc::Task::Vector* completed_tasks) {
   TRACE_EVENT0("disabled-by-default-cc.debug",
                "RasterWorkerPool::CollectCompletedTasks");
-
   {
     base::AutoLock lock(lock_);
     CollectCompletedTasksWithLockAcquired(token, completed_tasks);
   }
 }
 
 void RasterWorkerPool::CollectCompletedTasksWithLockAcquired(
     cc::NamespaceToken token,
     cc::Task::Vector* completed_tasks) {
   DCHECK(token.IsValid());
   work_queue_.CollectCompletedTasks(token, completed_tasks);
 }
 
 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;
     }
   }
   return false;
 }
 
 void RasterWorkerPool::RunTaskInCategoryWithLockAcquired(
+    cc::TaskWorker* worker,
     cc::TaskCategory category) {
   TRACE_EVENT0("toplevel", "TaskGraphRunner::RunTask");
 
   lock_.AssertAcquired();
 
   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();
 
   // Call WillRun() before releasing |lock_| and running task.
   task->WillRun();
 
   {
     base::AutoUnlock unlock(lock_);
 
     task->RunOnWorkerThread();
@@ skipping 62 matching lines @@
 
 // Overridden from cc::Task:
 void RasterWorkerPool::ClosureTask::RunOnWorkerThread() {
   closure_.Run();
   closure_.Reset();
 }
 
 RasterWorkerPool::ClosureTask::~ClosureTask() {}
 
 }  // namespace content