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 "base/memory/linked_ptr.h"
 #include "cc/base/completion_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 
 namespace {
 
+const int kWorkerPoolCount = 3;
+
 class FakeWorkerPoolTaskImpl : public internal::WorkerPoolTask {
  public:
   FakeWorkerPoolTaskImpl(const base::Closure& callback,
                          const base::Closure& reply)
       : callback_(callback),
         reply_(reply) {
   }
 
   // Overridden from internal::WorkerPoolTask:
   virtual void RunOnWorkerThread(unsigned thread_index) OVERRIDE {
@@ skipping 27 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);
+  static linked_ptr<FakeWorkerPool> Create() {
+    return make_linked_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,
@@ skipping 59 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FakeWorkerPool);
 };
 
 class WorkerPoolTest : public testing::Test {
  public:
   WorkerPoolTest() {}
   virtual ~WorkerPoolTest() {}
 
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
-    worker_pool_ = FakeWorkerPool::Create();
+    for (int i = 0; i < kWorkerPoolCount; ++i)
+      worker_pools_.push_back(FakeWorkerPool::Create());
   }
   virtual void TearDown() OVERRIDE {
-    worker_pool_->Shutdown();
-    worker_pool_->CheckForCompletedTasks();
-  }
-
-  void ResetIds() {
-    run_task_ids_.clear();
-    on_task_completed_ids_.clear();
-  }
-
-  void RunAllTasks() {
-    worker_pool_->WaitForTasksToComplete();
-    worker_pool_->CheckForCompletedTasks();
-  }
-
-  FakeWorkerPool* worker_pool() {
-    return worker_pool_.get();
-  }
-
-  void RunTask(unsigned id) {
-    run_task_ids_.push_back(id);
-  }
-
-  void OnTaskCompleted(unsigned id) {
-    on_task_completed_ids_.push_back(id);
-  }
-
-  const std::vector<unsigned>& run_task_ids() {
-    return run_task_ids_;
-  }
-
-  const std::vector<unsigned>& on_task_completed_ids() {
-    return on_task_completed_ids_;
+    for (int i = 0; i < kWorkerPoolCount; ++i) {
+      worker_pools_[i]->Shutdown();
+      worker_pools_[i]->CheckForCompletedTasks();
+    }
+  }
+
+  void ResetAllIdsforWorkerPool(int worker_pool_index) {
+    run_task_ids_[worker_pool_index].clear();
+    on_task_completed_ids_[worker_pool_index].clear();
+  }
+
+  void RunAllTasksforWorkerPool(int worker_pool_index) {
+    worker_pools_[worker_pool_index]->WaitForTasksToComplete();
+    worker_pools_[worker_pool_index]->CheckForCompletedTasks();
+  }
+
+  FakeWorkerPool* worker_pool(int worker_pool_index) {
+    return worker_pools_[worker_pool_index].get();
+  }
+
+  void RunTask(int worker_pool_index, unsigned id) {
+    run_task_ids_[worker_pool_index].push_back(id);
+  }
+
+  void OnTaskCompleted(int worker_pool_index, unsigned id) {
+    on_task_completed_ids_[worker_pool_index].push_back(id);
+  }
+
+  const std::vector<unsigned>& run_task_ids(int worker_pool_index) {
+    return run_task_ids_[worker_pool_index];
+  }
+
+  const std::vector<unsigned>& on_task_completed_ids(int worker_pool_index) {
+    return on_task_completed_ids_[worker_pool_index];
   }
 
  private:
-  scoped_ptr<FakeWorkerPool> worker_pool_;
-  std::vector<unsigned> run_task_ids_;
-  std::vector<unsigned> on_task_completed_ids_;
+  std::vector<linked_ptr<FakeWorkerPool> > worker_pools_;

[reveman, 2014/01/14 08:44:24]

Sorry that I forgot to ask this before but did you try making this
"scoped_ptr<FakeWorkerPool> worker_pool_[kWorkerPoolCount]"? That would probably
be cleanest.

[sohanjg, 2014/01/14 09:05:59]

Done.
I tried earlier at each test level, but not here.

+  std::vector<unsigned> run_task_ids_[kWorkerPoolCount];
+  std::vector<unsigned> on_task_completed_ids_[kWorkerPoolCount];
 };
 
 TEST_F(WorkerPoolTest, Basic) {
-  EXPECT_EQ(0u, run_task_ids().size());
-  EXPECT_EQ(0u, on_task_completed_ids().size());
-
-  worker_pool()->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)));
-  RunAllTasks();
-
-  EXPECT_EQ(1u, run_task_ids().size());
-  EXPECT_EQ(1u, on_task_completed_ids().size());
-
-  worker_pool()->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)));
-  RunAllTasks();
-
-  EXPECT_EQ(3u, run_task_ids().size());
-  EXPECT_EQ(2u, on_task_completed_ids().size());
-
-  worker_pool()->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)));
-  RunAllTasks();
-
-  EXPECT_EQ(6u, run_task_ids().size());
-  EXPECT_EQ(3u, on_task_completed_ids().size());
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    EXPECT_EQ(0u, run_task_ids(i).size());
+    EXPECT_EQ(0u, on_task_completed_ids(i).size());
+
+    worker_pool(i)->ScheduleTasks(
+        std::vector<FakeWorkerPool::Task>(
+            1,
+            FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                            base::Unretained(this),
+                                            i,
+                                            0u),
+                                 base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                            base::Unretained(this),
+                                            i,
+                                            0u),
+                                 base::Closure(),
+                                 1u,
+                                 0u)));
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    RunAllTasksforWorkerPool(i);
+
+    EXPECT_EQ(1u, run_task_ids(i).size());
+    EXPECT_EQ(1u, on_task_completed_ids(i).size());
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    worker_pool(i)->ScheduleTasks(
+        std::vector<FakeWorkerPool::Task>(
+            1,
+            FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                            base::Unretained(this),
+                                            i,
+                                            0u),
+                                 base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                            base::Unretained(this),
+                                            i,
+                                            0u),
+                                 base::Bind(&WorkerPoolTest::RunTask,
+                                            base::Unretained(this),
+                                            i,
+                                            0u),
+                                 1u,
+                                 0u)));
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    RunAllTasksforWorkerPool(i);
+
+    EXPECT_EQ(3u, run_task_ids(i).size());
+    EXPECT_EQ(2u, on_task_completed_ids(i).size());
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    worker_pool(i)->ScheduleTasks(
+        std::vector<FakeWorkerPool::Task>(
+            1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                               base::Unretained(this),
+                                               i,
+                                               0u),
+                                    base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                               base::Unretained(this),
+                                               i,
+                                               0u),
+                                    base::Bind(&WorkerPoolTest::RunTask,
+                                               base::Unretained(this),
+                                               i,
+                                               0u),
+                                    2u,
+                                    0u)));
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    RunAllTasksforWorkerPool(i);
+
+    EXPECT_EQ(6u, run_task_ids(i).size());
+    EXPECT_EQ(3u, on_task_completed_ids(i).size());
+  }
 }
 
 TEST_F(WorkerPoolTest, Dependencies) {
-  worker_pool()->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)));
-  RunAllTasks();
-
-  // 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_pool()->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)));
-  RunAllTasks();
-
-  // 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]);
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    worker_pool(i)->ScheduleTasks(
+        std::vector<FakeWorkerPool::Task>(
+            1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                               base::Unretained(this),
+                                               i,
+                                               0u),
+                                    base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                               base::Unretained(this),
+                                               i,
+                                               0u),
+                                    base::Bind(&WorkerPoolTest::RunTask,
+                                               base::Unretained(this),
+                                               i,
+                                               1u),
+                                    1u,
+                                    0u)));
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    RunAllTasksforWorkerPool(i);
+
+    // Check if task ran before dependent.
+    ASSERT_EQ(2u, run_task_ids(i).size());
+    EXPECT_EQ(0u, run_task_ids(i)[0]);
+    EXPECT_EQ(1u, run_task_ids(i)[1]);
+    ASSERT_EQ(1u, on_task_completed_ids(i).size());
+    EXPECT_EQ(0u, on_task_completed_ids(i)[0]);
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    worker_pool(i)->ScheduleTasks(
+        std::vector<FakeWorkerPool::Task>(
+            1, FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
+                                               base::Unretained(this),
+                                               i,
+                                               2u),
+                                    base::Bind(&WorkerPoolTest::OnTaskCompleted,
+                                               base::Unretained(this),
+                                               i,
+                                               2u),
+                                    base::Bind(&WorkerPoolTest::RunTask,
+                                               base::Unretained(this),
+                                               i,
+                                               3u),
+                                    2u,
+                                    0u)));
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    RunAllTasksforWorkerPool(i);
+
+    // Task should only run once.
+    ASSERT_EQ(5u, run_task_ids(i).size());
+    EXPECT_EQ(2u, run_task_ids(i)[2]);
+    EXPECT_EQ(3u, run_task_ids(i)[3]);
+    EXPECT_EQ(3u, run_task_ids(i)[4]);
+    ASSERT_EQ(2u, on_task_completed_ids(i).size());
+    EXPECT_EQ(2u, on_task_completed_ids(i)[1]);
+  }
 }
 
 TEST_F(WorkerPoolTest, Priority) {
-  {
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
     FakeWorkerPool::Task tasks[] = {
         FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         0u),
                              base::Bind(&WorkerPoolTest::OnTaskCompleted,
                                         base::Unretained(this),
+                                        i,
                                         0u),
                              base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         2u),
                              1u,
                              1u),  // Priority 1
         FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         1u),
                              base::Bind(&WorkerPoolTest::OnTaskCompleted,
                                         base::Unretained(this),
+                                        i,
                                         1u),
                              base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         3u),
                              1u,
                              0u)  // Priority 0
     };
