// clustering from losing critical parallelism in the Tensorflow graph, which
// can incur great performance degradation.
//
// This pass must be run before MarkForCompilationPass, as it stores the
// scoping information that MarkForCompilationPass will need to respect for
// clustering decision.
class ClusterScopingPass : public GraphOptimizationPass {
 public:
  Status Run(const GraphOptimizationPassOptions& options) override;

// Marks a subset of nodes in the graph which are to be clustered
// with an attribute _XlaCluster=<cluster id> so they are picked up by the
// EncapsulateSubgraphsPass.
class MarkForCompilationPass : public GraphOptimizationPass {
 public:
  MarkForCompilationPass() = default;

  Status Run(const GraphOptimizationPassOptions& options) override;

 private:
  Status RunForTest(const GraphOptimizationPassOptions& options,

REGISTER_OPTIMIZATION(OptimizationPassRegistry::POST_REWRITE_FOR_EXEC, 9,
                      ClusterScopingPass);

REGISTER_OPTIMIZATION(OptimizationPassRegistry::POST_REWRITE_FOR_EXEC, 10,
                      MarkForCompilationPass);

REGISTER_OPTIMIZATION(OptimizationPassRegistry::POST_REWRITE_FOR_EXEC, 12,
                      ForceXlaConstantsOnHostPass);

REGISTER_OPTIMIZATION(OptimizationPassRegistry::POST_REWRITE_FOR_EXEC, 20,

  opt_options.flib_def = flib_def;

  if (options.enable_cluster_scoping) {
    ClusterScopingPass cluster_scoping_pass;
    TF_RETURN_IF_ERROR(cluster_scoping_pass.Run(opt_options));
  }

  MarkForCompilationPass mark_for_compilation_pass;
  return mark_for_compilation_pass.RunForTest(
      opt_options,
      /*disable_deadness_analysis=*/options.disable_deadness_analysis,

  TF_RETURN_IF_ERROR(runner.AddCpus(32));
  TF_RETURN_IF_ERROR(runner.AddGpus(8));

  for (absl::string_view auto_clustering_pass :
       {"CloneConstantsForBetterClusteringPass", "MarkForCompilationPass",
        "IncreaseDynamismForAutoJitPass", "PartiallyDeclusterPass"}) {
    GraphDef next;
    TF_RETURN_IF_ERROR(
        runner.Run(auto_clustering_pass, std::move(graphdef), &next));

                                   absl::string_view golden_summary_file_path);
};

#if defined(PLATFORM_GOOGLE)
// Reads the GraphDef stored in graph_def_path (which must be a pbtxt file) and
// benchmarks MarkForCompilationPass on this graphdef.
Status BenchmarkMarkForCompilation(absl::string_view graph_def_path,
                                   benchmark::State& state);
#endif  // PLATFORM_GOOGLE

}  // namespace tensorflow

// all operations in the cluster that XLA:CPU can compile.
//
// We provide the `allow_mixing_unknown_and_cpu` knob so that we can do both of
// the following things:
//
// - Let MarkForCompilationPass not inject CPU-placed operations into clusters
//   that will run on unknown devices (because the unknown XLA backend may not
//   support every operation supported by CPU).

    std::atomic<int64_t>* fuel = new std::atomic<int64_t>;
    *fuel = initial_value;
    return fuel;
  }();

  return fuel;
}

}  // anonymous namespace

Status MarkForCompilationPass::Run(
    const GraphOptimizationPassOptions& options) {
  MarkForCompilationPassFlags* flags = GetMarkForCompilationPassFlags();

  MarkForCompilationPassImpl::DebugOptions debug_options;