Shared Raster Worker Threads

cc/resources/worker_pool_unittest.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 <vector>
 
 #include "cc/base/completion_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 42 matching lines @@
                               dependent_count(dependent_count),
                               priority(priority) {
     }
 
     base::Closure callback;
     base::Closure reply;
     base::Closure dependent;
     unsigned dependent_count;
     unsigned priority;
   };
-  FakeWorkerPool() : WorkerPool(1, "test") {}
+  FakeWorkerPool() : WorkerPool() {}
   virtual ~FakeWorkerPool() {}
 
   static scoped_ptr<FakeWorkerPool> Create() {
     return make_scoped_ptr(new FakeWorkerPool);
   }
 
   void ScheduleTasks(const std::vector<Task>& tasks) {
     TaskVector new_tasks;
     TaskVector new_dependents;
     TaskGraph new_graph;
 
     scoped_refptr<FakeWorkerPoolTaskImpl> new_completion_task(
         new FakeWorkerPoolTaskImpl(
             base::Bind(&FakeWorkerPool::OnTasksCompleted,
                        base::Unretained(this)),
             base::Closure()));
     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(
           new FakeWorkerPoolTaskImpl(it->callback, it->reply));
       scoped_ptr<internal::GraphNode> node(
           new internal::GraphNode(new_task.get(), it->priority));
 
       DCHECK(it->dependent_count);
       for (unsigned i = 0; i < it->dependent_count; ++i) {
         scoped_refptr<FakeWorkerPoolTaskImpl> new_dependent_task(
             new FakeWorkerPoolTaskImpl(it->dependent, base::Closure()));
         scoped_ptr<internal::GraphNode> dependent_node(
             new internal::GraphNode(new_dependent_task.get(), it->priority));
         dependent_node->add_dependent(completion_node.get());
         completion_node->add_dependency();
         node->add_dependent(dependent_node.get());
         dependent_node->add_dependency();
         new_graph.set(new_dependent_task.get(), dependent_node.Pass());
         new_dependents.push_back(new_dependent_task.get());
       }
 
       new_graph.set(new_task.get(), node.Pass());
       new_tasks.push_back(new_task.get());
     }
 
     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);
   }
 
   void WaitForTasksToComplete() {
     DCHECK(scheduled_tasks_completion_);
     scheduled_tasks_completion_->Wait();
   }
 
@@ skipping 258 matching lines @@
   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]);
 }
 
+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