cc: Rasterize cheap tiles immediately

cc/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/worker_pool.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
+#include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
 
 #if defined(OS_ANDROID)
 // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
 #include <sys/resource.h>
 #endif
 
 namespace cc {
 
 namespace {
 
 class WorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   WorkerPoolTaskImpl(const WorkerPool::Callback& task,
                      const base::Closure& reply)
       : internal::WorkerPoolTask(reply),
         task_(task) {}
 
   virtual void Run(RenderingStats* rendering_stats) OVERRIDE {
     task_.Run(rendering_stats);
     base::subtle::Release_Store(&completed_, 1);
   }
 
+  virtual void DeferToThread(base::Thread* thread) OVERRIDE {}
+
  private:
   WorkerPool::Callback task_;
 };
 
 const char* kWorkerThreadNamePrefix = "Compositor";
 
 #if defined(OS_ANDROID)
 const int kNumPendingTasksPerWorker = 8;
 #else
 const int kNumPendingTasksPerWorker = 40;
 #endif
 
 const int kCheckForCompletedTasksDelayMs = 6;
 
+// Limits for the total number of cheap tasks we are allowed to perform
+// during a single frame and the time spent running those tasks.
+// TODO(skyostil): Determine these limits more dynamically.
+const int kMaxCheapTaskCount = 6;
+const int kMaxCheapTaskMs = kCheckForCompletedTasksDelayMs;
+
 }  // namespace
 
 namespace internal {
 
 WorkerPoolTask::WorkerPoolTask(const base::Closure& reply) : reply_(reply) {
   base::subtle::Acquire_Store(&completed_, 0);
 }
 
 WorkerPoolTask::~WorkerPoolTask() {
 }
@@ skipping 88 matching lines @@
 
 WorkerPool::WorkerPool(WorkerPoolClient* client, size_t num_threads)
     : client_(client),
       origin_loop_(base::MessageLoopProxy::current()),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       workers_need_sorting_(false),
       pending_task_count_(0),
       shutdown_(false),
       check_for_completed_tasks_pending_(false),
       idle_callback_(
-          base::Bind(&WorkerPool::OnIdle, weak_ptr_factory_.GetWeakPtr())) {
+          base::Bind(&WorkerPool::OnIdle, weak_ptr_factory_.GetWeakPtr())),
+      cheap_task_callback_(
+          base::Bind(&WorkerPool::RunCheapTasks,
+                     weak_ptr_factory_.GetWeakPtr())),
+      run_cheap_tasks_pending_(false) {
   const std::string thread_name_prefix = kWorkerThreadNamePrefix;
   while (workers_.size() < num_threads) {
     int thread_number = workers_.size() + 1;
     workers_.push_back(new Worker(
         this,
         thread_name_prefix + StringPrintf("Worker%d", thread_number).c_str()));
   }
   base::subtle::Acquire_Store(&pending_task_count_, 0);
 }
 
 WorkerPool::~WorkerPool() {
   Shutdown();
   STLDeleteElements(&workers_);
   // Cancel all pending callbacks.
   weak_ptr_factory_.InvalidateWeakPtrs();
   DCHECK_EQ(base::subtle::Acquire_Load(&pending_task_count_), 0);
 }
 
 void WorkerPool::Shutdown() {
   DCHECK(!shutdown_);
   shutdown_ = true;
 
+  if (run_cheap_tasks_pending_)
+    RunCheapTasks();
+
   for (WorkerVector::iterator it = workers_.begin();
        it != workers_.end(); it++) {
     Worker* worker = *it;
     worker->StopAfterCompletingAllPendingTasks();
   }
 }
 
 void WorkerPool::PostTaskAndReply(
     const Callback& task, const base::Closure& reply) {
   Worker* worker = GetWorkerForNextTask();
 
   worker->PostTask(
       make_scoped_ptr(new WorkerPoolTaskImpl(
                           task,
                           reply)).PassAs<internal::WorkerPoolTask>());
 }
 
 bool WorkerPool::IsBusy() {
   Worker* worker = GetWorkerForNextTask();
 
   return worker->num_pending_tasks() >= kNumPendingTasksPerWorker;
 }
 
 void WorkerPool::SetRecordRenderingStats(bool record_rendering_stats) {
+  if (record_rendering_stats)
+    cheap_rendering_stats_.reset(new RenderingStats);
+  else
+    cheap_rendering_stats_.reset();
+
   for (WorkerVector::iterator it = workers_.begin();
        it != workers_.end(); ++it) {
     Worker* worker = *it;
     worker->set_record_rendering_stats(record_rendering_stats);
   }
 }
 
 void WorkerPool::GetRenderingStats(RenderingStats* stats) {
   stats->totalRasterizeTime = base::TimeDelta();
   stats->totalPixelsRasterized = 0;
   stats->totalDeferredImageDecodeCount = 0;
   stats->totalDeferredImageDecodeTime = base::TimeDelta();
+  if (cheap_rendering_stats_) {
+    stats->totalRasterizeTime +=
+        cheap_rendering_stats_->totalRasterizeTime;
+    stats->totalPixelsRasterized +=
+        cheap_rendering_stats_->totalPixelsRasterized;
+    stats->totalDeferredImageDecodeCount +=
+        cheap_rendering_stats_->totalDeferredImageDecodeCount;
+    stats->totalDeferredImageDecodeTime +=
+        cheap_rendering_stats_->totalDeferredImageDecodeTime;
+  }
   for (WorkerVector::iterator it = workers_.begin();
        it != workers_.end(); ++it) {
     Worker* worker = *it;
     CHECK(worker->rendering_stats());
     stats->totalRasterizeTime +=
         worker->rendering_stats()->totalRasterizeTime;
     stats->totalPixelsRasterized +=
         worker->rendering_stats()->totalPixelsRasterized;
     stats->totalDeferredImageDecodeCount +=
         worker->rendering_stats()->totalDeferredImageDecodeCount;
@@ skipping 28 matching lines @@
   workers_need_sorting_ = true;
 }
 
 void WorkerPool::OnWorkCompletedOnWorkerThread() {
   // Post idle handler task when pool work count reaches 0.
   if (base::subtle::Barrier_AtomicIncrement(&pending_task_count_, -1) == 0) {
     origin_loop_->PostTask(FROM_HERE, idle_callback_);
   }
 }
 
 void WorkerPool::OnIdle() {

[reveman, 2013/02/14 21:10:49]

do we need to make sure this is not called when we have pending cheap tasks?

[Sami, 2013/02/15 16:41:22]

Good point. I made it a no-op if there are pending cheap tasks -- as opposed to
canceling the callback entirely since it's posted from the worker thread.

+  TRACE_EVENT0("cc", "WorkerPool::OnIdle");
   if (base::subtle::Acquire_Load(&pending_task_count_) == 0) {
     check_for_completed_tasks_callback_.Cancel();
     CheckForCompletedTasks();
   }
 }
 
 void WorkerPool::CheckForCompletedTasks() {
+  TRACE_EVENT0("cc", "WorkerPool::CheckForCompletedTasks");
   check_for_completed_tasks_pending_ = false;
 
   for (WorkerVector::iterator it = workers_.begin();
        it != workers_.end(); it++) {
     Worker* worker = *it;
     worker->CheckForCompletedTasks();
   }
 
   client_->DidFinishDispatchingWorkerPoolCompletionCallbacks();
 
@@ skipping 12 matching lines @@
 }
 
 void WorkerPool::SortWorkersIfNeeded() {
   if (!workers_need_sorting_)
     return;
 
   std::sort(workers_.begin(), workers_.end(), NumPendingTasksComparator());
   workers_need_sorting_ = false;
 }
 
+bool WorkerPool::CanPostCheapTask() const {
+  return pending_cheap_tasks_.size() < kMaxCheapTaskCount;
+}
+
+void WorkerPool::PostCheapTask(scoped_ptr<internal::WorkerPoolTask> task) {
+  DCHECK(CanPostCheapTask());
+  pending_cheap_tasks_.push_back(task.Pass());
+  if (!run_cheap_tasks_pending_) {
+    origin_loop_->PostTask(FROM_HERE, cheap_task_callback_);

[reveman, 2013/02/14 21:10:49]

Please add a ScheduleRunCheapTasks(). And you'll need to call
ScheduleCheckForCompletedTasks() here too.

[Sami, 2013/02/15 16:41:22]

Done. See below for why I didn't add the ScheduleCheckForCompletedTasks().

+    run_cheap_tasks_pending_ = true;
+  }
+}
+
+void WorkerPool::RunCheapTasks() {
+  // Run as many cheap tasks as we can within the time limit.
+  TRACE_EVENT0("cc", "WorkerPool::RunCheapTasks");
+  base::TimeTicks deadline = base::TimeTicks::Now() +
+      base::TimeDelta::FromMilliseconds(kMaxCheapTaskMs);

[reveman, 2013/02/14 21:10:49]

Should the deadline for cheap tasks not be something like: nextVSyncTickTime -
10ms?

You'll also need to set something like check_for_completed_tasks_time_ in
ScheduleCheckForCompletedTasks and use that to determine when
CheckForCompletedTasks() needs to be called.

When reaching check_for_completed_tasks_time_ you can probably just make the
call to CheckForCompletedTasks() and then keep running more cheap tasks until
the deadline.

[Sami, 2013/02/15 16:41:22]

I'm not sure that's ideal. One of the sites this optimization is aimed for
(JSGameBench) tries to run at a constant 30 fps. That means that by the time we
get around to running cheap tasks the "next" vsync is already gone. Perhaps we
could try to estimate where we are in a vsync period and only allow this work
during the first part, although I can see that becoming very unpredictable. I
think allowing 6 ms of cheap tasks per tile management operation is a reasonable
compromise.
Done.

+  while (pending_cheap_tasks_.size()) {
+    scoped_ptr<internal::WorkerPoolTask> task =
+        pending_cheap_tasks_.take_front();
+    task->Run(cheap_rendering_stats_.get());
+    task->DidComplete();

[reveman, 2013/02/14 21:10:49]

Can we have this DidComplete call be done by CheckForCompletedTasks instead?
That makes the flow more like the tasks that run on worker threads and if we
ever need to add
WorkerPoolClient::WillStartDispatchingWorkerPoolCompletionCallbacks() we could
do that.

[Sami, 2013/02/15 16:41:22]

Good idea, I've moved the DidComplete() check to CheckForCompletedTasks().
However, I think we should also call CheckCompletedTasks() in this function when
we're done; otherwise a cheap task will always take ~6 ms to complete. Since the
texture upload is only kicked off in the completion callback, this delay seems
excessive. What do you think?

+    if (base::TimeTicks::Now() >= deadline) {
+      TRACE_EVENT_INSTANT0("cc", "WorkerPool::RunCheapTasks out of time");
+      break;
+    }
+  }
+
+  // Defer remaining tasks to worker threads.
+  while (pending_cheap_tasks_.size()) {
+    scoped_ptr<internal::WorkerPoolTask> task =
+        pending_cheap_tasks_.take_front();
+    Worker* worker = GetWorkerForNextTask();
+    task->DeferToThread(worker);

[reveman, 2013/02/14 21:10:49]

move DeferToThread into PostTask if possible.

[Sami, 2013/02/15 16:41:22]

Done.

+    worker->PostTask(task.Pass());
+  }
+  run_cheap_tasks_pending_ = false;
+}
+
 }  // namespace cc