Revert of cc: Remove WorkerPool class and instead use TaskGraphRunner directly.

cc/resources/worker_pool_perftest.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 "base/time/time.h"
+#include "cc/base/completion_event.h"
+#include "cc/test/lap_timer.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/perf/perf_test.h"
+
+namespace cc {
+
+namespace {
+
+static const int kTimeLimitMillis = 2000;
+static const int kWarmupRuns = 5;
+static const int kTimeCheckInterval = 10;
+
+class PerfWorkerPoolTaskImpl : public internal::WorkerPoolTask {
+ public:
+  // Overridden from internal::WorkerPoolTask:
+  virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {}
+  virtual void CompleteOnOriginThread() OVERRIDE {}
+
+ private:
+  virtual ~PerfWorkerPoolTaskImpl() {}
+};
+
+class PerfControlWorkerPoolTaskImpl : public internal::WorkerPoolTask {
+ public:
+  PerfControlWorkerPoolTaskImpl() : did_start_(new CompletionEvent),
+                                    can_finish_(new CompletionEvent) {}
+
+  // Overridden from internal::WorkerPoolTask:
+  virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
+    did_start_->Signal();
+    can_finish_->Wait();
+  }
+  virtual void CompleteOnOriginThread() OVERRIDE {}
+
+  void WaitForTaskToStartRunning() {
+    did_start_->Wait();
+  }
+
+  void AllowTaskToFinish() {
+    can_finish_->Signal();
+  }
+
+ private:
+  virtual ~PerfControlWorkerPoolTaskImpl() {}
+
+  scoped_ptr<CompletionEvent> did_start_;
+  scoped_ptr<CompletionEvent> can_finish_;
+
+  DISALLOW_COPY_AND_ASSIGN(PerfControlWorkerPoolTaskImpl);
+};
+
+class PerfWorkerPool : public WorkerPool {
+ public:
+  PerfWorkerPool() : WorkerPool() {}
+  virtual ~PerfWorkerPool() {}
+
+  static scoped_ptr<PerfWorkerPool> Create() {
+    return make_scoped_ptr(new PerfWorkerPool);
+  }
+
+  void ScheduleTasks(internal::WorkerPoolTask* root_task,
+                     internal::WorkerPoolTask* leaf_task,
+                     unsigned max_depth,
+                     unsigned num_children_per_node) {
+    TaskVector tasks;
+    TaskGraph graph;
+
+    scoped_ptr<internal::GraphNode> root_node;
+    if (root_task)
+      root_node = make_scoped_ptr(new internal::GraphNode(root_task, 0u));
+
+    scoped_ptr<internal::GraphNode> leaf_node;
+    if (leaf_task)
+      leaf_node = make_scoped_ptr(new internal::GraphNode(leaf_task, 0u));
+
+    if (max_depth) {
+      BuildTaskGraph(&tasks,
+                     &graph,
+                     root_node.get(),
+                     leaf_node.get(),
+                     0,
+                     max_depth,
+                     num_children_per_node);
+    }
+
+    if (leaf_node)
+      graph.set(leaf_task, leaf_node.Pass());
+
+    if (root_node)
+      graph.set(root_task, root_node.Pass());
+
+    SetTaskGraph(&graph);
+
+    tasks_.swap(tasks);
+  }
+
+  void CheckForCompletedTasks() {
+    CheckForCompletedWorkerTasks();
+  }
+
+ private:
+  typedef std::vector<scoped_refptr<internal::WorkerPoolTask> > TaskVector;
+
+  void BuildTaskGraph(TaskVector* tasks,
+                      TaskGraph* graph,
+                      internal::GraphNode* dependent_node,
+                      internal::GraphNode* leaf_node,
+                      unsigned current_depth,
+                      unsigned max_depth,
+                      unsigned num_children_per_node) {
+    scoped_refptr<PerfWorkerPoolTaskImpl> task(new PerfWorkerPoolTaskImpl);
+    scoped_ptr<internal::GraphNode> node(
+        new internal::GraphNode(task.get(), 0u));
+
+    if (current_depth < max_depth) {
+      for (unsigned i = 0; i < num_children_per_node; ++i) {
+        BuildTaskGraph(tasks,
+                       graph,
+                       node.get(),
+                       leaf_node,
+                       current_depth + 1,
+                       max_depth,
+                       num_children_per_node);
+      }
+    } else if (leaf_node) {
+      leaf_node->add_dependent(node.get());
+      node->add_dependency();
+    }
+
+    if (dependent_node) {
+      node->add_dependent(dependent_node);
+      dependent_node->add_dependency();
+    }
+    graph->set(task.get(), node.Pass());
+    tasks->push_back(task.get());
+  }
+
+  TaskVector tasks_;
+
+  DISALLOW_COPY_AND_ASSIGN(PerfWorkerPool);
+};
+
+class WorkerPoolPerfTest : public testing::Test {
+ public:
+  WorkerPoolPerfTest()
+      : timer_(kWarmupRuns,
+               base::TimeDelta::FromMilliseconds(kTimeLimitMillis),
+               kTimeCheckInterval) {}
+
+  // Overridden from testing::Test:
+  virtual void SetUp() OVERRIDE {
+    worker_pool_ = PerfWorkerPool::Create();
+  }
+  virtual void TearDown() OVERRIDE {
+    worker_pool_->Shutdown();
+    worker_pool_->CheckForCompletedTasks();
+  }
+
+  void AfterTest(const std::string& test_name) {
+    // Format matches chrome/test/perf/perf_test.h:PrintResult
+    printf(
+        "*RESULT %s: %.2f runs/s\n", test_name.c_str(), timer_.LapsPerSecond());
+  }
+
+  void RunScheduleTasksTest(const std::string& test_name,
+                            unsigned max_depth,
+                            unsigned num_children_per_node) {
+    timer_.Reset();
+    do {
+      scoped_refptr<PerfControlWorkerPoolTaskImpl> leaf_task(
+          new PerfControlWorkerPoolTaskImpl);
+      worker_pool_->ScheduleTasks(
+          NULL, leaf_task.get(), max_depth, num_children_per_node);
+      leaf_task->WaitForTaskToStartRunning();
+      worker_pool_->ScheduleTasks(NULL, NULL, 0, 0);
+      worker_pool_->CheckForCompletedTasks();
+      leaf_task->AllowTaskToFinish();
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    perf_test::PrintResult("schedule_tasks", "", test_name,
+                           timer_.LapsPerSecond(), "runs/s", true);
+  }
+
+  void RunExecuteTasksTest(const std::string& test_name,
+                           unsigned max_depth,
+                           unsigned num_children_per_node) {
+    timer_.Reset();
+    do {
+      scoped_refptr<PerfControlWorkerPoolTaskImpl> root_task(
+          new PerfControlWorkerPoolTaskImpl);
+      worker_pool_->ScheduleTasks(
+          root_task.get(), NULL, max_depth, num_children_per_node);
+      root_task->WaitForTaskToStartRunning();
+      root_task->AllowTaskToFinish();
+      worker_pool_->CheckForCompletedTasks();
+      timer_.NextLap();
+    } while (!timer_.HasTimeLimitExpired());
+
+    perf_test::PrintResult("execute_tasks", "", test_name,
+                           timer_.LapsPerSecond(), "runs/s", true);
+  }
+
+ protected:
+  scoped_ptr<PerfWorkerPool> worker_pool_;
+  LapTimer timer_;
+};
+
+TEST_F(WorkerPoolPerfTest, ScheduleTasks) {
+  RunScheduleTasksTest("1_10", 1, 10);
+  RunScheduleTasksTest("1_1000", 1, 1000);
+  RunScheduleTasksTest("2_10", 2, 10);
+  RunScheduleTasksTest("5_5", 5, 5);
+  RunScheduleTasksTest("10_2", 10, 2);
+  RunScheduleTasksTest("1000_1", 1000, 1);
+  RunScheduleTasksTest("10_1", 10, 1);
+}
+
+TEST_F(WorkerPoolPerfTest, ExecuteTasks) {
+  RunExecuteTasksTest("1_10", 1, 10);
+  RunExecuteTasksTest("1_1000", 1, 1000);
+  RunExecuteTasksTest("2_10", 2, 10);
+  RunExecuteTasksTest("5_5", 5, 5);
+  RunExecuteTasksTest("10_2", 10, 2);
+  RunExecuteTasksTest("1000_1", 1000, 1);
+  RunExecuteTasksTest("10_1", 10, 1);
+}
+
+}  // namespace
+
+}  // namespace cc