void RegisterTracingEngineFactory(const string& name, FactoryFunction factory) {
  assert((!GetFactories().count(name)) ||
         (GetFactories()[name] == factory) &&
             "Duplicate tracing factory registration");
  GetFactories()[name] = factory;
}

Status SetDefaultTracingEngine(const char* name) {
  auto entry = GetFactories().find(name);
  if (entry != GetFactories().end()) {

tensorflow::ServerDef GetServerDef(const std::string& job_name, int num_tasks) {
  tensorflow::ServerDef server_def;
  server_def.set_protocol("grpc");
  server_def.set_job_name(job_name);
  server_def.set_task_index(0);
  tensorflow::ClusterDef* cluster_def = server_def.mutable_cluster();
  tensorflow::JobDef* job_def = cluster_def->add_job();
  job_def->set_name(job_name);
  for (int i = 0; i < num_tasks; i++) {

    AbstractTensorHandle* upstream_grad = grad_outputs[0];
    AbstractTensorHandle* activations = forward_outputs_[0];

    // 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) {

  auto* reader = TFE_MonitoringNewCounterReader(counter_name);
  IncrementCounter1(counter, label_name);

  int64_t actual = TFE_MonitoringReadCounter1(reader, label_name);

  CHECK_EQ(actual, 1);
}

TFE_MonitoringCounter0* CreateCounter0(const char* counter_name) {
  TF_Status* status = TF_NewStatus();
  auto* counter =
      TFE_MonitoringNewCounter0(counter_name, status, "description");
  TF_DeleteStatus(status);

  }
  Status s;
  const char* device_name = DeviceName(&s);
  if (!s.ok()) {
    device_name = "<error fetching device name>";
  }
  return absl::StrCat("TensorHandle(", value_string, ", shape=", shape_string,
                      ", dtype=", DataType_Name(DataType()), ", device=\"",
                      device_name, "\")");
}

Status ImmediateExecutionTensorHandle::SummarizeValue(

  if (!s.ok()) {
    shape_string = "<error computing shape>";
  } else {
    shape_string = shape.DebugString();
  }
  return absl::StrCat("TensorHandle(shape=", shape_string,
                      ", dtype=", DataType_Name(DataType()),
                      ", type=", FullType().DebugString(), ")");
}

Status AbstractTensorHandle::TensorHandleStatus() const {
  // Tensor handles in current runtime don't carry error info and this method

    t.reset(x_raw);
  }

  AbstractOperationPtr check_numerics_op(ctx->CreateOperation());
  ForwardOperation forward_op;
  Status s = Reset(check_numerics_op.get(), "CheckNumerics",
                   /*raw_device_name=*/nullptr, &forward_op);
  ASSERT_EQ(errors::OK, s.code()) << s.message();
  if (isa<TracingOperation>(check_numerics_op.get())) {
    s = dyn_cast<TracingOperation>(check_numerics_op.get())

#include "tensorflow/core/platform/errors.h"

namespace tensorflow {

AbstractContext* BuildFunction(const char* fn_name) {
  std::unique_ptr<TF_Status, decltype(&TF_DeleteStatus)> status(
      TF_NewStatus(), TF_DeleteStatus);
  TF_ExecutionContext* graph_ctx = TF_CreateFunction(fn_name, status.get());
  return unwrap(graph_ctx);
}

Status CreateParamsForInputs(AbstractContext* ctx,

namespace tracing {

Status MaybeSetOpName(AbstractOperation* op, const char* op_name) {
  if (isa<TracingOperation>(op)) {
    TF_RETURN_IF_ERROR(dyn_cast<TracingOperation>(op)->SetOpName(op_name));
  }
  if (isa<gradients::TapeOperation>(op)) {
    TF_RETURN_IF_ERROR(MaybeSetOpName(
        dyn_cast<gradients::TapeOperation>(op)->GetBackingOperation(),
        op_name));
  }
  return absl::OkStatus();
}
}  // namespace tracing

int64_t TFE_MonitoringCounterReader::Read(const LabelType&... labels) {
  return counter->Read(labels...);
}

TFE_MonitoringCounterReader* TFE_MonitoringNewCounterReader(const char* name) {
  auto* result = new TFE_MonitoringCounterReader(name);

  return result;
}

int64_t TFE_MonitoringReadCounter0(TFE_MonitoringCounterReader* cell_reader) {
  int64_t result = cell_reader->Read();

  return result;
}