// clang-format on

namespace tensorflow {
namespace tfcompile {
namespace {

void zero_buffers(XlaCompiledCpuFunction* computation) {
  for (int i = 0; i < computation->num_args(); ++i) {
    memset(computation->arg_data(i), 0, computation->arg_size(i));
  }
}

// Trivial test that runs the generated function to ensure it doesn't crash.
TEST(TEST_NAME, NoCrash) {

        private Callable<T> computation;
        private Try<T> result;

        public Deferred(Callable<T> computation) {
            this.computation = computation;
        }

        @Override
        public T get() {
            return result().get();
        }

        private Try<T> result() {
            if (result == null) {

// clang-format on

namespace tensorflow {
namespace tfcompile {
namespace {

void zero_buffers(XlaCompiledCpuFunction* computation) {
  for (int i = 0; i < computation->num_args(); ++i) {
    memset(computation->arg_data(i), 0, computation->arg_size(i));
  }
}

// Trivial test that runs the generated function to ensure it doesn't crash.
TEST(TEST_NAME, NoCrash) {

/**
 * Starts and exposes the given suspending [computation] as a [Future] value.
 *
 * The [computation] executes synchronously until its first suspension point.
 */
internal
fun <T> future(context: CoroutineContext = EmptyCoroutineContext, computation: suspend () -> T): Future<T> =
    FutureContinuation<T>(context).also { k ->
        computation.startCoroutine(completion = k)
    }


private

      /*lower_to_xla_hlo=*/true, computation, metadata, device_type,
      shape_determination_fns, use_tuple_args, compilation_result,
      custom_legalization_passes, arg_shapes, arg_core_mapping,
      per_core_arg_shapes);

  if (mlir_bridge_status.ok()) {
    VLOG(1) << "Successfully compiled MLIR computation to XLA HLO using MLIR "
               "tf2xla bridge";

  Eigen::ThreadPool pool(1 /* num_threads */);
  Eigen::ThreadPoolDevice device(&pool, pool.NumThreads());

  CPP_CLASS computation;
  computation.set_thread_pool(&device);

  benchmark::Options options;
  benchmark::Stats stats;
  benchmark::Benchmark(options, [&] { computation.Run(); }, &stats);
  benchmark::DumpStatsToStdout(stats);
  return 0;
}

}  // namespace tfcompile
}  // namespace tensorflow

    }
}

kotlin {
    target.compilations.named("testFixtures") {
        associateWith(target.compilations["main"])
    }
    target.compilations.named("test") {
        associateWith(target.compilations["main"])
        associateWith(target.compilations["testFixtures"])
    }
    target.compilations.named("integTest") {
        associateWith(target.compilations["main"])

@ops.RegisterGradient("XlaClusterOutput")
def _XlaClusterOutputGrad(_, grad):
  del grad  # unused
  raise RuntimeError("Gradient computation of graph in xla.compile() is "
                     "prohibited because it can cause performance degradation."

  LOG_FIRST_N(INFO, 1) << "Compiling MLIR computation to XLA HLO using the "
                          "Combined MLIR Tf2Xla Bridge.";

  absl::StatusOr<std::string> mlir_compilation =
      internal::CompileFromMlirToXlaHlo(
          /*lower_to_xla_hlo=*/false, computation, metadata, device_type,
          shape_determination_fns, use_tuple_args, compilation_result,

   * The listener will run when the {@code Future}'s computation is {@linkplain Future#isDone()
   * complete} or, if the computation is already complete, immediately.
   *
   * <p>There is no guaranteed ordering of execution of listeners, but any listener added through
   * this method is guaranteed to be called once the computation is complete.
   *