TF_OpKernelConstruction* ctx);

// Allocates Tensor for output at given index. Caller takes ownership of
// returned TF_Tensor and should deallocate it using TF_DeleteTensor(tensor).
//
// This function should be used to allocate outputs inside kernel
// compute function.
TF_CAPI_EXPORT TF_Tensor* TF_AllocateOutput(TF_OpKernelContext* context,

};

inline Tensor TensorHandle::Resolve(Status* status) {
  TF_Tensor* tensor =
      TFE_TensorHandleResolve(handle_.get(), status->GetTFStatus());
  if (!status->ok()) {
    return Tensor(nullptr);
  }
  return Tensor(tensor);
}

inline TensorHandle TensorHandle::FromTensor(const Tensor& tensor,
                                             const Runtime& runtime,

        "TFE_TensorHandleDeviceMemorySize may not be called on a ",
        handle->TypeString(), " tensor handle.");
    return 0;
  }
  const tensorflow::Tensor* tensor;
  status->status = handle->Tensor(&tensor);
  if (!status->status.ok()) {
    return 0;
  }
  return tensor->TotalBytes();
}

TFE_Op* TFE_NewOp(TFE_Context* ctx, const char* op_or_function_name,

#ifndef TENSORFLOW_C_EAGER_DLPACK_H_
#define TENSORFLOW_C_EAGER_DLPACK_H_

#include "tensorflow/c/eager/c_api.h"

namespace tensorflow {

// PyCapsule name for DLPack Tensor
const char* const kDlTensorCapsuleName = "dltensor";

// Converts eager tensor handle to DLPack (DLManagedTensor*), and return the
// void* for further PyCapsule construction.
TF_CAPI_EXPORT extern void* TFE_HandleToDLPack(TFE_TensorHandle* h,

  TFE_TensorHandle* result_t =
      TF_AbstractTensorGetEagerTensor(result, status.get());
  ASSERT_EQ(TF_OK, TF_GetCode(status.get())) << TF_Message(status.get());
  TF_Tensor* result_tensor = TFE_TensorHandleResolve(result_t, status.get());

  // Copy Tensor data into an array.
  float result_data[4] = {0};
  memcpy(&result_data[0], TF_TensorData(result_tensor),
         TF_TensorByteSize(result_tensor));

#include "tensorflow/c/experimental/saved_model/public/tensor_spec.h"
#include "tensorflow/c/tf_datatype.h"
#include "tensorflow/c/tf_shape.h"
#include "tensorflow/c/tf_status.h"
#include "tensorflow/c/tf_tensor.h"
#include "tensorflow/core/lib/io/path.h"
#include "tensorflow/core/platform/status.h"
#include "tensorflow/core/platform/stringpiece.h"
#include "tensorflow/core/platform/test.h"

// This optimizes the following scenario:
// %tft0, %c2 = "tfd.move_dht_to_tft"(%dht0, %c1)
//     : (!dht.host_tensor, !tfrt.chain) -> (!tfd.tf_tensor, !tfrt.chain)
// %dht1, %c3 = "tfd.convert_tft_to_dht"(%tft0, %c2)
//     : (!tfd.tf_tensor, !tfrt.chain) -> (!dht.host_tensor, !tfrt.chain)
// some_op %dht1, %c3
//
// becomes
// some_op %dht0, %c1

struct SimplifyDoubleConversion

  // The operator with index `ioperation` will be assumed to produce and/or
  // consume the tensor with index `itensor`. NoOp if that's already the case.
  // The arguments must be valid indices (i.e., obtained with
  // `AddOperation`/`AddTensor`).
  void AddUse(int ioperation, int itensor);

  // Undoes an AddUse(ioperation, itensor). NoOp if there was no prior `AddUse`.
  // The arguments must be valid indices (i.e., obtained with

  TensorShape y_shape({2});
  Tensor x_init_value =
      test::AsTensor<float>({0.5f, 0.7f, 0.2f, 1.0f, 1.5f, -2.8f}, x_shape);
  RunTest(x, x_init_value, y, y_shape);
}

TEST_F(NaryGradTest, MinMulti) {
  // Test gradient when there are multiple minima.
  // Note that we cannot directly use a test Tensor with multiple
  // minima, as the numeric estimator will calculate incorrect

  void printType(Type type, DialectAsmPrinter &os) const override;
};

// The MLIR type represents a tensorflow::Tensor.
class TFTensorType : public Type::TypeBase<TFTensorType, Type, TypeStorage> {
 public:
  using Base::Base;
  static constexpr StringLiteral name = "tfrt.tf_tensor";
};

// The MLIR type represents a tensorflow::Allocator.
class TFAllocatorType