-    worker_pool()->ScheduleTasks(
+    worker_pool(i)->ScheduleTasks(
         std::vector<FakeWorkerPool::Task>(tasks, tasks + arraysize(tasks)));
   }
-  RunAllTasks();
-
-  // 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();
-  {
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    RunAllTasksforWorkerPool(i);
+
+    // Check if tasks ran in order of priority.
+    ASSERT_EQ(4u, run_task_ids(i).size());
+    EXPECT_EQ(1u, run_task_ids(i)[0]);
+    EXPECT_EQ(3u, run_task_ids(i)[1]);
+    EXPECT_EQ(0u, run_task_ids(i)[2]);
+    EXPECT_EQ(2u, run_task_ids(i)[3]);
+    ASSERT_EQ(2u, on_task_completed_ids(i).size());
+    EXPECT_EQ(1u, on_task_completed_ids(i)[0]);
+    EXPECT_EQ(0u, on_task_completed_ids(i)[1]);
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i)
+    ResetAllIdsforWorkerPool(i);
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
     std::vector<FakeWorkerPool::Task> tasks;
     tasks.push_back(
         FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         0u),
                              base::Bind(&WorkerPoolTest::OnTaskCompleted,
                                         base::Unretained(this),
+                                        i,
                                         0u),
                              base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         3u),
                              1u,    // 1 dependent
                              1u));  // Priority 1
     tasks.push_back(
         FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         1u),
                              base::Bind(&WorkerPoolTest::OnTaskCompleted,
                                         base::Unretained(this),
+                                        i,
                                         1u),
                              base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         4u),
                              2u,    // 2 dependents
                              1u));  // Priority 1
     tasks.push_back(
         FakeWorkerPool::Task(base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         2u),
                              base::Bind(&WorkerPoolTest::OnTaskCompleted,
                                         base::Unretained(this),
+                                        i,
                                         2u),
                              base::Bind(&WorkerPoolTest::RunTask,
                                         base::Unretained(this),
+                                        i,
                                         5u),
                              1u,    // 1 dependent
                              0u));  // Priority 0
-    worker_pool()->ScheduleTasks(tasks);
-  }
-  RunAllTasks();
-
-  // 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]);
+    worker_pool(i)->ScheduleTasks(tasks);
+  }
+
+  for (int i = 0; i < kWorkerPoolCount; ++i) {
+    RunAllTasksforWorkerPool(i);
+
+    // 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(i).size());
+    EXPECT_EQ(2u, run_task_ids(i)[0]);
+    EXPECT_EQ(5u, run_task_ids(i)[1]);
+    EXPECT_EQ(1u, run_task_ids(i)[2]);
+    ASSERT_EQ(3u, on_task_completed_ids(i).size());
+    EXPECT_EQ(2u, on_task_completed_ids(i)[0]);
+    EXPECT_EQ(1u, on_task_completed_ids(i)[1]);
+    EXPECT_EQ(0u, on_task_completed_ids(i)[2]);
+  }
 }
 
 }  // namespace
 
 }  // namespace cc