TaskGraphRunner Group support

cc/raster/task_graph_runner.h

 // Copyright 2014 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.
 
 #ifndef CC_RASTER_TASK_GRAPH_RUNNER_H_
 #define CC_RASTER_TASK_GRAPH_RUNNER_H_
 
 #include <algorithm>
 #include <map>
 #include <vector>
@@ skipping 28 matching lines @@
 
   Task();
   virtual ~Task();
 
   bool will_run_;
   bool did_run_;
 };
 
 // A task dependency graph describes the order in which to execute a set
 // of tasks. Dependencies are represented as edges. Each node is assigned
-// a priority and a run count that matches the number of dependencies.
-// Priority range from 0 (most favorable scheduling) to UINT_MAX
-// (least favorable).
+// a group, a priority and a run count that matches the number of dependencies.

[reveman, 2015/12/04 02:30:53]

how do you feel about "category" instead of "group"? "group" is OK but my
initial thought was that this implies some form of atomic execution guarantees.
e.g. all or none of the tasks in a group will execute.

[ericrk, 2015/12/04 19:14:30]

hmm, either seems fine to me, I'll switch to category.

+// Priority range from 0 (most favorable scheduling) to UINT16_MAX
+// (least favorable). Groups range from 0 to UINT16_MAX. It is up to the
+// implementation and its consumer to determine the meaning (if any) of a group.

[reveman, 2015/12/04 02:30:53]

Can we make it clear here that group and priority might be linked? E.g. a
TaskGraphRunner implementation may prioritize all tasks in one group
(independent of |priority|) over tasks in another group.

[ericrk, 2015/12/04 19:14:30]

Done.

 struct CC_EXPORT TaskGraph {
   struct Node {
     typedef std::vector<Node> Vector;

[reveman, 2015/12/04 02:30:53]

Btw, I'd like to remove all these Vector typedefs and just use std::vector
directly. These kind of typedef was always a bad idea. No need to do that as
part of this patch though, just fyi.

[ericrk, 2015/12/04 19:14:30]

will clean these up in a follow-up

 
-    Node(Task* task, size_t priority, size_t dependencies)
-        : task(task), priority(priority), dependencies(dependencies) {}
+    Node(Task* task, uint16_t group, uint16_t priority, size_t dependencies)
+        : task(task),
+          group(group),
+          priority(priority),
+          dependencies(dependencies) {}
 
     Task* task;
-    size_t priority;
+    uint16_t group;
+    uint16_t priority;
     size_t dependencies;

[reveman, 2015/12/04 02:30:53]

How about we also change |dependencies| to uint32_t? as that makes a Node two
words in size on 64bit and three on 32bit platforms

[ericrk, 2015/12/04 19:14:30]

yup - that's definitely better.

   };
 
   struct Edge {
     typedef std::vector<Edge> Vector;
 
     Edge(const Task* task, Task* dependent)
         : task(task), dependent(dependent) {}
 
     const Task* task;
     Task* dependent;
@@ skipping 131 matching lines @@
  private:
   TaskGraph* graph_;
   const Task* task_;
   size_t current_index_;
   TaskGraph::Node* current_node_;
 };
 
 }  // namespace cc
 
 #endif  // CC_RASTER_TASK_GRAPH_RUNNER_H_