Convert actor dummy objects to task execution edges. (#1281)

* Define execution dependencies flatbuffer and add to Redis commands

* Convert TaskSpec to TaskExecutionSpec

* Add execution dependencies to Python bindings

* Submitting actor tasks uses execution dependency API instead of dummy argument

* Fix dependency getters and some cleanup for fetching missing dependencies

* C++ convention

* Make TaskExecutionSpec a C++ class

* Convert local scheduler to use TaskExecutionSpec class

* Convert some pointers to references

* Finish conversion to TaskExecutionSpec class

* fix

* Fix

* Fix memory errors?

* Cast flatbuffers GetSize to size_t

* Fixes

* add more retries in global scheduler unit test

* fix linting and cast fbb.GetSize to size_t

* Style and doc

* Fix linting and simplify from_flatbuf.

src/common/task.h

@@ -13,6 +13,73 @@
 
 typedef uint8_t TaskSpec;
 
+class TaskExecutionSpec {
+ public:
+  TaskExecutionSpec(const std::vector<ObjectID> &execution_dependencies,
+                    TaskSpec *spec,
+                    int64_t task_spec_size);
+  TaskExecutionSpec(TaskExecutionSpec *execution_spec);
+
+  /// Get the task's execution dependencies.
+  ///
+  /// @return A vector of object IDs representing this task's execution
+  ///         dependencies.
+  std::vector<ObjectID> ExecutionDependencies();
+
+  /// Get the task spec size.
+  ///
+  /// @return The size of the immutable task spec.
+  int64_t SpecSize();
+
+  /// Get the task spec.
+  ///
+  /// @return A pointer to the immutable task spec.
+  TaskSpec *Spec();
+
+  /// Get the number of dependencies. This comprises the immutable task
+  /// arguments and the mutable execution dependencies.
+  ///
+  /// @return The number of dependencies.
+  int64_t NumDependencies();
+
+  /// Get the number of object IDs at the given dependency index.
+  ///
+  /// @param dependency_index The dependency index whose object IDs to count.
+  /// @return The number of object IDs at the given dependency_index.
+  int DependencyIdCount(int64_t dependency_index);
+
+  /// Get the object ID of a given dependency index.
+  ///
+  /// @param dependency_index The index at which we should look up the object
+  ///        ID.
+  /// @param id_index The index of the object ID.
+  ObjectID DependencyId(int64_t dependency_index, int64_t id_index);
+
+  /// Compute whether the task is dependent on an object ID.
+  ///
+  /// @param object_id The object ID that the task may be dependent on.
+  /// @return bool This returns true if the task is dependent on the given
+  ///         object ID and false otherwise.
+  bool DependsOn(ObjectID object_id);
+
+  /// Returns whether the given dependency index is a static dependency (an
+  /// argument of the immutable task).
+  ///
+  /// @param dependency_index The requested dependency index.
+  /// @return bool This returns true if the requested dependency index is
+  ///         immutable (an argument of the task).
+  bool IsStaticDependency(int64_t dependency_index);
+
+ private:
+  /** A list of object IDs representing this task's dependencies at execution
+   *  time. */
+  std::vector<ObjectID> execution_dependencies_;
+  /** The size of the task specification for this task. */
+  int64_t task_spec_size_;
+  /** The task specification for this task. */
+  std::unique_ptr<TaskSpec[]> spec_;
+};
+
 class TaskBuilder;
 
 #define NIL_TASK_ID NIL_ID
@@ -346,16 +413,6 @@ double TaskSpec_get_required_resource(const TaskSpec *spec,
 const std::unordered_map<std::string, double> TaskSpec_get_required_resources(
     const TaskSpec *spec);
 
-/**
- * Compute whether the task is dependent on an object ID.
- *
- * @param spec Task specification.
- * @param object_id The object ID that the task may be dependent on.
- * @return bool This returns true if the task is dependent on the given object
- *         ID and false otherwise.
- */
-bool TaskSpec_is_dependent_on(TaskSpec *spec, ObjectID object_id);
-
 /**
  * Compute the object id associated to a put call.
  *
@@ -426,10 +483,8 @@ struct Task {
   int state;
   /** The ID of the local scheduler involved. */
   DBClientID local_scheduler_id;
-  /** The size of the task specification for this task. */
-  int64_t task_spec_size;
-  /** The task specification for this task. */
-  TaskSpec spec;
+  /** The execution specification for this task. */
+  std::unique_ptr<TaskExecutionSpec> execution_spec;
 };
 
 /**
@@ -442,6 +497,11 @@ struct Task {
  */
 Task *Task_alloc(TaskSpec *spec,
                  int64_t task_spec_size,
+                 int state,
+                 DBClientID local_scheduler_id,
+                 const std::vector<ObjectID> &execution_dependencies);
+
+Task *Task_alloc(TaskExecutionSpec &execution_spec,
                  int state,
                  DBClientID local_scheduler_id);
 
@@ -468,10 +528,7 @@ DBClientID Task_local_scheduler(Task *task);
 /** Set the local scheduler ID for this task. */
 void Task_set_local_scheduler(Task *task, DBClientID local_scheduler_id);
 
-/** Task specification of this task. */
-TaskSpec *Task_task_spec(Task *task);
-
-int64_t Task_task_spec_size(Task *task);
+TaskExecutionSpec *Task_task_execution_spec(Task *task);
 
 /** Task ID of this task. */
 TaskID Task_task_id(Task *task);