Add case to verify task priority and category

Current case only cover dependency. The added cases verify task with different priority
and category runs in predefined order.


Bug: None
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: I185d4fab123c5318df4e60f99506fa20dc622ab7
Reviewed-on: https://chromium-review.googlesource.com/1196234Reviewed-by: Eric Karl <ericrk@chromium.org>
Commit-Queue: Xing Xu <xing.xu@intel.com>
Cr-Commit-Position: refs/heads/master@{#592286}

cc/raster/task_graph_work_queue_unittest.cc

@@ -4,6 +4,7 @@
 
 #include "cc/raster/task_graph_work_queue.h"
 
+#include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
@@ -58,5 +59,161 @@ TEST(TaskGraphWorkQueueTest, TestChangingDependency) {
   EXPECT_FALSE(work_queue.HasReadyToRunTasks());
 }
 
+// Tasks with same priority but in different category.
+TEST(TaskGraphWorkQueueTest, TestTaskWithDifferentCategory) {
+  TaskGraphWorkQueue work_queue;
+  NamespaceToken token = work_queue.GenerateNamespaceToken();
+
+  // Create a graph where | task| has dependencies.
+  TaskGraph graph;
+  scoped_refptr<FakeTaskImpl> task(new FakeTaskImpl());
+  scoped_refptr<FakeTaskImpl> dependency_task1(new FakeTaskImpl());
+  scoped_refptr<FakeTaskImpl> dependency_task2(new FakeTaskImpl());
+  scoped_refptr<FakeTaskImpl> dependency_task3(new FakeTaskImpl());
+
+  graph.nodes.push_back(TaskGraph::Node(task.get(), 0u, 0u, 3u));
+  graph.nodes.push_back(TaskGraph::Node(dependency_task1.get(), 0u, 0u, 0u));
+  graph.nodes.push_back(TaskGraph::Node(dependency_task2.get(), 1u, 0u, 0u));
+  graph.nodes.push_back(TaskGraph::Node(dependency_task3.get(), 2u, 0u, 0u));
+
+  graph.edges.push_back(TaskGraph::Edge(dependency_task1.get(), task.get()));
+  graph.edges.push_back(TaskGraph::Edge(dependency_task2.get(), task.get()));
+  graph.edges.push_back(TaskGraph::Edge(dependency_task3.get(), task.get()));
+
+  // Schedule the graph.
+  work_queue.ScheduleTasks(token, &graph);
+
+  // Run the |dependency_task1|from category 0.
+  TaskGraphWorkQueue::PrioritizedTask prioritized_dependency_task =
+      work_queue.GetNextTaskToRun(0u);
+  EXPECT_EQ(prioritized_dependency_task.task.get(), dependency_task1.get());
+  work_queue.CompleteTask(std::move(prioritized_dependency_task));
+  EXPECT_TRUE(work_queue.HasReadyToRunTasks());
+  EXPECT_FALSE(work_queue.HasReadyToRunTasksForCategory(0u));
+  EXPECT_TRUE(work_queue.HasReadyToRunTasksForCategory(1u));
+  EXPECT_TRUE(work_queue.HasReadyToRunTasksForCategory(2u));
+
+  // Run the |dependency_task2|from category 1.
+  prioritized_dependency_task = work_queue.GetNextTaskToRun(1u);
+  EXPECT_EQ(prioritized_dependency_task.task.get(), dependency_task2.get());
+  work_queue.CompleteTask(std::move(prioritized_dependency_task));
+  EXPECT_TRUE(work_queue.HasReadyToRunTasks());
+  EXPECT_FALSE(work_queue.HasReadyToRunTasksForCategory(0u));
+  EXPECT_FALSE(work_queue.HasReadyToRunTasksForCategory(1u));
+  EXPECT_TRUE(work_queue.HasReadyToRunTasksForCategory(2u));
+
+  // Run the |dependency_task3|from category 2.
+  prioritized_dependency_task = work_queue.GetNextTaskToRun(2u);
+  EXPECT_EQ(prioritized_dependency_task.task.get(), dependency_task3.get());
+  work_queue.CompleteTask(std::move(prioritized_dependency_task));
+  EXPECT_TRUE(work_queue.HasReadyToRunTasks());
+  // Once all dependencies from different category completed, | task| turns
+  // ready to run.
+  EXPECT_TRUE(work_queue.HasReadyToRunTasksForCategory(0u));
+  EXPECT_FALSE(work_queue.HasReadyToRunTasksForCategory(1u));
+  EXPECT_FALSE(work_queue.HasReadyToRunTasksForCategory(2u));
+
+  prioritized_dependency_task = work_queue.GetNextTaskToRun(0u);
+  EXPECT_EQ(prioritized_dependency_task.task.get(), task.get());
+  work_queue.CompleteTask(std::move(prioritized_dependency_task));
+  EXPECT_FALSE(work_queue.HasReadyToRunTasks());
+}
+
+// Tasks with different priority run in a priority order. But need to guarantee
+// its dependences are completed.
+TEST(TaskGraphWorkQueueTest, TestTaskWithDifferentPriority) {
+  TaskGraphWorkQueue work_queue;
+  NamespaceToken token = work_queue.GenerateNamespaceToken();
+  {
+    // Create a graph where task has a dependency
+    TaskGraph graph;
+    scoped_refptr<FakeTaskImpl> task(new FakeTaskImpl());
+    scoped_refptr<FakeTaskImpl> dependency_task1(new FakeTaskImpl());
+    scoped_refptr<FakeTaskImpl> dependency_task2(new FakeTaskImpl());
+    scoped_refptr<FakeTaskImpl> dependency_task3(new FakeTaskImpl());
+
+    // | task| has the lowest priority and 3 dependences, will run last.
+    graph.nodes.push_back(TaskGraph::Node(task.get(), 0u, 2u, 3u));
+    graph.nodes.push_back(TaskGraph::Node(dependency_task1.get(), 0u, 3u, 0u));
+    graph.nodes.push_back(TaskGraph::Node(dependency_task2.get(), 0u, 2u, 0u));
+    graph.nodes.push_back(TaskGraph::Node(dependency_task3.get(), 0u, 1u, 0u));
+
+    graph.edges.push_back(TaskGraph::Edge(dependency_task1.get(), task.get()));
+    graph.edges.push_back(TaskGraph::Edge(dependency_task2.get(), task.get()));
+    graph.edges.push_back(TaskGraph::Edge(dependency_task3.get(), task.get()));
+
+    // Schedule the graph.
+    work_queue.ScheduleTasks(token, &graph);
+
+    // Run the |dependency_task|
+    TaskGraphWorkQueue::PrioritizedTask prioritized_dependency_task =
+        work_queue.GetNextTaskToRun(0u);
+    EXPECT_EQ(prioritized_dependency_task.task.get(), dependency_task3.get());
+    work_queue.CompleteTask(std::move(prioritized_dependency_task));
+    EXPECT_TRUE(work_queue.HasReadyToRunTasks());
+
+    prioritized_dependency_task = work_queue.GetNextTaskToRun(0u);
+    EXPECT_EQ(prioritized_dependency_task.task.get(), dependency_task2.get());
+    work_queue.CompleteTask(std::move(prioritized_dependency_task));
+    EXPECT_TRUE(work_queue.HasReadyToRunTasks());
+
+    prioritized_dependency_task = work_queue.GetNextTaskToRun(0u);
+    EXPECT_EQ(prioritized_dependency_task.task.get(), dependency_task1.get());
+    work_queue.CompleteTask(std::move(prioritized_dependency_task));
+    EXPECT_TRUE(work_queue.HasReadyToRunTasks());
+
+    // | task| runs last.
+    prioritized_dependency_task = work_queue.GetNextTaskToRun(0u);
+    EXPECT_EQ(prioritized_dependency_task.task.get(), task.get());
+    work_queue.CompleteTask(std::move(prioritized_dependency_task));
+    EXPECT_FALSE(work_queue.HasReadyToRunTasks());
+  }
+
+  {
+    // Create a graph where task has dependencies
+    TaskGraph graph;
+    scoped_refptr<FakeTaskImpl> task(new FakeTaskImpl());
+    scoped_refptr<FakeTaskImpl> dependency_task1(new FakeTaskImpl());
+    scoped_refptr<FakeTaskImpl> dependency_task2(new FakeTaskImpl());
+    scoped_refptr<FakeTaskImpl> dependency_task3(new FakeTaskImpl());
+
+    // | task| has the highest priority and 3 dependences, also will run last.
+    graph.nodes.push_back(TaskGraph::Node(task.get(), 0u, 0u, 3u));
+    graph.nodes.push_back(TaskGraph::Node(dependency_task1.get(), 0u, 3u, 0u));
+    graph.nodes.push_back(TaskGraph::Node(dependency_task2.get(), 0u, 2u, 0u));
+    graph.nodes.push_back(TaskGraph::Node(dependency_task3.get(), 0u, 1u, 0u));
+
+    graph.edges.push_back(TaskGraph::Edge(dependency_task1.get(), task.get()));
+    graph.edges.push_back(TaskGraph::Edge(dependency_task2.get(), task.get()));
+    graph.edges.push_back(TaskGraph::Edge(dependency_task3.get(), task.get()));
+
+    // Schedule the graph.
+    work_queue.ScheduleTasks(token, &graph);
+
+    // Run the |dependency_task|
+    TaskGraphWorkQueue::PrioritizedTask prioritized_dependency_task =
+        work_queue.GetNextTaskToRun(0u);
+    EXPECT_EQ(prioritized_dependency_task.task.get(), dependency_task3.get());
+    work_queue.CompleteTask(std::move(prioritized_dependency_task));
+    EXPECT_TRUE(work_queue.HasReadyToRunTasks());
+
+    prioritized_dependency_task = work_queue.GetNextTaskToRun(0u);
+    EXPECT_EQ(prioritized_dependency_task.task.get(), dependency_task2.get());
+    work_queue.CompleteTask(std::move(prioritized_dependency_task));
+    EXPECT_TRUE(work_queue.HasReadyToRunTasks());
+
+    prioritized_dependency_task = work_queue.GetNextTaskToRun(0u);
+    EXPECT_EQ(prioritized_dependency_task.task.get(), dependency_task1.get());
+    work_queue.CompleteTask(std::move(prioritized_dependency_task));
+    EXPECT_TRUE(work_queue.HasReadyToRunTasks());
+
+    // | task| runs last.
+    prioritized_dependency_task = work_queue.GetNextTaskToRun(0u);
+    EXPECT_EQ(prioritized_dependency_task.task.get(), task.get());
+    work_queue.CompleteTask(std::move(prioritized_dependency_task));
+    EXPECT_FALSE(work_queue.HasReadyToRunTasks());
+  }
+}
+
 }  // namespace
 }  // namespace cc