Convert task_spec to flatbuffers (#255)

* convert Ray to C++

* convert task_spec to flatbuffers

* fix

* it compiles

* latest

* tests are passing

* task2 -> task

* fix

* fix

* fix

* fix

* fix

* linting

* fix valgrind

* upgrade flatbuffers

* use debug mode for valgrind

* fix naming and comments

* downgrade flatbuffers

* fix linting

* reintroduce TaskSpec_free

* rename TaskSpec -> TaskInfo

* refactoring

* linting

src/common/test/db_tests.cc

@@ -6,6 +6,7 @@
 
 #include "event_loop.h"
 #include "test_common.h"
+#include "example_task.h"
 #include "state/db.h"
 #include "state/object_table.h"
 #include "state/task_table.h"
@@ -16,6 +17,8 @@
 
 SUITE(db_tests);
 
+TaskBuilder *g_task_builder = NULL;
+
 /* Retry 10 times with an 100ms timeout. */
 const int NUM_RETRIES = 10;
 const uint64_t TIMEOUT = 50;
@@ -149,10 +152,11 @@ TEST task_table_test(void) {
       db_connect("127.0.0.1", 6379, "local_scheduler", "127.0.0.1", 0, NULL);
   db_attach(db, loop, false);
   DBClientID local_scheduler_id = globally_unique_id();
-  task_spec *spec = example_task_spec(1, 1);
-  task_table_test_task =
-      Task_alloc(spec, TASK_STATUS_SCHEDULED, local_scheduler_id);
-  free_task_spec(spec);
+  int64_t task_spec_size;
+  TaskSpec *spec = example_task_spec(1, 1, &task_spec_size);
+  task_table_test_task = Task_alloc(spec, task_spec_size, TASK_STATUS_SCHEDULED,
+                                    local_scheduler_id);
+  TaskSpec_free(spec);
   RetryInfo retry = {
       .num_retries = NUM_RETRIES,
       .timeout = TIMEOUT,
@@ -183,10 +187,13 @@ TEST task_table_all_test(void) {
   DBHandle *db =
       db_connect("127.0.0.1", 6379, "local_scheduler", "127.0.0.1", 0, NULL);
   db_attach(db, loop, false);
-  task_spec *spec = example_task_spec(1, 1);
+  int64_t task_spec_size;
+  TaskSpec *spec = example_task_spec(1, 1, &task_spec_size);
   /* Schedule two tasks on different local local schedulers. */
-  Task *task1 = Task_alloc(spec, TASK_STATUS_SCHEDULED, globally_unique_id());
-  Task *task2 = Task_alloc(spec, TASK_STATUS_SCHEDULED, globally_unique_id());
+  Task *task1 = Task_alloc(spec, task_spec_size, TASK_STATUS_SCHEDULED,
+                           globally_unique_id());
+  Task *task2 = Task_alloc(spec, task_spec_size, TASK_STATUS_SCHEDULED,
+                           globally_unique_id());
   RetryInfo retry = {
       .num_retries = NUM_RETRIES, .timeout = TIMEOUT, .fail_callback = NULL,
   };
@@ -201,7 +208,7 @@ TEST task_table_all_test(void) {
   event_loop_add_timer(loop, 200, (event_loop_timer_handler) timeout_handler,
                        NULL);
   event_loop_run(loop);
-  free_task_spec(spec);
+  TaskSpec_free(spec);
   db_disconnect(db);
   destroy_outstanding_callbacks(loop);
   event_loop_destroy(loop);
@@ -237,6 +244,7 @@ SUITE(db_tests) {
 GREATEST_MAIN_DEFS();
 
 int main(int argc, char **argv) {
+  g_task_builder = make_task_builder();
   GREATEST_MAIN_BEGIN();
   RUN_SUITE(db_tests);
   GREATEST_MAIN_END();

src/common/test/example_task.h

@@ -0,0 +1,59 @@
+#ifndef EXAMPLE_TASK_H
+#define EXAMPLE_TASK_H
+
+#include "task.h"
+
+extern TaskBuilder *g_task_builder;
+
+const int64_t arg_value_size = 1000;
+
+static inline TaskSpec *example_task_spec_with_args(int64_t num_args,
+                                                    int64_t num_returns,
+                                                    ObjectID arg_ids[],
+                                                    int64_t *task_spec_size) {
+  TaskID parent_task_id = globally_unique_id();
+  FunctionID func_id = globally_unique_id();
+  TaskSpec_start_construct(g_task_builder, NIL_ID, parent_task_id, 0,
+                           NIL_ACTOR_ID, 0, func_id, num_returns);
+  for (int64_t i = 0; i < num_args; ++i) {
+    ObjectID arg_id;
+    if (arg_ids == NULL) {
+      arg_id = globally_unique_id();
+    } else {
+      arg_id = arg_ids[i];
+    }
+    TaskSpec_args_add_ref(g_task_builder, arg_id);
+  }
+  return TaskSpec_finish_construct(g_task_builder, task_spec_size);
+}
+
+static inline TaskSpec *example_task_spec(int64_t num_args,
+                                          int64_t num_returns,
+                                          int64_t *task_spec_size) {
+  return example_task_spec_with_args(num_args, num_returns, NULL,
+                                     task_spec_size);
+}
+
+static inline Task *example_task_with_args(int64_t num_args,
+                                           int64_t num_returns,
+                                           int task_state,
+                                           ObjectID arg_ids[]) {
+  int64_t task_spec_size;
+  TaskSpec *spec = example_task_spec_with_args(num_args, num_returns, arg_ids,
+                                               &task_spec_size);
+  Task *instance = Task_alloc(spec, task_spec_size, task_state, NIL_ID);
+  TaskSpec_free(spec);
+  return instance;
+}
+
+static inline Task *example_task(int64_t num_args,
+                                 int64_t num_returns,
+                                 int task_state) {
+  int64_t task_spec_size;
+  TaskSpec *spec = example_task_spec(num_args, num_returns, &task_spec_size);
+  Task *instance = Task_alloc(spec, task_spec_size, task_state, NIL_ID);
+  TaskSpec_free(spec);
+  return instance;
+}
+
+#endif /* EXAMPLE_TASK_H */

src/common/test/object_table_tests.cc

@@ -1,6 +1,7 @@
 #include "greatest.h"
 
 #include "event_loop.h"
+#include "example_task.h"
 #include "test_common.h"
 #include "common.h"
 #include "state/object_table.h"
@@ -11,6 +12,7 @@
 SUITE(object_table_tests);
 
 static event_loop *g_loop;
+TaskBuilder *g_task_builder = NULL;
 
 /* ==== Test adding and looking up metadata ==== */
 
@@ -18,7 +20,7 @@ int new_object_failed = 0;
 int new_object_succeeded = 0;
 ObjectID new_object_id;
 Task *new_object_task;
-task_spec *new_object_task_spec;
+TaskSpec *new_object_task_spec;
 TaskID new_object_task_id;
 
 void new_object_fail_callback(UniqueID id,
@@ -68,7 +70,7 @@ TEST new_object_test(void) {
   new_object_id = globally_unique_id();
   new_object_task = example_task(1, 1, TASK_STATUS_WAITING);
   new_object_task_spec = Task_task_spec(new_object_task);
-  new_object_task_id = task_spec_id(new_object_task_spec);
+  new_object_task_id = TaskSpec_task_id(new_object_task_spec);
   g_loop = event_loop_create();
   DBHandle *db =
       db_connect("127.0.0.1", 6379, "plasma_manager", "127.0.0.1", 0, NULL);
@@ -902,6 +904,7 @@ SUITE(object_table_tests) {
 GREATEST_MAIN_DEFS();
 
 int main(int argc, char **argv) {
+  g_task_builder = make_task_builder();
   GREATEST_MAIN_BEGIN();
   RUN_SUITE(object_table_tests);
   GREATEST_MAIN_END();

src/common/test/task_table_tests.cc

@@ -1,6 +1,7 @@
 #include "greatest.h"
 
 #include "event_loop.h"
+#include "example_task.h"
 #include "test_common.h"
 #include "common.h"
 #include "state/object_table.h"
@@ -12,6 +13,7 @@
 SUITE(task_table_tests);
 
 event_loop *g_loop;
+TaskBuilder *g_task_builder = NULL;
 
 /* ==== Test operations in non-failure scenario ==== */
 
@@ -418,6 +420,7 @@ SUITE(task_table_tests) {
 GREATEST_MAIN_DEFS();
 
 int main(int argc, char **argv) {
+  g_task_builder = make_task_builder();
   GREATEST_MAIN_BEGIN();
   RUN_SUITE(task_table_tests);
   GREATEST_MAIN_END();

src/common/test/task_tests.cc

@@ -14,37 +14,39 @@ SUITE(task_tests);
 TEST task_test(void) {
   TaskID parent_task_id = globally_unique_id();
   FunctionID func_id = globally_unique_id();
-  task_spec *spec = start_construct_task_spec(
-      NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0, func_id, 4, 2, 10);
-  ASSERT(task_num_args(spec) == 4);
-  ASSERT(task_num_returns(spec) == 2);
+  TaskBuilder *builder = make_task_builder();
+  TaskSpec_start_construct(builder, NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0,
+                           func_id, 2);
 
   UniqueID arg1 = globally_unique_id();
-  ASSERT(task_args_add_ref(spec, arg1) == 0);
-  ASSERT(task_args_add_val(spec, (uint8_t *) "hello", 5) == 1);
+  TaskSpec_args_add_ref(builder, arg1);
+  TaskSpec_args_add_val(builder, (uint8_t *) "hello", 5);
   UniqueID arg2 = globally_unique_id();
-  ASSERT(task_args_add_ref(spec, arg2) == 2);
-  ASSERT(task_args_add_val(spec, (uint8_t *) "world", 5) == 3);
+  TaskSpec_args_add_ref(builder, arg2);
+  TaskSpec_args_add_val(builder, (uint8_t *) "world", 5);
   /* Finish constructing the spec. This constructs the task ID and the
    * return IDs. */
-  finish_construct_task_spec(spec);
+  int64_t size;
+  uint8_t *spec = TaskSpec_finish_construct(builder, &size);
 
   /* Check that the spec was constructed as expected. */
-  ASSERT(task_num_args(spec) == 4);
-  ASSERT(task_num_returns(spec) == 2);
-  ASSERT(FunctionID_equal(task_function(spec), func_id));
-  ASSERT(ObjectID_equal(task_arg_id(spec, 0), arg1));
-  ASSERT(memcmp(task_arg_val(spec, 1), (uint8_t *) "hello",
-                task_arg_length(spec, 1)) == 0);
-  ASSERT(ObjectID_equal(task_arg_id(spec, 2), arg2));
-  ASSERT(memcmp(task_arg_val(spec, 3), (uint8_t *) "world",
-                task_arg_length(spec, 3)) == 0);
+  ASSERT(TaskSpec_num_args(spec) == 4);
+  ASSERT(TaskSpec_num_returns(spec) == 2);
+  ASSERT(FunctionID_equal(TaskSpec_function(spec), func_id));
+  ASSERT(ObjectID_equal(TaskSpec_arg_id(spec, 0), arg1));
+  ASSERT(memcmp(TaskSpec_arg_val(spec, 1), (uint8_t *) "hello",
+                TaskSpec_arg_length(spec, 1)) == 0);
+  ASSERT(ObjectID_equal(TaskSpec_arg_id(spec, 2), arg2));
+  ASSERT(memcmp(TaskSpec_arg_val(spec, 3), (uint8_t *) "world",
+                TaskSpec_arg_length(spec, 3)) == 0);
 
-  free_task_spec(spec);
+  TaskSpec_free(spec);
+  free_task_builder(builder);
   PASS();
 }
 
 TEST deterministic_ids_test(void) {
+  TaskBuilder *builder = make_task_builder();
   /* Define the inputs to the task construction. */
   TaskID parent_task_id = globally_unique_id();
   FunctionID func_id = globally_unique_id();
@@ -52,123 +54,132 @@ TEST deterministic_ids_test(void) {
   uint8_t *arg2 = (uint8_t *) "hello world";
 
   /* Construct a first task. */
-  task_spec *spec1 = start_construct_task_spec(
-      NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0, func_id, 2, 3, 11);
-  task_args_add_ref(spec1, arg1);
-  task_args_add_val(spec1, arg2, 11);
-  finish_construct_task_spec(spec1);
+  TaskSpec_start_construct(builder, NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0,
+                           func_id, 3);
+  TaskSpec_args_add_ref(builder, arg1);
+  TaskSpec_args_add_val(builder, arg2, 11);
+  int64_t size1;
+  TaskSpec *spec1 = TaskSpec_finish_construct(builder, &size1);
 
   /* Construct a second identical task. */
-  task_spec *spec2 = start_construct_task_spec(
-      NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0, func_id, 2, 3, 11);
-  task_args_add_ref(spec2, arg1);
-  task_args_add_val(spec2, arg2, 11);
-  finish_construct_task_spec(spec2);
+  TaskSpec_start_construct(builder, NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0,
+                           func_id, 3);
+  TaskSpec_args_add_ref(builder, arg1);
+  TaskSpec_args_add_val(builder, arg2, 11);
+  int64_t size2;
+  TaskSpec *spec2 = TaskSpec_finish_construct(builder, &size2);
 
-  /* Check that these tasks have the same task IDs and the same return IDs.*/
-  ASSERT(TaskID_equal(task_spec_id(spec1), task_spec_id(spec2)));
-  ASSERT(ObjectID_equal(task_return(spec1, 0), task_return(spec2, 0)));
-  ASSERT(ObjectID_equal(task_return(spec1, 1), task_return(spec2, 1)));
-  ASSERT(ObjectID_equal(task_return(spec1, 2), task_return(spec2, 2)));
+  /* Check that these tasks have the same task IDs and the same return IDs. */
+  ASSERT(TaskID_equal(TaskSpec_task_id(spec1), TaskSpec_task_id(spec2)));
+  ASSERT(ObjectID_equal(TaskSpec_return(spec1, 0), TaskSpec_return(spec2, 0)));
+  ASSERT(ObjectID_equal(TaskSpec_return(spec1, 1), TaskSpec_return(spec2, 1)));
+  ASSERT(ObjectID_equal(TaskSpec_return(spec1, 2), TaskSpec_return(spec2, 2)));
   /* Check that the return IDs are all distinct. */
-  ASSERT(!ObjectID_equal(task_return(spec1, 0), task_return(spec2, 1)));
-  ASSERT(!ObjectID_equal(task_return(spec1, 0), task_return(spec2, 2)));
-  ASSERT(!ObjectID_equal(task_return(spec1, 1), task_return(spec2, 2)));
+  ASSERT(!ObjectID_equal(TaskSpec_return(spec1, 0), TaskSpec_return(spec2, 1)));
+  ASSERT(!ObjectID_equal(TaskSpec_return(spec1, 0), TaskSpec_return(spec2, 2)));
+  ASSERT(!ObjectID_equal(TaskSpec_return(spec1, 1), TaskSpec_return(spec2, 2)));
 
   /* Create more tasks that are only mildly different. */
 
   /* Construct a task with a different parent task ID. */
-  task_spec *spec3 = start_construct_task_spec(
-      NIL_ID, globally_unique_id(), 0, NIL_ACTOR_ID, 0, func_id, 2, 3, 11);
-  task_args_add_ref(spec3, arg1);
-  task_args_add_val(spec3, arg2, 11);
-  finish_construct_task_spec(spec3);
+  TaskSpec_start_construct(builder, NIL_ID, globally_unique_id(), 0,
+                           NIL_ACTOR_ID, 0, func_id, 3);
+  TaskSpec_args_add_ref(builder, arg1);
+  TaskSpec_args_add_val(builder, arg2, 11);
+  int64_t size3;
+  TaskSpec *spec3 = TaskSpec_finish_construct(builder, &size3);
 
   /* Construct a task with a different parent counter. */
-  task_spec *spec4 = start_construct_task_spec(
-      NIL_ID, parent_task_id, 1, NIL_ACTOR_ID, 0, func_id, 2, 3, 11);
-  task_args_add_ref(spec4, arg1);
-  task_args_add_val(spec4, arg2, 11);
-  finish_construct_task_spec(spec4);
+  TaskSpec_start_construct(builder, NIL_ID, parent_task_id, 1, NIL_ACTOR_ID, 0,
+                           func_id, 3);
+  TaskSpec_args_add_ref(builder, arg1);
+  TaskSpec_args_add_val(builder, arg2, 11);
+  int64_t size4;
+  TaskSpec *spec4 = TaskSpec_finish_construct(builder, &size4);
 
   /* Construct a task with a different function ID. */
-  task_spec *spec5 =
-      start_construct_task_spec(NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0,
-                                globally_unique_id(), 2, 3, 11);
-  task_args_add_ref(spec5, arg1);
-  task_args_add_val(spec5, arg2, 11);
-  finish_construct_task_spec(spec5);
+  TaskSpec_start_construct(builder, NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0,
+                           globally_unique_id(), 3);
+  TaskSpec_args_add_ref(builder, arg1);
+  TaskSpec_args_add_val(builder, arg2, 11);
+  int64_t size5;
+  TaskSpec *spec5 = TaskSpec_finish_construct(builder, &size5);
 
   /* Construct a task with a different object ID argument. */
-  task_spec *spec6 = start_construct_task_spec(
-      NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0, func_id, 2, 3, 11);
-  task_args_add_ref(spec6, globally_unique_id());
-  task_args_add_val(spec6, arg2, 11);
-  finish_construct_task_spec(spec6);
+  TaskSpec_start_construct(builder, NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0,
+                           func_id, 3);
+  TaskSpec_args_add_ref(builder, globally_unique_id());
+  TaskSpec_args_add_val(builder, arg2, 11);
+  int64_t size6;
+  TaskSpec *spec6 = TaskSpec_finish_construct(builder, &size6);
 
   /* Construct a task with a different value argument. */
-  task_spec *spec7 = start_construct_task_spec(
-      NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0, func_id, 2, 3, 11);
-  task_args_add_ref(spec7, arg1);
-  task_args_add_val(spec7, (uint8_t *) "hello_world", 11);
-  finish_construct_task_spec(spec7);
+  TaskSpec_start_construct(builder, NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0,
+                           func_id, 3);
+  TaskSpec_args_add_ref(builder, arg1);
+  TaskSpec_args_add_val(builder, (uint8_t *) "hello_world", 11);
+  int64_t size7;
+  TaskSpec *spec7 = TaskSpec_finish_construct(builder, &size7);
 
   /* Check that the task IDs are all distinct from the original. */
-  ASSERT(!TaskID_equal(task_spec_id(spec1), task_spec_id(spec3)));
-  ASSERT(!TaskID_equal(task_spec_id(spec1), task_spec_id(spec4)));
-  ASSERT(!TaskID_equal(task_spec_id(spec1), task_spec_id(spec5)));
-  ASSERT(!TaskID_equal(task_spec_id(spec1), task_spec_id(spec6)));
-  ASSERT(!TaskID_equal(task_spec_id(spec1), task_spec_id(spec7)));
+  ASSERT(!TaskID_equal(TaskSpec_task_id(spec1), TaskSpec_task_id(spec3)));
+  ASSERT(!TaskID_equal(TaskSpec_task_id(spec1), TaskSpec_task_id(spec4)));
+  ASSERT(!TaskID_equal(TaskSpec_task_id(spec1), TaskSpec_task_id(spec5)));
+  ASSERT(!TaskID_equal(TaskSpec_task_id(spec1), TaskSpec_task_id(spec6)));
+  ASSERT(!TaskID_equal(TaskSpec_task_id(spec1), TaskSpec_task_id(spec7)));
 
   /* Check that the return object IDs are distinct from the originals. */
-  task_spec *specs[6] = {spec1, spec3, spec4, spec5, spec6, spec7};
+  TaskSpec *specs[6] = {spec1, spec3, spec4, spec5, spec6, spec7};
   for (int task_index1 = 0; task_index1 < 6; ++task_index1) {
     for (int return_index1 = 0; return_index1 < 3; ++return_index1) {
       for (int task_index2 = 0; task_index2 < 6; ++task_index2) {
         for (int return_index2 = 0; return_index2 < 3; ++return_index2) {
           if (task_index1 != task_index2 && return_index1 != return_index2) {
             ASSERT(!ObjectID_equal(
-                task_return(specs[task_index1], return_index1),
-                task_return(specs[task_index2], return_index2)));
+                TaskSpec_return(specs[task_index1], return_index1),
+                TaskSpec_return(specs[task_index2], return_index2)));
           }
         }
       }
     }
   }
 
-  free_task_spec(spec1);
-  free_task_spec(spec2);
-  free_task_spec(spec3);
-  free_task_spec(spec4);
-  free_task_spec(spec5);
-  free_task_spec(spec6);
-  free_task_spec(spec7);
+  TaskSpec_free(spec1);
+  TaskSpec_free(spec2);
+  TaskSpec_free(spec3);
+  TaskSpec_free(spec4);
+  TaskSpec_free(spec5);
+  TaskSpec_free(spec6);
+  TaskSpec_free(spec7);
+  free_task_builder(builder);
   PASS();
 }
 
 TEST send_task(void) {
+  TaskBuilder *builder = make_task_builder();
   TaskID parent_task_id = globally_unique_id();
   FunctionID func_id = globally_unique_id();
-  task_spec *spec = start_construct_task_spec(
-      NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0, func_id, 4, 2, 10);
-  task_args_add_ref(spec, globally_unique_id());
-  task_args_add_val(spec, (uint8_t *) "Hello", 5);
-  task_args_add_val(spec, (uint8_t *) "World", 5);
-  task_args_add_ref(spec, globally_unique_id());
-  finish_construct_task_spec(spec);
+  TaskSpec_start_construct(builder, NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0,
+                           func_id, 2);
+  TaskSpec_args_add_ref(builder, globally_unique_id());
+  TaskSpec_args_add_val(builder, (uint8_t *) "Hello", 5);
+  TaskSpec_args_add_val(builder, (uint8_t *) "World", 5);
+  TaskSpec_args_add_ref(builder, globally_unique_id());
+  int64_t size;
+  TaskSpec *spec = TaskSpec_finish_construct(builder, &size);
   int fd[2];
   socketpair(AF_UNIX, SOCK_STREAM, 0, fd);
-  write_message(fd[0], SUBMIT_TASK, task_spec_size(spec), (uint8_t *) spec);
+  write_message(fd[0], SUBMIT_TASK, size, (uint8_t *) spec);
   int64_t type;
   int64_t length;
   uint8_t *message;
   read_message(fd[1], &type, &length, &message);
-  task_spec *result = (task_spec *) message;
+  TaskSpec *result = (TaskSpec *) message;
   ASSERT(type == SUBMIT_TASK);
-  ASSERT(memcmp(spec, result, task_spec_size(spec)) == 0);
-  ASSERT(memcmp(spec, result, task_spec_size(result)) == 0);
-  free(spec);
+  ASSERT(memcmp(spec, result, size) == 0);
+  TaskSpec_free(spec);
   free(result);
+  free_task_builder(builder);
   PASS();
 }
 

src/common/test/test_common.h

@@ -3,64 +3,16 @@
 
 #include <unistd.h>
 
+#include "common.h"
 #include "io.h"
 #include "hiredis/hiredis.h"
 #include "utstring.h"
 
-#include "task.h"
-
 #ifndef _WIN32
 /* This function is actually not declared in standard POSIX, so declare it. */
 extern int usleep(useconds_t usec);
 #endif
 
-const int64_t arg_value_size = 1000;
-
-static inline task_spec *example_task_spec_with_args(int64_t num_args,
-                                                     int64_t num_returns,
-                                                     ObjectID arg_ids[]) {
-  TaskID parent_task_id = globally_unique_id();
-  FunctionID func_id = globally_unique_id();
-  task_spec *task =
-      start_construct_task_spec(NIL_ID, parent_task_id, 0, NIL_ACTOR_ID, 0,
-                                func_id, num_args, num_returns, arg_value_size);
-  for (int64_t i = 0; i < num_args; ++i) {
-    ObjectID arg_id;
-    if (arg_ids == NULL) {
-      arg_id = globally_unique_id();
-    } else {
-      arg_id = arg_ids[i];
-    }
-    task_args_add_ref(task, arg_id);
-  }
-  finish_construct_task_spec(task);
-  return task;
-}
-
-static inline task_spec *example_task_spec(int64_t num_args,
-                                           int64_t num_returns) {
-  return example_task_spec_with_args(num_args, num_returns, NULL);
-}
-
-static inline Task *example_task_with_args(int64_t num_args,
-                                           int64_t num_returns,
-                                           int Task_state,
-                                           ObjectID arg_ids[]) {
-  task_spec *spec = example_task_spec_with_args(num_args, num_returns, arg_ids);
-  Task *instance = Task_alloc(spec, Task_state, NIL_ID);
-  free_task_spec(spec);
-  return instance;
-}
-
-static inline Task *example_task(int64_t num_args,
-                                 int64_t num_returns,
-                                 int Task_state) {
-  task_spec *spec = example_task_spec(num_args, num_returns);
-  Task *instance = Task_alloc(spec, Task_state, NIL_ID);
-  free_task_spec(spec);
-  return instance;
-}
-
 /* I/O helper methods to retry binding to sockets. */
 static inline UT_string *bind_ipc_sock_retry(const char *socket_name_format,
                                              int *fd) {