indexify 0.4.6__py3-none-any.whl → 0.4.8__py3-none-any.whl

indexify/executor/function_executor_controller/run_task.py

@@ -16,7 +16,7 @@ from indexify.executor.function_executor.function_executor import FunctionExecut
 from indexify.executor.function_executor.health_checker import HealthCheckResult
 from indexify.proto.executor_api_pb2 import (
     FunctionExecutorTerminationReason,
-    Task,
+    TaskAllocation,
     TaskFailureReason,
     TaskOutcomeCode,
 )
@@ -41,12 +41,13 @@ async def run_task_on_function_executor(
     """
     logger = logger.bind(module=__name__)
     request: RunTaskRequest = RunTaskRequest(
-        namespace=task_info.task.namespace,
-        graph_name=task_info.task.graph_name,
-        graph_version=task_info.task.graph_version,
-        function_name=task_info.task.function_name,
-        graph_invocation_id=task_info.task.graph_invocation_id,
-        task_id=task_info.task.id,
+        namespace=task_info.allocation.task.namespace,
+        graph_name=task_info.allocation.task.graph_name,
+        graph_version=task_info.allocation.task.graph_version,
+        function_name=task_info.allocation.task.function_name,
+        graph_invocation_id=task_info.allocation.task.graph_invocation_id,
+        task_id=task_info.allocation.task.id,
+        allocation_id=task_info.allocation.allocation_id,
         function_input=task_info.input,
     )
     # Don't keep the input in memory after we started running the task.
@@ -58,8 +59,8 @@ async def run_task_on_function_executor(
         task_info.init_value = None
 
     function_executor.invocation_state_client().add_task_to_invocation_id_entry(
-        task_id=task_info.task.id,
-        invocation_id=task_info.task.graph_invocation_id,
+        task_id=task_info.allocation.task.id,
+        invocation_id=task_info.allocation.task.graph_invocation_id,
     )
 
     metric_function_executor_run_task_rpcs.inc()
@@ -73,16 +74,15 @@ async def run_task_on_function_executor(
     # If this RPC failed due to customer code crashing the server we won't be
     # able to detect this. We'll treat this as our own error for now and thus
     # let the AioRpcError to be raised here.
-    timeout_sec = task_info.task.timeout_ms / 1000.0
+    timeout_sec = task_info.allocation.task.timeout_ms / 1000.0
     try:
         channel: grpc.aio.Channel = function_executor.channel()
         response: RunTaskResponse = await FunctionExecutorStub(channel).run_task(
             request, timeout=timeout_sec
         )
         task_info.output = _task_output_from_function_executor_response(
-            task=task_info.task,
+            allocation=task_info.allocation,
             response=response,
-            allocation_id=task_info.allocation_id,
         )
     except grpc.aio.AioRpcError as e:
         if e.code() == grpc.StatusCode.DEADLINE_EXCEEDED:
@@ -91,36 +91,29 @@ async def run_task_on_function_executor(
                 FunctionExecutorTerminationReason.FUNCTION_EXECUTOR_TERMINATION_REASON_FUNCTION_TIMEOUT
             )
             task_info.output = TaskOutput.function_timeout(
-                task=task_info.task,
-                allocation_id=task_info.allocation_id,
+                allocation=task_info.allocation,
                 timeout_sec=timeout_sec,
             )
         else:
             metric_function_executor_run_task_rpc_errors.inc()
             logger.error("task execution failed", exc_info=e)
-            task_info.output = TaskOutput.internal_error(
-                task=task_info.task, allocation_id=task_info.allocation_id
-            )
+            task_info.output = TaskOutput.internal_error(task_info.allocation)
     except asyncio.CancelledError:
         # The task is still running in FE, we only cancelled the client-side RPC.
         function_executor_termination_reason = (
             FunctionExecutorTerminationReason.FUNCTION_EXECUTOR_TERMINATION_REASON_FUNCTION_CANCELLED
         )
-        task_info.output = TaskOutput.task_cancelled(
-            task=task_info.task, allocation_id=task_info.allocation_id
-        )
+        task_info.output = TaskOutput.task_cancelled(task_info.allocation)
     except Exception as e:
         metric_function_executor_run_task_rpc_errors.inc()
         logger.error("task execution failed", exc_info=e)
-        task_info.output = TaskOutput.internal_error(
-            task=task_info.task, allocation_id=task_info.allocation_id
-        )
+        task_info.output = TaskOutput.internal_error(task_info.allocation)
 
     metric_function_executor_run_task_rpc_latency.observe(time.monotonic() - start_time)
     metric_function_executor_run_task_rpcs_in_progress.dec()
 
     function_executor.invocation_state_client().remove_task_to_invocation_id_entry(
-        task_id=task_info.task.id,
+        task_id=task_info.allocation.task.id,
     )
 
     if (
@@ -147,7 +140,7 @@ async def run_task_on_function_executor(
 
 
 def _task_output_from_function_executor_response(
-    task: Task, response: RunTaskResponse, allocation_id: str
+    allocation: TaskAllocation, response: RunTaskResponse
 ) -> TaskOutput:
     response_validator = MessageValidator(response)
     response_validator.required_field("stdout")
@@ -162,8 +155,7 @@ def _task_output_from_function_executor_response(
         metrics.timers = dict(response.metrics.timers)
 
     output = TaskOutput(
-        task=task,
-        allocation_id=allocation_id,
+        allocation=allocation,
         outcome_code=(
             TaskOutcomeCode.TASK_OUTCOME_CODE_SUCCESS
             if response.success

indexify/executor/function_executor_controller/task_info.py

@@ -4,7 +4,7 @@ from typing import Optional
 
 from tensorlake.function_executor.proto.function_executor_pb2 import SerializedObject
 
-from indexify.proto.executor_api_pb2 import Task
+from indexify.proto.executor_api_pb2 import TaskAllocation
 
 from .task_output import TaskOutput
 
@@ -13,8 +13,7 @@ from .task_output import TaskOutput
 class TaskInfo:
     """Object used to track a task during its full lifecycle in the FunctionExecutorController."""
 
-    task: Task
-    allocation_id: str
+    allocation: TaskAllocation
     # time.monotonic() timestamp
     start_time: float
     # time.monotonic() timestamp when the task was prepared for execution

indexify/executor/function_executor_controller/task_output.py

@@ -7,7 +7,7 @@ from tensorlake.function_executor.proto.function_executor_pb2 import (
 
 from indexify.proto.executor_api_pb2 import (
     DataPayload,
-    Task,
+    TaskAllocation,
     TaskFailureReason,
     TaskOutcomeCode,
 )
@@ -26,8 +26,7 @@ class TaskOutput:
 
     def __init__(
         self,
-        task: Task,
-        allocation_id: str,
+        allocation: TaskAllocation,
         outcome_code: TaskOutcomeCode,
         # Optional[TaskFailureReason] is not supported in python 3.9
         failure_reason: TaskFailureReason = None,
@@ -42,8 +41,8 @@ class TaskOutput:
         uploaded_stdout: Optional[DataPayload] = None,
         uploaded_stderr: Optional[DataPayload] = None,
     ):
-        self.task = task
-        self.allocation_id = allocation_id
+        self.task = allocation.task
+        self.allocation = allocation
         self.function_output = function_output
         self.router_output = router_output
         self.stdout = stdout
@@ -60,14 +59,12 @@ class TaskOutput:
     @classmethod
     def internal_error(
         cls,
-        task: Task,
-        allocation_id: str,
+        allocation: TaskAllocation,
     ) -> "TaskOutput":
         """Creates a TaskOutput for an internal error."""
         # We are not sharing internal error messages with the customer.
         return TaskOutput(
-            task=task,
-            allocation_id=allocation_id,
+            allocation=allocation,
             outcome_code=TaskOutcomeCode.TASK_OUTCOME_CODE_FAILURE,
             failure_reason=TaskFailureReason.TASK_FAILURE_REASON_INTERNAL_ERROR,
             stderr="Platform failed to execute the function.",
@@ -76,15 +73,13 @@ class TaskOutput:
     @classmethod
     def function_timeout(
         cls,
-        task: Task,
-        allocation_id: str,
+        allocation: TaskAllocation,
         timeout_sec: float,
     ) -> "TaskOutput":
         """Creates a TaskOutput for an function timeout error."""
         # Task stdout, stderr is not available.
         return TaskOutput(
-            task=task,
-            allocation_id=allocation_id,
+            allocation=allocation,
             outcome_code=TaskOutcomeCode.TASK_OUTCOME_CODE_FAILURE,
             failure_reason=TaskFailureReason.TASK_FAILURE_REASON_FUNCTION_TIMEOUT,
             stderr=f"Function exceeded its configured timeout of {timeout_sec:.3f} sec.",
@@ -93,13 +88,11 @@ class TaskOutput:
     @classmethod
     def task_cancelled(
         cls,
-        task: Task,
-        allocation_id: str,
+        allocation: TaskAllocation,
     ) -> "TaskOutput":
         """Creates a TaskOutput for the case when task didn't finish because its allocation was removed by Server."""
         return TaskOutput(
-            task=task,
-            allocation_id=allocation_id,
+            allocation=allocation,
             outcome_code=TaskOutcomeCode.TASK_OUTCOME_CODE_FAILURE,
             failure_reason=TaskFailureReason.TASK_FAILURE_REASON_TASK_CANCELLED,
         )
@@ -107,16 +100,11 @@ class TaskOutput:
     @classmethod
     def function_executor_terminated(
         cls,
-        task: Task,
-        allocation_id: str,
+        allocation: TaskAllocation,
     ) -> "TaskOutput":
         """Creates a TaskOutput for the case when task didn't run because its FE terminated."""
         return TaskOutput(
-            task=task,
-            allocation_id=allocation_id,
+            allocation=allocation,
             outcome_code=TaskOutcomeCode.TASK_OUTCOME_CODE_FAILURE,
             failure_reason=TaskFailureReason.TASK_FAILURE_REASON_FUNCTION_EXECUTOR_TERMINATED,
-            # TODO: add FE startup stdout, stderr to the task output if FE failed to startup.
-            stdout="",
-            stderr="Can't execute the function because its Function Executor terminated.",
         )

indexify/executor/function_executor_controller/upload_task_output.py

@@ -121,13 +121,13 @@ async def _upload_to_blob_store(
     output: TaskOutput, blob_store: BLOBStore, logger: Any
 ) -> None:
     if output.stdout is not None:
-        stdout_url = f"{output.task.output_payload_uri_prefix}.{output.task.id}.stdout"
+        stdout_url = f"{output.allocation.task.output_payload_uri_prefix}.{output.allocation.task.id}.stdout"
         stdout_bytes: bytes = output.stdout.encode()
         await blob_store.put(stdout_url, stdout_bytes, logger)
         output.uploaded_stdout = DataPayload(
             uri=stdout_url,
             size=len(stdout_bytes),
-            sha256_hash=_compute_hash(stdout_bytes),
+            sha256_hash=compute_hash(stdout_bytes),
             encoding=DataPayloadEncoding.DATA_PAYLOAD_ENCODING_UTF8_TEXT,
             encoding_version=0,
         )
@@ -135,13 +135,13 @@ async def _upload_to_blob_store(
         output.stdout = None
 
     if output.stderr is not None:
-        stderr_url = f"{output.task.output_payload_uri_prefix}.{output.task.id}.stderr"
+        stderr_url = f"{output.allocation.task.output_payload_uri_prefix}.{output.allocation.task.id}.stderr"
         stderr_bytes: bytes = output.stderr.encode()
         await blob_store.put(stderr_url, stderr_bytes, logger)
         output.uploaded_stderr = DataPayload(
             uri=stderr_url,
             size=len(stderr_bytes),
-            sha256_hash=_compute_hash(stderr_bytes),
+            sha256_hash=compute_hash(stderr_bytes),
             encoding=DataPayloadEncoding.DATA_PAYLOAD_ENCODING_UTF8_TEXT,
             encoding_version=0,
         )
@@ -153,7 +153,7 @@ async def _upload_to_blob_store(
         uploaded_data_payloads = []
         for func_output_item in output.function_output.outputs:
             node_output_sequence = len(uploaded_data_payloads)
-            output_url = f"{output.task.output_payload_uri_prefix}.{output.task.id}.{node_output_sequence}"
+            output_url = f"{output.allocation.task.output_payload_uri_prefix}.{output.allocation.task.id}.{node_output_sequence}"
             output_bytes: bytes = (
                 func_output_item.bytes
                 if func_output_item.HasField("bytes")
@@ -164,7 +164,7 @@ async def _upload_to_blob_store(
                 DataPayload(
                     uri=output_url,
                     size=len(output_bytes),
-                    sha256_hash=_compute_hash(output_bytes),
+                    sha256_hash=compute_hash(output_bytes),
                     encoding=_to_grpc_data_payload_encoding(output),
                     encoding_version=0,
                 )
@@ -214,7 +214,7 @@ def _to_grpc_data_payload_encoding(task_output: TaskOutput) -> DataPayloadEncodi
         return DataPayloadEncoding.DATA_PAYLOAD_ENCODING_BINARY_PICKLE
 
 
-def _compute_hash(data: bytes) -> str:
+def compute_hash(data: bytes) -> str:
     hasher = hashlib.sha256(usedforsecurity=False)
     hasher.update(data)
     return hasher.hexdigest()

indexify/executor/state_reconciler.py

@@ -21,9 +21,9 @@ from .function_executor.server.function_executor_server_factory import (
 from .function_executor_controller import (
     FunctionExecutorController,
     function_executor_logger,
-    task_logger,
+    task_allocation_logger,
     validate_function_executor_description,
-    validate_task,
+    validate_task_allocation,
 )
 from .metrics.state_reconciler import (
     metric_state_reconciliation_errors,
@@ -376,31 +376,16 @@ class ExecutorStateReconciler:
             # Nothing to do, task already exists and it's immutable.
             return
 
-        function_executor_controller.add_task(
-            task=task_allocation.task,
-            allocation_id=task_allocation.allocation_id,
-        )
+        function_executor_controller.add_task_allocation(task_allocation)
 
     def _valid_task_allocations(self, task_allocations: Iterable[TaskAllocation]):
         valid_task_allocations: List[TaskAllocation] = []
         for task_allocation in task_allocations:
             task_allocation: TaskAllocation
-            logger = self._task_allocation_logger(task_allocation)
-
-            try:
-                validate_task(task_allocation.task)
-            except ValueError as e:
-                # There's no way to report this error to Server so just log it.
-                logger.error(
-                    "received invalid TaskAllocation from Server, dropping it from desired state",
-                    exc_info=e,
-                )
-                continue
+            logger = task_allocation_logger(task_allocation, self._logger)
 
-            validator = MessageValidator(task_allocation)
             try:
-                validator.required_field("function_executor_id")
-                validator.required_field("allocation_id")
+                validate_task_allocation(task_allocation)
             except ValueError as e:
                 # There's no way to report this error to Server so just log it.
                 logger.error(
@@ -423,16 +408,3 @@ class ExecutorStateReconciler:
             valid_task_allocations.append(task_allocation)
 
         return valid_task_allocations
-
-    def _task_allocation_logger(self, task_allocation: TaskAllocation) -> Any:
-        """Returns a logger for the given TaskAllocation.
-
-        Doesn't assume that the supplied TaskAllocation is valid.
-        """
-        return task_logger(task_allocation.task, self._logger).bind(
-            function_executor_id=(
-                task_allocation.function_executor_id
-                if task_allocation.HasField("function_executor_id")
-                else None
-            )
-        )

indexify/executor/state_reporter.py

@@ -9,7 +9,9 @@ from indexify.proto.executor_api_pb2 import (
     AllowedFunction,
     ExecutorState,
     ExecutorStatus,
+    ExecutorUpdate,
     FunctionExecutorState,
+    FunctionExecutorUpdate,
     GPUModel,
     GPUResources,
 )
@@ -24,8 +26,7 @@ from indexify.proto.executor_api_pb2_grpc import ExecutorAPIStub
 
 from .channel_manager import ChannelManager
 from .function_allowlist import FunctionURI
-from .function_executor_controller.loggers import task_logger
-from .function_executor_controller.task_output import TaskOutput
+from .function_executor_controller.loggers import task_result_logger
 from .host_resources.host_resources import HostResources, HostResourcesProvider
 from .host_resources.nvidia_gpu import NVIDIA_GPU_MODEL
 from .metrics.state_reporter import (
@@ -83,7 +84,8 @@ class ExecutorStateReporter:
         self._last_server_clock: int = (
             0  # Server expects initial value to be 0 until it is set by Server.
         )
-        self._completed_task_outputs: List[TaskOutput] = []
+        self._pending_task_results: List[TaskResult] = []
+        self._pending_fe_updates: List[FunctionExecutorUpdate] = []
         self._function_executor_states: Dict[str, FunctionExecutorState] = {}
 
     def update_executor_status(self, value: ExecutorStatus) -> None:
@@ -98,7 +100,7 @@ class ExecutorStateReporter:
     ) -> None:
         self._function_executor_states[state.description.id] = state
 
-    def remove_function_executor_info(self, function_executor_id: str) -> None:
+    def remove_function_executor_state(self, function_executor_id: str) -> None:
         if function_executor_id not in self._function_executor_states:
             self._logger.warning(
                 "attempted to remove non-existing function executor state",
@@ -108,8 +110,12 @@ class ExecutorStateReporter:
 
         self._function_executor_states.pop(function_executor_id)
 
-    def add_completed_task_output(self, task_output: TaskOutput) -> None:
-        self._completed_task_outputs.append(task_output)
+    def add_completed_task_result(self, task_result: TaskResult) -> None:
+        self._pending_task_results.append(task_result)
+
+    def add_function_executor_update(self, update: FunctionExecutorUpdate) -> None:
+        """Adds a function executor update to the list of updates to be reported."""
+        self._pending_fe_updates.append(update)
 
     def schedule_state_report(self) -> None:
         """Schedules a state report to be sent to the server asap.
@@ -212,19 +218,28 @@ class ExecutorStateReporter:
         ):
             metric_state_report_rpcs.inc()
             state: ExecutorState = self._current_executor_state()
-            task_outputs: List[TaskOutput] = self._remove_completed_tasks()
-            task_results: List[TaskResult] = _to_task_result_protos(task_outputs)
+            update: ExecutorUpdate = self._remove_pending_update()
+
+            for task_result in update.task_results:
+                task_result_logger(task_result, self._logger).info(
+                    "reporting task outcome",
+                    outcome_code=TaskOutcomeCode.Name(task_result.outcome_code),
+                    failure_reason=(
+                        TaskFailureReason.Name(task_result.failure_reason)
+                        if task_result.HasField("failure_reason")
+                        else "None"
+                    ),
+                )
 
             try:
                 await stub.report_executor_state(
                     ReportExecutorStateRequest(
-                        executor_state=state, task_results=task_results
+                        executor_state=state, executor_update=update
                     ),
                     timeout=_REPORT_RPC_TIMEOUT_SEC,
                 )
             except Exception as e:
-                for task_output in task_outputs:
-                    self.add_completed_task_output(task_output)
+                self._add_to_pending_update(update)
                 raise
 
     def _current_executor_state(self) -> ExecutorState:
@@ -247,21 +262,26 @@ class ExecutorStateReporter:
         state.server_clock = self._last_server_clock
         return state
 
-    def _remove_completed_tasks(self) -> List[TaskOutput]:
-        task_outputs: List[TaskOutput] = []
-        while len(self._completed_task_outputs) > 0:
-            task_output = self._completed_task_outputs.pop()
-            task_outputs.append(task_output)
-            task_logger(task_output.task, self._logger).info(
-                "reporting task outcome",
-                outcome_code=TaskOutcomeCode.Name(task_output.outcome_code),
-                failure_reason=(
-                    "None"
-                    if task_output.failure_reason is None
-                    else TaskFailureReason.Name(task_output.failure_reason)
-                ),
-            )
-        return task_outputs
+    def _remove_pending_update(self) -> ExecutorUpdate:
+        """Removes all pending executor updates and returns them."""
+        # No races here cause we don't await.
+        task_results: List[TaskResult] = self._pending_task_results
+        self._pending_task_results = []
+
+        fe_updates: List[FunctionExecutorUpdate] = self._pending_fe_updates
+        self._pending_fe_updates = []
+
+        return ExecutorUpdate(
+            executor_id=self._executor_id,
+            task_results=task_results,
+            function_executor_updates=fe_updates,
+        )
+
+    def _add_to_pending_update(self, update: ExecutorUpdate) -> None:
+        for task_result in update.task_results:
+            self.add_completed_task_result(task_result)
+        for function_executor_update in update.function_executor_updates:
+            self.add_function_executor_update(function_executor_update)
 
 
 def _to_allowed_function_protos(
@@ -324,36 +344,6 @@ def _to_gpu_model_proto(nvidia_gpu_model: NVIDIA_GPU_MODEL) -> GPUModel:
         return GPUModel.GPU_MODEL_UNKNOWN
 
 
-def _to_task_result_protos(task_outputs: List[TaskOutput]) -> List[TaskResult]:
-    task_results: List[TaskResult] = []
-
-    for output in task_outputs:
-        task_result = TaskResult(
-            task_id=output.task.id,
-            allocation_id=output.allocation_id,
-            namespace=output.task.namespace,
-            graph_name=output.task.graph_name,
-            function_name=output.task.function_name,
-            graph_invocation_id=output.task.graph_invocation_id,
-            reducer=output.reducer,
-            outcome_code=output.outcome_code,
-            next_functions=(output.router_output.edges if output.router_output else []),
-            function_outputs=output.uploaded_data_payloads,
-        )
-        if output.failure_reason is not None:
-            task_result.failure_reason = output.failure_reason
-        if output.uploaded_stdout is not None:
-            task_result.stdout.CopyFrom(output.uploaded_stdout)
-        if output.uploaded_stderr is not None:
-            task_result.stderr.CopyFrom(output.uploaded_stderr)
-        if output.router_output is not None:
-            task_result.routing.next_functions[:] = output.router_output.edges
-
-        task_results.append(task_result)
-
-    return task_results
-
-
 def _executor_labels() -> Dict[str, str]:
     """Returns standard executor labels always added to user supplied labels."""
     return {

indexify/proto/executor_api.proto

@@ -109,6 +109,10 @@ message FunctionExecutorDescription {
     optional uint32 customer_code_timeout_ms = 9;
     optional DataPayload graph = 10;
     optional FunctionExecutorResources resources = 11;
+    // URI prefix for the startup output payloads.
+    // S3 URI if the data is stored in S3.
+    // Starts with "file://"" prefix followed by an absolute directory path if the data is stored on a local file system.
+    optional string output_payload_uri_prefix = 12;
 }
 
 message FunctionExecutorState {
@@ -117,6 +121,12 @@ message FunctionExecutorState {
     optional FunctionExecutorTerminationReason termination_reason = 3;
 }
 
+message FunctionExecutorUpdate {
+    optional FunctionExecutorDescription description = 1;
+    optional DataPayload startup_stdout = 2;
+    optional DataPayload startup_stderr = 3;
+}
+
 enum ExecutorStatus {
     EXECUTOR_STATUS_UNKNOWN = 0;
     EXECUTOR_STATUS_STARTING_UP = 1;
@@ -145,13 +155,20 @@ message ExecutorState {
     optional uint64 server_clock = 12;
 }
 
-// A message sent by Executor to report its up to date state to Server.
+// Updates that Executor wants to report to Server. If report_executor_state RPC is successful
+// then the updates from it won't be included in the next RPC.
+message ExecutorUpdate {
+    optional string executor_id = 1;
+    repeated TaskResult task_results = 2;
+    repeated FunctionExecutorUpdate function_executor_updates = 3;
+}
+
 message ReportExecutorStateRequest {
     optional ExecutorState executor_state = 1;
-    repeated TaskResult task_results = 2;
+    optional ExecutorUpdate executor_update = 2;
 }
 
-// A message sent by Server to Executor to acknowledge the receipt of Executor state.
+// A message sent by Server to Executor to acknowledge the receipt of ReportExecutorStateRequest.
 message ReportExecutorStateResponse {
 }
 
@@ -226,24 +243,24 @@ message ResultRouting {
 
 message TaskResult {
     optional string task_id = 1;
-    optional string namespace = 2;
-    optional string graph_name = 3;
-    optional string function_name = 4;
-    optional string graph_invocation_id = 5;
-    optional bool reducer = 6;
-    optional TaskOutcomeCode outcome_code = 7;
-    optional TaskFailureReason failure_reason = 8;
+    optional string allocation_id = 2;
+    optional string namespace = 3;
+    optional string graph_name = 4;
+    optional string graph_version = 5;
+    optional string function_name = 6;
+    optional string graph_invocation_id = 7;
+    optional bool reducer = 8;
+    optional TaskOutcomeCode outcome_code = 9;
+    optional TaskFailureReason failure_reason = 10;
     // Edges that the function wants the invocation to be routed to.
     // Previously called router_edges.
     // NB: An empty list indicates that the graph's route definitions should be used,
     // unless this field is overridden by the presence of the `routing` field.
-    repeated string next_functions = 9;
-    repeated DataPayload function_outputs = 10;
+    repeated string next_functions = 11;
+    repeated DataPayload function_outputs = 12;
     // Standard output and error streams of the function.
-    optional DataPayload stdout = 11;
-    optional DataPayload stderr = 12;
-
-    optional string allocation_id = 13;
+    optional DataPayload stdout = 13;
+    optional DataPayload stderr = 14;
 
     // Indicates how the results should be routed.
     // If this is present, it replaces `next_functions`.
@@ -253,7 +270,7 @@ message TaskResult {
     // graph's routing.  The long-term goal is to deprecate
     // `next_functions`, so that if `routing` is not present, the
     // graph's routing definitions will always be used.
-    ResultRouting routing = 14;
+    ResultRouting routing = 15;
 }
 
 // Internal API for scheduling and running tasks on Executors. Executors are acting as clients of this API.