}
        }
      }
      op {
        name: "RestoreV2"
        input_arg {
          name: "prefix"
          type: DT_STRING
        }
        input_arg {
          name: "tensor_names"
          type: DT_STRING
        }
        input_arg {
          name: "shape_and_slices"
          type: DT_STRING
        }
        output_arg {
          name: "tensors"

  }];
}

def TF_SaveOp : TF_Op<"Save", []> {
  let summary = "Saves the input tensors to disk.";

  let description = [{
The size of `tensor_names` must match the number of tensors in `data`. `data[i]`
is written to `filename` with name `tensor_names[i]`.

See also `SaveSlices`.
  }];

  let arguments = (ins

  }
}

AssetFileDef CreateAssetFileDef(const StringRef filename,
                                const StringRef tensor_name) {
  AssetFileDef asset_file_def{};
  asset_file_def.set_filename(MaybeStripAssetDirectoryPrefix(filename).str());

  tensorflow::TensorInfo tensor_info{};
  tensor_info.set_name(tensor_name.str());
  *asset_file_def.mutable_tensor_info() = tensor_info;

  return asset_file_def;
}

                             bool sync_dst_compute) const override;
  void CopyDeviceTensorToCPU(const Tensor* device_tensor,
                             absl::string_view tensor_name, Device* device,
                             Tensor* cpu_tensor, StatusCallback done) override;
  void CopyTensorInSameDevice(const Tensor* input_tensor, Device* device,
                              Tensor* output_tensor,

  }

  // Runs and compares the outputs of `tensor_name` on both the
  // `unfrozen_session` and the `frozen_graph_def.
  void RunAndCompareFrozenAndUnfrozenGraphs(Session* unfrozen_session,
                                            const GraphDef& frozen_graph_def,
                                            const string& tensor_name) {
    std::vector<Tensor> unfrozen_outputs;

#include "tensorflow/compiler/tf2xla/shape_util.h"
#include "tensorflow/compiler/tf2xla/type_util.h"

namespace tensorflow {

void XlaHostRecvDeviceContext::CopyDeviceTensorToCPU(
    const Tensor* device_tensor, StringPiece tensor_name, Device* device,
    Tensor* cpu_tensor, StatusCallback done) {
  DataType dtype = EncodePrimitiveTypeAsDataType(shape_.element_type()).value();
  TensorShape tensor_shape;

                             const std::string& recv_device,
                             const std::string& tensor_name) {
  return absl::StrCat(send_device, ";", send_device_incarnation, ";",
                      recv_device, ";", tensor_name);
}
}  // namespace

std::optional<std::string> _HostRecvOp::GetResourceInstanceStr() {

                             bool sync_dst_compute) const override;

  void CopyDeviceTensorToCPU(const Tensor* device_tensor,
                             StringPiece tensor_name, Device* device,
                             Tensor* cpu_tensor, StatusCallback done) override {
    done(errors::Internal("host->device copy not implemented."));
  }

                             bool sync_dst_compute) const override;
  void CopyDeviceTensorToCPU(const Tensor* device_tensor,
                             absl::string_view tensor_name, Device* device,
                             Tensor* cpu_tensor, StatusCallback done) override;
  void CopyTensorInSameDevice(const Tensor* input_tensor, Device* device,
                              Tensor* output_tensor,

  }

  // Copies `device_memory_base_` with `shape_` into `cpu_tensor`.
  // `device_tensor` is unused.
  void CopyDeviceTensorToCPU(const Tensor* device_tensor,
                             StringPiece tensor_name, Device* device,
                             Tensor* cpu_tensor, StatusCallback done) override;

  void CopyTensorInSameDevice(const Tensor* input_tensor, Device* device,
                              Tensor* output_tensor,