ray/src/common/format/common.fbs

// Indices into resource vectors.
// A resource vector maps a resource index to the number
// of units of that resource required.

// The total length of the resource vector is ResourceIndex_MAX.
enum ResourceIndex:int {
  // A central processing unit.
  CPU = 0,
  // A graphics processing unit.
  GPU = 1,
  // A dummy entry to make ResourceIndex_MAX equal to the length of
  // a resource vector.
  DUMMY = 2
}

table Arg {
  // Object ID for pass-by-reference arguments.
  object_id: string;
  // Data for pass-by-value arguments.
  data: string;
}

table TaskInfo {
  // ID of the driver that created this task.
  driver_id: string;
  // Task ID of the task.
  task_id: string;
  // Task ID of the parent task.
  parent_task_id: string;
  // A count of the number of tasks submitted by the parent task before this one.
  parent_counter: int;
  // Actor ID of the task. This is the actor that this task is executed on
  // or NIL_ACTOR_ID if the task is just a normal task.
  actor_id: string;
  // Number of tasks that have been submitted to this actor so far.
  actor_counter: int;
  // Function ID of the task.
  function_id: string;
  // Task arguments.
  args: [Arg];
  // Object IDs of return values.
  returns: [string];
  // The required_resources vector indicates the quantities of the different
  // resources required by this task. The index in this vector corresponds to
  // the resource type defined in the ResourceIndex enum. For example,
  // required_resources[0] is the number of CPUs required, and
  // required_resources[1] is the number of GPUs required.
  required_resources: [double];
}

// Object information data structure.
table ObjectInfo {
  // Object ID of this object.
  object_id: string;
  // Number of bytes the content of this object occupies in memory.
  data_size: long;
  // Number of bytes the metadata of this object occupies in memory.
  metadata_size: long;
  // Unix epoch of when this object was created.
  create_time: long;
  // How long creation of this object took.
  construct_duration: long;
  // Hash of the object content.
  digest: string;
  // Specifies if this object was deleted or added.
  is_deletion: bool;
}

root_type TaskInfo;

table SubscribeToNotificationsReply {
  // The object ID of the object that the notification is about.
  object_id: string;
  // The size of the object.
  object_size: long;
  // The IDs of the managers that contain this object.
  manager_ids: [string];
}

root_type SubscribeToNotificationsReply;

table TaskReply {
  // The task ID of the task that the message is about.
  task_id: string;
  // The state of the task. This is encoded as a bit mask of scheduling_state
  // enum values in task.h.
  state: long;
  // A local scheduler ID.
  local_scheduler_id: string;
  // A string of bytes representing the task specification.
  task_spec: string;
  // A boolean representing whether the update was successful. This field
  // should only be used for test-and-set operations.
  updated: bool;
}

root_type TaskReply;

table SubscribeToDBClientTableReply {
  // The db client ID of the client that the message is about.
  db_client_id: string;
  // The type of the client.
  client_type: string;
  // If the client is a local scheduler, this is the address of the plasma
  // manager that the local scheduler is connected to. Otherwise, it is empty.
  aux_address: string;
  // True if the message is about the addition of a client and false if it is
  // about the deletion of a client.
  is_insertion: bool;
}

root_type SubscribeToDBClientTableReply;

table LocalSchedulerInfoMessage {
  // The db client ID of the client that the message is about.
  db_client_id: string;
  // The total number of workers that are connected to this local scheduler.
  total_num_workers: long;
  // The number of tasks queued in this local scheduler.
  task_queue_length: long;
  // The number of workers that are available and waiting for tasks.
  available_workers: long;
  // The resource vector of resources generally available to this local
  // scheduler.
  static_resources: [double];
  // The resource vector of resources currently available to this local
  // scheduler.
  dynamic_resources: [double];
}

root_type LocalSchedulerInfoMessage;

table ResultTableReply {
  // The task ID of the task that created the object.
  task_id: string;
  // Whether the task created the object through a ray.put.
  is_put: bool;
}

root_type ResultTableReply;