auto it = info_map_.find(&region);
    assert(it != info_map_.end());
    return it->second;
  }

  // Returns backtracking analysis for the given function.
  const InfoT& GetAnalysisForFunc(func::FuncOp func) const {
    return GetAnalysisForRegion(func.getBody());
  }

  // Backtracks the given value.
  Value BacktrackValue(Value value);

 private:

llvm::SmallVector<Operation*, 4> FindOutsideCompiledOpsAtHead(
    const mlir::TF::SideEffectAnalysis& side_effect_analysis,
    mlir::tf_device::ClusterOp cluster) {
  const auto& analysis = side_effect_analysis.GetAnalysisForFunc(
      cluster->getParentOfType<mlir::func::FuncOp>());
  Region* cluster_region = &cluster.getBody();
  llvm::SmallSetVector<Operation*, 4> head_outside_compiled_ops;

  for (auto func : module_op.getOps<func::FuncOp>()) {
    if (func.isExternal()) continue;
    const auto& analysis_for_func =
        side_effect_analysis.GetAnalysisForFunc(func);
    if (failed(UpdateAllControlDependencies(func, analysis_for_func))) {
      signalPassFailure();
      return;
    }
  }
}

}  // namespace

  TF::SideEffectAnalysis side_effect_analysis(module);
  auto main_func = module.lookupSymbol<func::FuncOp>("main");
  const TF::SideEffectAnalysis::Info& info =
      side_effect_analysis.GetAnalysisForFunc(main_func);
  llvm::StringMap<SmallVector<Cluster>> clusters = BuildAllClusters(
      main_func.front(), info, GetDevice, CanBeIgnoredInCluster);
  return clusters;
}

TEST(BuildClusters, TestSingleCluster) {

  SmallVector<func::FuncOp> funcs(module.getOps<func::FuncOp>());
  int func_count = -1;
  for (auto func : funcs) {
    const auto& info = side_effect_analysis.GetAnalysisForFunc(func);
    for (auto& block : func) {
      OpBuilder builder = OpBuilder::atBlockBegin(&block);
      RaiseTargetSubgraphsForBlock(block, builder, module,

  ModuleOp module = getOperation();
  mlir::TF::ResourceAliasAnalysis resource_analysis(module);
  module.walk([&](func::FuncOp func) {
    const auto& resource_analysis_info =
        resource_analysis.GetAnalysisForFunc(func);
    // Find all the executes first, since we will mutate the nodes around each
    // execute.
    llvm::SmallVector<tf_device::LaunchOp, 8> execute_launches;
    func.walk([&](tf_device::LaunchOp op) {

      side_effect_analysis = TF::SideEffectAnalysis(module);
    }
    ConvertControlToDataOutputs(
        while_body, while_callers, recompute_analysis_for_funcs,
        side_effect_analysis.GetAnalysisForFunc(while_body), solver,
        composite_tpuexecute_side_effects_);
  }
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>
CreateTFExecutorConvertControlToDataOutputsPass() {

  for (auto func : module.getOps<func::FuncOp>()) {
    this->info_map_.try_emplace(func, func, op_side_effect_collector,
                                alias_analysis_.GetAnalysisForFunc(func),
                                op_to_parallel_ids);
  }
}

SideEffectAnalysis::SideEffectAnalysis(ModuleOp module)
    : SideEffectAnalysis(module, {}) {
}

}  // namespace TF

  for (auto func : getOperation().getOps<mlir::func::FuncOp>())
    if (!func.isExternal() &&
        failed(FormClustersInFunction(
            func, side_effect_analysis.GetAnalysisForFunc(func),
            strict_clusters_)))
      return signalPassFailure();
}
}  // anonymous namespace

std::unique_ptr<mlir::OperationPass<ModuleOp>> CreateTPUClusterFormationPass(