ops::internal::Enter enter(s.WithOpName("init_value"), init_value, loop_name);
  ops::Merge merge(s.WithOpName("merge"), {init_value, init_value});
  Output next_iteration =
      ops::NextIteration(s.WithOpName("next_itr"), merge.output);
  return s.graph()->UpdateEdge(next_iteration.node(), 0, merge.output.node(),
                               1);
}

TEST(NodesRelatedToRefVariables, Cycles) {

    int64_t &next_id) {
  // Always create a new ID for anonymous handle.
  if (IsResourceHandleAnonymous(shared_name)) return {resource, next_id++};

  ResourceHandle handle(container, shared_name, device, /*op=*/nullptr);
  auto emplace_res = resource_handle_id_map.try_emplace(handle, next_id);
  // New ID created, increment next_id.
  if (emplace_res.second) ++next_id;
  return {resource, emplace_res.first->second};

namespace mlir {
namespace TF {

llvm::SmallVector<ResourceHandleValueAndId, 4>
_TfrtGetResourceOp::GetResourceHandleValueAndIdList(
    llvm::SmallDenseMap<ResourceHandle, int64_t> &resource_handle_id_map,
    int64_t &next_id) {
  llvm::SmallVector<ResourceHandleValueAndId, 4> resource_vec;
  llvm::StringRef device = GetDeviceOrEmpty(getOperation());

  for (const auto &iter : llvm::enumerate(getResults())) {
    auto index = iter.index();

syntax = "proto3";

package tensorflow.calibrator;

option cc_enable_arenas = true;

// Calibration algorithm's collecting statistics.
// NEXT_ID: 4
message CalibrationStatistics {
  message MinMaxStatistics {
    // global minimum of all sample datasets.
    float global_min = 1;

    // global maximum of all sample datasets.
    float global_max = 2;
  }

  message AverageMinMaxStatistics {

  void runOnFunction(func::FuncOp func,
                     const TF::SideEffectAnalysis::Info& analysis) {
    int64_t next_id = 0;
    llvm::SmallDenseMap<Operation*, int64_t, 8> ids;
    func.walk([&](Operation* op) {
      ids[op] = next_id++;
      op->emitRemark("ID: ") << ids[op];
    });
    auto join_ids = [&](const llvm::ArrayRef<Operation*> ops) {
      llvm::SmallVector<std::string, 8> id_vec;

  }

  void runOnFunction(func::FuncOp func,
                     const TF::ResourceAliasAnalysis::Info& analysis) {
    int64_t next_id = 0;
    llvm::SmallDenseMap<Value, int64_t, 8> ids;

    auto assign_id = [&](Value value) {
      if (ids.find(value) == ids.end()) ids.insert({value, next_id++});
    };

    auto get_id = [&](Value value) -> int64_t {
      auto it = ids.find(value);
      assert(it != ids.end());

      // directly.
      auto iter = merge_to_next_iteration.find(n);
      if (iter != merge_to_next_iteration.end()) {
        const Node *next_iter = iter->second, *node = next_iter;
        do {
          TF_RETURN_IF_ERROR(node->input_node(0, &node));
        } while (node->IsIdentity());
        const Node* switch_input;
        bool is_loop_invariant = node->IsSwitch() &&

      llvm::SmallDenseMap<mlir::TF::ResourceHandle, int64_t>&
          resource_handle_id_map,
      int64_t& next_id) {
    llvm::SmallVector<mlir::TF::ResourceHandleValueAndId> resource_vec;
    for (Value resource :
         mlir::tf_type::filter_resources(this->getOperation()->getResults())) {
      resource_vec.push_back({resource, next_id++});
    }
    return resource_vec;
  }
};

}  // namespace TF

      /*methodName=*/"GetResourceHandleValueAndIdList",
      /*args=*/(ins "llvm::SmallDenseMap<ResourceHandle, int64_t>&":$resource_handle_id_map,
                    "int64_t&":$next_id)
    >,
  ];
}

def TF_GetResourceInstanceInterface : OpInterface<"GetResourceInstanceInterface"> {
  let description = [{Returns a string corresponding to the resource instance

    llvm::StringRef container, llvm::StringRef shared_name,
    llvm::StringRef device, Value resource,
    llvm::SmallDenseMap<ResourceHandle, int64_t>& resource_handle_id_map,
    int64_t& next_id);

// Shape functions for ops that are using TF_SameOperandsAndResultTypeResolveRef
// and have at least one operand, result type can be inferred using the first
// operand's type.