Node* write_op = MakeWrite(root, Output(call), "write_result");
  write_op->AddAttr(kXlaHasReferenceVarsAttr, false);

  auto xla_compile = NodeWith(Op("_XlaCompile"), Attr("must_compile", false));
  auto predicated_compilation_key =
      NodeWith(Op("Switch"), Inputs(Out(0, xla_compile), Out(1, xla_compile)));
  auto xla_run =
      NodeWith(Op("_XlaRun"), Inputs(Out(1, predicated_compilation_key)));
  auto tf_call =

    //       Switch(pred=xla_compile.compilation_successful,
    //              value=xla_compile.key)
    //
    //   tf_call_outputs = cluster_N(..., ^use_tf_call)
    //   xla_run_outputs = _XlaRun(..., key=use_xla_run)
    //   outputs = Merge(tf_call_outputs, xla_run_outputs).
    ops::Switch s(root.WithOpName("predicated_compilation_key"),
                  xla_compile.key, xla_compile.compilation_successful);

  Status CompileSingleOp(const XlaCompiler::CompileOptions& options,
                         const OpKernelContext* ctx,
                         absl::Span<const XlaArgument> args,
                         XlaCompilationResult* result) override;

 private:
  XlaCompiler xla_compiler_;

  TfGraphToHloCompiler(const TfGraphToHloCompiler&) = delete;
  void operator=(const TfGraphToHloCompiler&) = delete;
};

    OP_REQUIRES_OK(ctx, args_and_variables_snapshot.status());
    const std::vector<XlaCompiler::Argument>& args =
        args_and_variables_snapshot->first;
    variables_snapshot = std::move(args_and_variables_snapshot->second);

    // Do not alias resource updates as locking variables in XlaCompile and
    // unlocking them in XlaRun may lead to deadlocks.
    Status status;
    if (use_pjrt) {

    const XlaCompiler::CompileOptions& options, const OpKernelContext* ctx,
    absl::Span<const XlaArgument> args, XlaCompilationResult* result) {
  return ADD_SOURCE_LOCATION(xla_compiler_.CompileSingleOp(
      options, XlaCompiler::SingleOpCompileArgument(*ctx), args, result));
}

  virtual absl::StatusOr<std::string> BuildSerializedExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result) = 0;

  // Loads `serialized_executable` into an `ExecutableType` using `ClientType`.
  virtual StatusOr<std::unique_ptr<ExecutableType>> LoadExecutable(
      const XlaCompiler::Options& options,
      const XlaCompiler::CompilationResult& result,
      const std::string& serialized_executable) = 0;

      XlaCompiler::Options{}, fn, args, XlaCompiler::CompileOptions{},
      DeviceCompileMode::kStrict, profiler, &compilation_result, &executable);
  EXPECT_FALSE(status.ok());
  EXPECT_TRUE(absl::StrContains(status.message(), "XLA compilation disabled"));

  // Check that async compilation is disallowed.
  status = xla_device_compiler->CompileIfNeeded(

#ifndef TENSORFLOW_COMPILER_JIT_TF_TO_HLO_COMPILER_H_
#define TENSORFLOW_COMPILER_JIT_TF_TO_HLO_COMPILER_H_

#include <memory>
#include <vector>

#include "tensorflow/compiler/tf2xla/xla_compiler.h"
#include "tensorflow/core/framework/op_kernel.h"

namespace tensorflow {

class TfToHloCompiler {
 public:
  TfToHloCompiler() = default;
  virtual ~TfToHloCompiler() = default;

 private:
  Status Compile(const std::vector<XlaCompiler::Argument>& args,
                 OpKernelContext* ctx,
                 DeviceCompiler<xla::LocalExecutable, xla::LocalClient>**
                     xla_device_compiler,
                 DeviceCompilationProfiler** profiler,
                 const XlaCompiler::CompilationResult** result,
                 xla::LocalExecutable** executable);

    const DeviceBase* device, const XlaPlatformInfo& platform_info,
    const NameAttrList& function,
    const std::vector<XlaCompiler::Argument>& args,
    DeviceCompileMode compile_mode, bool has_ref_vars,
    bool may_alias_resource_update, FunctionLibraryRuntime* flr,
    ResourceMgr* rm, const XlaCompiler::CompilationResult** compilation_result,
    xla::PjRtClient** client, xla::PjRtLoadedExecutable** executable) {