namespace tensorflow {
namespace {
bool ShouldBeMegamorphic(int64_t compile_count, int64_t execution_count) {
  const int64_t kCompileThreshold = 10;
  const int64_t kMinExecutionsPerCompile = 50;

  // This heuristic is trying to capture the following property: have we sunk a
  // certain minimum amount of compile time into the cluster that didn't quite
  // "pay off"?
  return compile_count > kCompileThreshold &&

    bool is_megamorphic = false;

    std::string DebugString() const {
      return absl::StrCat(
          "DeviceCompilationProfiler::ClusterCompileStats {compile_count=",
          compile_count, ", execution_count=", execution_count,
          ", cumulative_compile_time_us=", cumulative_compile_time_us,
          ", is_megamorphic=", is_megamorphic, "}");
    }
  };

    TF_ASSERT_OK_AND_ASSIGN(auto stats, profiler->GetCompileStats(function));
    XlaJitCompilationActivity expected_activity;
    expected_activity.set_cluster_name(function.name());
    expected_activity.set_compile_count(stats.compile_count);
    expected_activity.set_compile_time_us(4);
    expected_activity.set_cumulative_compile_time_us(
        stats.cumulative_compile_time_us);
    expected_activity.set_used_persistent_cache(false);

            expected_auto_clustering_activity.DebugString());

  EXPECT_EQ(listener()->jit_compilation_activity().cluster_name(), "cluster_0");
  EXPECT_EQ(listener()->jit_compilation_activity().compile_count(), 1);

  int64_t first_compile_time =
      listener()->jit_compilation_activity().compile_time_us();
  EXPECT_GT(first_compile_time, 0);

// 7 instances of XlaJitCompilationActivity.
//
// Next ID: 6
message XlaJitCompilationActivity {
  string cluster_name = 1;

  // The number of time this cluster has been compiled.
  int32 compile_count = 2;

  // Microseconds spent in the individual compilation being reported.
  int64 compile_time_us = 3;

  // Total microseconds spent in (re-)compiling this cluster so far.
  int64 cumulative_compile_time_us = 4;

      listener_->GetListenerHistory();
  EXPECT_EQ(activity_history.size(), 1);
  EXPECT_EQ(activity_history[0].cluster_name(), fn.name());
  EXPECT_EQ(activity_history[0].compile_count(), 1);
  EXPECT_FALSE(activity_history[0].used_persistent_cache());

  listener_->ClearListenerHistory();

  // Create another DeviceCompiler object pointing to the same persistent cache