void distinct_count_accuracy_profile::run()

in cpp/src/distinct_count_accuracy_profile.cpp [87:146]

• 47 lines of code
• 6 McCabe index (conditional complexity)

void distinct_count_accuracy_profile::run() {
  const size_t lg_min_trials = 4;
  const size_t lg_max_trials = 16;
  const size_t trials_ppo = 4;
  const bool print_intermediate = true; // print intermediate data

  const size_t minT = 1 << lg_min_trials;
  const size_t max_trials = 1 << lg_max_trials;

  const size_t lg_min_counts = 0;
  const size_t lg_max_counts = 32;
  const size_t counts_ppo = 16;

  const size_t quantiles_k = 10000;

  const size_t num_points = count_points(lg_min_counts, lg_max_counts, counts_ppo);
  size_t p = 1 << lg_min_counts;
  for (size_t i = 0; i < num_points; i++) {
    stats.push_back(accuracy_stats(quantiles_k, p));
    p = pwr_2_law_next(counts_ppo, p);
  }

  key = 0;

  const auto start_time = std::chrono::system_clock::now();

  // this will generate a table of data up to each intermediate number of trials
  size_t last_trials = 0;
  while (last_trials < max_trials) {
    const size_t next_trials = (last_trials == 0) ? minT : pwr_2_law_next(trials_ppo, last_trials);
    const int delta = next_trials - last_trials;
    for (int i = 0; i < delta; i++) {
      run_trial();
    }
    last_trials = next_trials;

    if (print_intermediate or next_trials == max_trials) {
      print_stats();
    }

    std::cout << "Cum Trials             : " << last_trials << std::endl;
    std::cout << "Cum Updates            : " << key << std::endl;
    const auto current_time = std::chrono::system_clock::now();
    const std::chrono::milliseconds cum_time_ms =
        std::chrono::duration_cast<std::chrono::milliseconds>(current_time - start_time);
    std::cout << "Cum Time, ms           : " << cum_time_ms.count() << std::endl;
    const double time_per_trial_ms = (cum_time_ms.count()) / last_trials;
    std::cout << "Avg Time Per Trial, ms : " << time_per_trial_ms << std::endl;

    const auto current_time_t = std::chrono::system_clock::to_time_t(current_time);
    std::cout << "Current time           : " << std::ctime(&current_time_t);

    const auto time_to_complete_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        cum_time_ms / last_trials * (max_trials - last_trials));
    const auto est_completion_time = std::chrono::system_clock::to_time_t(current_time + time_to_complete_ms);
    std::cout << "Est Time of Completion : " << std::ctime(&est_completion_time);

    std::cout << std::endl;
  }
}