A simple interpreted reference executor.

Inherits From: Context

This executor is to be used by default in unit tests and simple applications such as colab notebooks and turorials. It is intended to serve as the gold standard of correctness for all other executors to compare against. As such, it is designed for simplicity and ease of reasoning about correctness, rather than for high performance. We will tolerate copying values, marshaling and unmarshaling when crossing TF graph boundary, etc., for the sake of keeping the logic minimal. The executor can be reused across multiple calls, so any state associated with individual executions is maintained separately from this class. High-performance simulations on large data sets will require a separate executor optimized for performance. This executor is plugged in as the handler of computation invocations at the top level of the context stack.



View source

Ingests value 'val' given the expected type type_spec.

This function is invoked on Python call arguments and/or their constituents to translate them into a form that can be used in the given context. This is performed in the process of handling a computation's __call__(), while bundling arguments together, and prior to calling invoke().

val An object that represents the value to ingest in the given context.
type_spec The tff.Type of the value represented by this object.

The result of ingestion, which is context-dependent.


View source

Invokes computation comp with argument arg.

Prior to calling invoke, the argument arg or its constituents must have been ingested by the context by calling ingest.

comp The computation being invoked. The Python type of comp expected here (e.g., pb.Computation. ComputationImpl, or other) may depend on the context. It is the responsibility of the concrete implementation of this interface to verify that the type of comp matches what the context is expecting.
arg The optional argument of the call (possibly an argument tuple with a nested structure), or None if no argument was supplied. Computations accept arguments in a variety of forms, but those are first ingested by calling ingest() above, then bundled together into a single object before calling invoke() in the given context.

The result of invocation, which is context-dependent.