let summary = "Loads a restored variable tensor as a tensor future";

  let description = [{
    This op loads a restored variable tensor as a tensor future. It is a
    replacement of `tf.ReadVariableOp`.

    This op returns a scalar string tensor containing the restored variable name, which 
    is composed from `container_name` and `shared_name` from a `var_handle` and can be

def PromiseOp: TensorflowMlrt_Op<"promise", []> {
  let summary = "Set a tensor in a promise";

  let description = [{
    Set a tensor in a promise.

    $promise: A value of type !mlrt.promise. The underlying value must be a tensorflow tensor.
    $tensor: A tensorflow tensor.
  }];

  let arguments = (ins
    MlrtPromiseType:$promise,
    TFTensorType:$tensor
  );

  let assemblyFormat = "operands attr-dict";
}

  Status RunCallable(CallableHandle handle,
                     const std::vector<Tensor>& feed_tensors,
                     std::vector<Tensor>* fetch_tensors,
                     RunMetadata* run_metadata);

  /// \brief Invokes the subgraph named by `handle` with the given options and
  /// input tensors.
  ///
  /// The order of tensors in `feed_tensors` must match the order of names in

  %2 = "tf.TensorListStack"(%1, %arg1) : (tensor<!tf_type.variant<tensor<10xf32>>>, tensor<1xi32>) -> tensor<3x10xf32>
  func.return %2 : tensor<3x10xf32>

// CHECK-SAME:  ([[INPUT:%.*]]: tensor<3x10xf32>, [[ELEM_SHAPE:%.*]]: tensor<1xi32>, [[INDEX:%.*]]: tensor<i32>, [[ITEM:%.*]]: tensor<10xf32>)

  // Create a DeviceMemoryBase from a Tensor. The Tensor can be an XlaTensor, in
  // which case the returned value is shaped_buffer()->root_buffer(), or a
  // normal Tensor in which case the returned value is
  // {tensor.tensor_data().data(), tensor.tensor_data().size}.
  static se::DeviceMemoryBase DeviceMemoryFromTensor(const Tensor& tensor);

  // Assign the internal ShapedBuffer to new memory for the given dtype and

func.func @single_restore_group(%arg0: tensor<!tf_type.string>) -> (tensor<*xf32>, tensor<*xi32>) {
  %0 = "tf.Const"() {value = dense<"foo"> : tensor<1x!tf_type.string>} : () -> tensor<1x!tf_type.string>
  %1 = "tf.Const"() {value = dense<""> : tensor<1x!tf_type.string>} : () -> tensor<1x!tf_type.string>
  %2 = "tf.RestoreV2"(%arg0, %0, %1) : (tensor<!tf_type.string>, tensor<1x!tf_type.string>, tensor<1x!tf_type.string>) -> tensor<*xf32>

// as tensor names may have changed via MLIR constant folding process.
bool ExpectEqualTensor(const Tensor* tensor, const Tensor* expected_tensor) {
  return (tensor->is_variable() == expected_tensor->is_variable()) &&
         (GetAsVector(tensor->shape()) ==
          GetAsVector(expected_tensor->shape()));
}

// Finds the match of the quantized tensor from the possible tensors. Each

  }

  // Read all underlying tensors of the variables from the session.
  std::vector<Tensor> tensors;
  tensors.reserve(resource_tensors.size());
  for (const Tensor& resource_tensor : resource_tensors) {
    if (resource_tensor.dtype() != tensorflow::DT_RESOURCE) {
      tensors.push_back(resource_tensor);
      continue;
    }

    for (const int itensor : operations_[ioperation].tensors) {
      if (const auto& tensor = tensors_[itensor];
          tensor.first_use() >= begin && tensor.first_use() < end &&
          tensor.last_use() > peak_loc) {
        for (const int ioperation : tensor.operations) {
          // We return the earliest dependence on any output tensor.
          if (ioperation > peak_loc && ioperation < best) {

// in the plugin for Training. The API takes in the context with indices for the
// input and value tensors. It also accepts the copy callback provided by
// pluggable vendor to do the copying of the tensors and the update callback to
// apply the arithmetic operation. The caller takes ownership of the `source`,
// `dest`, `tensor` and `value` tensors and is responsible for freeing them with
// TF_DeleteTensor.