public T completeAndGet() {
                return successfulResult;
            }
        };
    }

    /**
     * An invocation with no pre-computed result, requiring to do the expensive computation on {@link #completeAndGet()}.
     */
    static <T> Deferrable<T> deferred(Supplier<T> result) {
        return new Deferrable<T>() {
            private volatile T value;

            @Override

}

tensorflow::XlaCompilationResult CreateXlaComputationResult(
    const char* hlo_name) {
  auto result = tensorflow::XlaCompilationResult();
  xla::HloModuleProto hlo;
  hlo.set_name(hlo_name);
  result.computation = std::make_shared<xla::XlaComputation>(hlo);
  return result;
}

TEST(TestUtil, ComputationContainsOk) {
  constexpr char arbitrary_hlo[] = "arbitrary_hlo";
  auto result = CreateXlaComputationResult(arbitrary_hlo);

// TFL op interface for sparse operands.

def TFL_SparseOp : OpInterface<"SparseOpInterface"> {
  let description = [{
    Interface for ops that support sparse computation.
  }];

  let methods = [
    InterfaceMethod<
      [{Returns the indices of sparse operands.}],
      "std::vector<int>", "GetSparseOperands", (ins)
    >,
    InterfaceMethod<

   * expected</i>, but not absolutely required, to have the following properties:
   *
   * <ul>
   *   <li>Its execution does not cause any observable side effects.
   *   <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal
   *       Objects.equal}{@code (a, b)} implies that {@code Objects.equal(function.apply(a),
   *       function.apply(b))}.
   * </ul>
   *

	"84594350493221918389213352992032324280367711247940675652888030554255915464401",
	"82793403787388584738507275144194252681",

	// Arnault, "Rabin-Miller Primality Test: Composite Numbers Which Pass It",
	// Mathematics of Computation, 64(209) (January 1995), pp. 335-361.
	"1195068768795265792518361315725116351898245581", // strong pseudoprime to prime bases 2 through 29
	// strong pseudoprime to all prime bases up to 200
	`

import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.util.Arrays;

/**
 * Skeleton implementation of {@link HashFunction}, appropriate for non-streaming algorithms. All
 * the hash computation done using {@linkplain #newHasher()} are delegated to the {@linkplain
 * #hashBytes(byte[], int, int)} method.
 *
 * @author Dimitris Andreou
 */
@Immutable
@ElementTypesAreNonnullByDefault

  // stream are executed on the device. Operations include data
  // copying back and forth between CPU and the device, and
  // computations enqueued by XLA.
  std::shared_ptr<se::Stream> stream_ TF_GUARDED_BY(mu_);
  // If false, only stream_ is valid and all computation and transfers use
  // stream_. If true, computation is performed by stream_ and transfers are
  // performed by host_to_device/device_to_device stream or borrowing a stream

title: TensorFlow, Large-scale machine learning on heterogeneous systems

// In both cases, a SignatureDef is serialized as a SignatureDef protobuf:
// https://github.com/tensorflow/tensorflow/blob/8ce0600f58ed84a8c84a7bbdb014d1f09e44f4c8/tensorflow/core/protobuf/meta_graph.proto#L260-L330
// and represents a computation defined by a TF subgraph.
// These Signatures were primarily designed to be interoperable with the legacy
// TF 1 Session-based C++ SavedModelBundle loading APIs:

   * required, to have the following properties:
   *
   * <ul>
   *   <li>Its execution does not cause any observable side effects.
   *   <li>The computation is <i>consistent with equals</i>; that is, {@link Objects#equal
   *       Objects.equal}{@code (a, b)} implies that {@code predicate.apply(a) ==
   *       predicate.apply(b))}.
   * </ul>
   *