NameAttrList function;
  function.set_name("TestFunc");

  EXPECT_TRUE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kAsync, 0));
  EXPECT_TRUE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kLazy, 0));
  EXPECT_TRUE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kStrict, 0));
}

TEST(DeviceCompilationProfilerTest, ShouldCompileClusterFirstExecution) {

  XlaCompiler::Options options = GetDefaultXlaOptions();

  NameAttrList fn;
  fn.set_name("foo");

  // Using a mock here since it's difficult to have ShouldCompileCluster()
  // return false.
  EXPECT_CALL(*mock_profiler_,
              ShouldCompileCluster(_, DeviceCompileMode::kLazy, 1))
      .WillOnce(Return(false));

  TF_EXPECT_OK(xla_device_compiler_->CompileIfNeeded(

  // Determines whether the cluster should be compiled. Creates and inserts an
  // entry into stats (also calls `RegisterExecution`) for `function` if it
  // doesn't already exist.
  virtual bool ShouldCompileCluster(const NameAttrList& function,
                                    DeviceCompileMode compile_mode,
                                    int64_t current_request_count);

  jit_compilation_activity.set_used_persistent_cache(used_persistent_cache);
  return BroadcastXlaActivity(std::move(jit_compilation_activity));
}

bool DeviceCompilationProfiler::ShouldCompileCluster(
    const NameAttrList& function, DeviceCompileMode compile_mode,
    int64_t current_request_count) {
  std::optional<int64_t> compile_threshold;
  if (compile_mode == DeviceCompileMode::kLazy) {

    return errors::Internal("XLA compilation disabled");
  }

  if (state == DeviceCompileState::kUncompiled) {
    XLA_SCOPED_LOGGING_TIMER("Compilation of XLA executable");
    if (!profiler->ShouldCompileCluster(function, compile_mode,
                                        current_request_count)) {
      VLOG(2) << "Not compiling for signature: " << human_signature;
      return absl::OkStatus();

  // Populates `clusters_`.
  Status BuildInitialClusterSet();

  absl::StatusOr<bool> ShouldCompileClusterImpl(const Cluster& cluster);

  absl::StatusOr<bool> ShouldCompileCluster(const Cluster& cluster);

  absl::StatusOr<bool> ClusteringWillIntroduceInterDeviceDependency(
      const Cluster& from, const Cluster& to);

  bool ShouldCompile(bool is_xla_compile_attr_true,