// Calculate Grad
    std::string name = "relu_grad";
    TF_RETURN_IF_ERROR(ReluGrad(ctx, upstream_grad, activations,
                                &grad_inputs[0], name.c_str()));
    return absl::OkStatus();
  }
  ~ReluGradientFunction() override {
    for (auto output : forward_outputs_) {
      if (output) {
        output->Unref();
      }
    }
  }

 private:

                         off_t size) {
  int src_fd = open(src, O_RDONLY);
  if (src_fd < 0) return -1;

  // When creating file, use the same permissions as original
  mode_t open_mode = mode & (S_IRWXU | S_IRWXG | S_IRWXO);

  // O_WRONLY | O_CREAT | O_TRUNC:
  //   Open file for write and if file does not exist, create the file.
  //   If file exists, truncate its size to 0.

  TracingContext* tracing_ctx = dyn_cast<TracingContext>(unwrap(func));
  if (!tracing_ctx) {
    tsl::Set_TF_Status_from_Status(
        s, tensorflow::errors::InvalidArgument(
               "TF_AddFunctionParameter must be called on a TracingContext."));
    return nullptr;
  }
  tensorflow::PartialTensorShape partial_shape;
  if (shape.num_dims != -1) {
    DCHECK(shape.dim_sizes != nullptr);

  EXPECT_EQ(dltensor_out->dtype.lanes, dltensor_in->dtype.lanes);
  for (int i = 0; i < dltensor_in->ndim; ++i) {
    EXPECT_EQ(dltensor_out->shape[i], dltensor_in->shape[i]);
    if (dltensor_out->strides) {
      if (i == dltensor_in->ndim - 1) {
        EXPECT_EQ(dltensor_out->strides[i], 1);
      } else {
        EXPECT_EQ(dltensor_out->strides[i],

  PartialTensorShape shape;
  std::string shape_string;
  if (Shape(&shape).ok()) {
    shape_string = shape.DebugString();
  } else {
    shape_string = "<error computing shape>";
  }
  std::string value_string;
  if (!SummarizeValue(value_string).ok()) {
    value_string = "<error computing value>";
  }
  if (value_string.length() > 100) {

  ::tensorflow::FileStatistics cc_stats;
  TF_SetStatus(status, TF_OK, "");
  ::tensorflow::Status s =
      ::tensorflow::Env::Default()->Stat(filename, &cc_stats);
  ::tensorflow::Set_TF_Status_from_Status(status, s);
  if (s.ok()) {
    stats->length = cc_stats.length;
    stats->mtime_nsec = cc_stats.mtime_nsec;
    stats->is_directory = cc_stats.is_directory;
  }
}

// Return value will be unused
bool StaticallyRegisterLocalFilesystems() {
  TF_FilesystemPluginInfo info;
  TF_InitPlugin(&info);
  Status status = filesystem_registration::RegisterFilesystemPluginImpl(&info);
  if (!status.ok()) {
    VLOG(0) << "Static POSIX filesystem could not be registered: " << status;
    return false;
  }
  return true;
}

// Perform the actual registration

                      absl::Span<AbstractTensorHandle* const> inputs,
                      absl::Span<AbstractTensorHandle*> outputs) {
  std::vector<AbstractTensorHandle*> temp_outputs(2);
  TF_RETURN_IF_ERROR(
      ops::IdentityN(ctx, inputs, absl::MakeSpan(temp_outputs), "IdentityN"));
  // Although, `ops::IdentityN` returns 2 tensors, the first tensor isn't needed
  // for computing gradient so we could safely drop it.

    }
    std::vector<AbstractTensorHandle*> temp_outputs(1);
    AbstractContextPtr tape_ctx(new TapeContext(ctx, &tape, grad_registry));
    TF_RETURN_IF_ERROR(
        forward_model(tape_ctx.get(), inputs, absl::MakeSpan(temp_outputs)));

    TF_RETURN_IF_ERROR(tape.ComputeGradient(ctx, /*targets=*/temp_outputs,
                                            /*sources=*/inputs,

using tensorflow::strings::StrCat;

TF_ExecutionContext* TF_NewEagerExecutionContext(TFE_ContextOptions* options,
                                                 TF_Status* s) {
  TFE_Context* c_ctx = TFE_NewContext(options, s);
  if (TF_GetCode(s) != TF_OK) {
    return nullptr;
  }
  return wrap(static_cast<AbstractContext*>(unwrap(c_ctx)));
}

TF_AbstractTensor* TF_CreateAbstractTensorFromEagerTensor(TFE_TensorHandle* t,