Shared Raster Worker Threads

cc/resources/worker_pool_unittest.cc

Index: cc/resources/worker_pool_unittest.cc
diff --git a/cc/resources/worker_pool_unittest.cc b/cc/resources/worker_pool_unittest.cc
old mode 100644
new mode 100755
index f7c5a951df6de92dffb4b344f2fce408b06f3298..8f3f831c4b75387f43487b714f546f4d231093b9
--- a/cc/resources/worker_pool_unittest.cc
+++ b/cc/resources/worker_pool_unittest.cc
@@ -60,7 +60,7 @@ class FakeWorkerPool : public WorkerPool {
     unsigned dependent_count;
     unsigned priority;
   };
-  FakeWorkerPool() : WorkerPool(1, "test") {}
+  FakeWorkerPool() : WorkerPool() {}
   virtual ~FakeWorkerPool() {}
 
   static scoped_ptr<FakeWorkerPool> Create() {
@@ -80,6 +80,8 @@ class FakeWorkerPool : public WorkerPool {
     scoped_ptr<internal::GraphNode> completion_node(
         new internal::GraphNode(new_completion_task.get(), 0u));
 
+
+

[reveman, 2014/01/09 16:04:26]

no need to add these 2 blank lines

[sohanjg, 2014/01/10 15:12:31]

Done.

     for (std::vector<Task>::const_iterator it = tasks.begin();
          it != tasks.end(); ++it) {
       scoped_refptr<FakeWorkerPoolTaskImpl> new_task(
@@ -108,9 +110,7 @@ class FakeWorkerPool : public WorkerPool {
     new_graph.set(new_completion_task.get(), completion_node.Pass());
 
     scheduled_tasks_completion_.reset(new CompletionEvent);
-

[reveman, 2014/01/09 16:04:26]

no need to remove this blank line

[sohanjg, 2014/01/10 15:12:31]

Done.

     SetTaskGraph(&new_graph);
-

[reveman, 2014/01/09 16:04:26]

no need to remove this blank line

[sohanjg, 2014/01/10 15:12:31]

Done.

     dependents_.swap(new_dependents);
     completion_task_.swap(new_completion_task);
     tasks_.swap(new_tasks);
@@ -389,6 +389,230 @@ TEST_F(WorkerPoolTest, Priority) {
   EXPECT_EQ(0u, on_task_completed_ids()[2]);
 }
 
+TEST_F(WorkerPoolTest, MultipleWorkerPoolBasic) {
+  ResetIds();
+
+  EXPECT_EQ(0u, run_task_ids().size());
+  EXPECT_EQ(0u, on_task_completed_ids().size());
+
+  // Setup multiple workerpool.
+  scoped_ptr<FakeWorkerPool>worker_pool1 = FakeWorkerPool::Create();
+  scoped_ptr<FakeWorkerPool>worker_pool2 = FakeWorkerPool::Create();
+  scoped_ptr<FakeWorkerPool>worker_pool3 = FakeWorkerPool::Create();
+
+  worker_pool1->ScheduleTasks(
+      std::vector<FakeWorkerPool::Task>(
+          1,
+          FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                          base::Unretained(this),
+                                          0u),
+                               base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                          base::Unretained(this),
+                                          0u),
+                               base::Closure(),
+                               1u,
+                               0u)));
+  worker_pool1->WaitForTasksToComplete();
+  worker_pool1->CheckForCompletedTasks();
+
+  EXPECT_EQ(1u, run_task_ids().size());
+  EXPECT_EQ(1u, on_task_completed_ids().size());
+
+  worker_pool2->ScheduleTasks(
+      std::vector<FakeWorkerPool::Task>(
+          1,
+          FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                          base::Unretained(this),
+                                          0u),
+                               base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                          base::Unretained(this),
+                                          0u),
+                               base::Bind(&WorkerPoolTest::RunTask,
+                                          base::Unretained(this),
+                                          0u),
+                               1u,
+                               0u)));
+
+  worker_pool2->WaitForTasksToComplete();
+  worker_pool2->CheckForCompletedTasks();
+
+  EXPECT_EQ(3u, run_task_ids().size());
+  EXPECT_EQ(2u, on_task_completed_ids().size());
+
+  worker_pool3->ScheduleTasks(
+      std::vector<FakeWorkerPool::Task>(
+          1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                             base::Unretained(this),
+                                             0u),
+                                  base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                             base::Unretained(this),
+                                             0u),
+                                  base::Bind(&WorkerPoolTest::RunTask,
+                                             base::Unretained(this),
+                                             0u),
+                                  2u,
+                                  0u)));
+  worker_pool3->WaitForTasksToComplete();
+  worker_pool3->CheckForCompletedTasks();
+
+  EXPECT_EQ(6u, run_task_ids().size());
+  EXPECT_EQ(3u, on_task_completed_ids().size());
+}
+
+TEST_F(WorkerPoolTest, MultipleWorkerPoolDependencies) {
+  // Setup multiple workerpool.
+  scoped_ptr<FakeWorkerPool>worker_pool1 = FakeWorkerPool::Create();
+  scoped_ptr<FakeWorkerPool>worker_pool2 = FakeWorkerPool::Create();
+
+  worker_pool1->ScheduleTasks(
+      std::vector<FakeWorkerPool::Task>(
+          1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                             base::Unretained(this),
+                                             0u),
+                                  base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                             base::Unretained(this),
+                                             0u),
+                                  base::Bind(&WorkerPoolTest::RunTask,
+                                             base::Unretained(this),
+                                             1u),
+                                  1u,
+                                  0u)));
+  worker_pool1->WaitForTasksToComplete();
+  worker_pool1->CheckForCompletedTasks();
+
+  // Check if task ran before dependent.
+  ASSERT_EQ(2u, run_task_ids().size());
+  EXPECT_EQ(0u, run_task_ids()[0]);
+  EXPECT_EQ(1u, run_task_ids()[1]);
+  ASSERT_EQ(1u, on_task_completed_ids().size());
+  EXPECT_EQ(0u, on_task_completed_ids()[0]);
+
+  worker_pool2->ScheduleTasks(
+      std::vector<FakeWorkerPool::Task>(
+          1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                             base::Unretained(this),
+                                             2u),
+                                  base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                             base::Unretained(this),
+                                             2u),
+                                  base::Bind(&WorkerPoolTest::RunTask,
+                                             base::Unretained(this),
+                                             3u),
+                                  2u,
+                                  0u)));
+  worker_pool2->WaitForTasksToComplete();
+  worker_pool2->CheckForCompletedTasks();
+
+  // Task should only run once.
+  ASSERT_EQ(5u, run_task_ids().size());
+  EXPECT_EQ(2u, run_task_ids()[2]);
+  EXPECT_EQ(3u, run_task_ids()[3]);
+  EXPECT_EQ(3u, run_task_ids()[4]);
+  ASSERT_EQ(2u, on_task_completed_ids().size());
+  EXPECT_EQ(2u, on_task_completed_ids()[1]);
+}
+
+TEST_F(WorkerPoolTest, MultipleWorkerPoolPriority) {
+  // Setup multiple workerpool.
+  scoped_ptr<FakeWorkerPool>worker_pool1 = FakeWorkerPool::Create();
+  scoped_ptr<FakeWorkerPool>worker_pool2 = FakeWorkerPool::Create();
+  {
+    FakeWorkerPool::Task tasks[] = {
+        FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        0u),
+                             base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                        base::Unretained(this),
+                                        0u),
+                             base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        2u),
+                             1u,
+                             1u),  // Priority 1
+        FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        1u),
+                             base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                        base::Unretained(this),
+                                        1u),
+                             base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        3u),
+                             1u,
+                             0u)  // Priority 0
+    };
+    worker_pool1->ScheduleTasks(
+        std::vector<FakeWorkerPool::Task>(tasks, tasks + arraysize(tasks)));
+  }
+  worker_pool1->WaitForTasksToComplete();
+  worker_pool1->CheckForCompletedTasks();
+
+  // Check if tasks ran in order of priority.
+  ASSERT_EQ(4u, run_task_ids().size());
+  EXPECT_EQ(1u, run_task_ids()[0]);
+  EXPECT_EQ(3u, run_task_ids()[1]);
+  EXPECT_EQ(0u, run_task_ids()[2]);
+  EXPECT_EQ(2u, run_task_ids()[3]);
+  ASSERT_EQ(2u, on_task_completed_ids().size());
+  EXPECT_EQ(1u, on_task_completed_ids()[0]);
+  EXPECT_EQ(0u, on_task_completed_ids()[1]);
+
+  ResetIds();
+  {
+    std::vector<FakeWorkerPool::Task> tasks;
+    tasks.push_back(
+        FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        0u),
+                             base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                        base::Unretained(this),
+                                        0u),
+                             base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        3u),
+                             1u,    // 1 dependent
+                             1u));  // Priority 1
+    tasks.push_back(
+        FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        1u),
+                             base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                        base::Unretained(this),
+                                        1u),
+                             base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        4u),
+                             2u,    // 2 dependents
+                             1u));  // Priority 1
+    tasks.push_back(
+        FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        2u),
+                             base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                        base::Unretained(this),
+                                        2u),
+                             base::Bind(&WorkerPoolTest::RunTask,
+                                        base::Unretained(this),
+                                        5u),
+                             1u,    // 1 dependent
+                             0u));  // Priority 0
+    worker_pool2->ScheduleTasks(tasks);
+  }
+  worker_pool2->WaitForTasksToComplete();
+  worker_pool2->CheckForCompletedTasks();
+
+  // Check if tasks ran in order of priority and that task with more
+  // dependents ran first when priority is the same.
+  ASSERT_LE(3u, run_task_ids().size());
+  EXPECT_EQ(2u, run_task_ids()[0]);
+  EXPECT_EQ(5u, run_task_ids()[1]);
+  EXPECT_EQ(1u, run_task_ids()[2]);
+  ASSERT_EQ(3u, on_task_completed_ids().size());
+  EXPECT_EQ(2u, on_task_completed_ids()[0]);
+  EXPECT_EQ(1u, on_task_completed_ids()[1]);
+  EXPECT_EQ(0u, on_task_completed_ids()[2]);
+}

[reveman, 2014/01/09 16:04:26]

I'd like to see the tests run tasks from multiple worker pool instances at the
same time instead of waiting for all tasks to finish before using another worker
pool instance as that's not a realistic use case.

Using the existing test logic for multiple worker pool instances is a good idea
but let's instead adjust the existing test code so it can run with 1-N worker
pool instances instead of duplicating all this logic.

Always using 3 worker pool instances is fine for now but let's make sure it's
easy to parameterize this later.

+
 }  // namespace
 
 }  // namespace cc