main.cpp

#include "pls/pls.h"

#include "benchmark_runner.h"
#include "benchmark_base/matrix.h"
#include "benchmark_base/fft.h"

using namespace comparison_benchmarks::base;

void pls_conquer(fft::complex_vector::iterator data, fft::complex_vector::iterator swap_array, int n) {
  if (n < 2) {
    return;
  }

  fft::divide(data, swap_array, n);
  if (n <= fft::RECURSIVE_CUTOFF) {
    fft::conquer(data, swap_array, n / 2);
    fft::conquer(data + n / 2, swap_array + n / 2, n / 2);
  } else {
    pls::spawn([data, n, swap_array]() {
      pls_conquer(data, swap_array, n / 2);
    });
    pls::spawn_and_sync([data, n, swap_array]() {
      pls_conquer(data + n / 2, swap_array + n / 2, n / 2);
    });
  }

  fft::combine(data, n);
}

constexpr int MAX_NUM_TASKS = 16;
constexpr int MAX_STACK_SIZE = 4096 * 1;

int main(int argc, char **argv) {
  auto settings = benchmark_runner::parse_parameters(argc, argv);
  size_t matrix_size = settings.size_;
  size_t fft_size = 8192;

  string test_name = to_string(settings.num_threads_) + ".csv";
  string full_directory = settings.output_directory_ + "/PLS_v3/";
  benchmark_runner runner{full_directory, test_name};

  pls::scheduler scheduler{(unsigned) settings.num_threads_, MAX_NUM_TASKS, MAX_STACK_SIZE};

  // Data Containers
  fft::complex_vector fft_data(fft_size);
  fft::complex_vector fft_swap_array(fft_size);
  fft::fill_input(fft_data);
  matrix::matrix<double> matrix_a{matrix_size};
  matrix::matrix<double> matrix_b{matrix_size};
  matrix::matrix<double> matrix_result{matrix_size};

  if (settings.type_ == benchmark_runner::benchmark_settings::ISOLATED) {
#if PLS_PROFILING_ENABLED
    scheduler.get_profiler().disable_memory_measure();
    runner.add_custom_stats_field("T_1");
    runner.add_custom_stats_field("T_inf");
#endif
    printf("Running isolated measurement...\n");
    runner.enable_memory_stats();
    runner.pre_allocate_stats();

    runner.run_iterations(settings.iterations_, [&]() {
      // Serial Matrix Multiplication
      matrix_result.multiply(matrix_a, matrix_b);
      // Parallel FFT
      scheduler.perform_work([&]() {
        pls_conquer(fft_data.begin(), fft_swap_array.begin(), fft_size);
      });
    }, [&]() {
      fft::fill_input(fft_data); // Reset data before each run
    }, [&]() {
#if PLS_PROFILING_ENABLED
      runner.store_custom_stat("T_1", scheduler.get_profiler().current_run().t_1_);
      runner.store_custom_stat("T_inf", scheduler.get_profiler().current_run().t_inf_);
#endif
    });
    runner.commit_results(true);
  } else {
    printf("Running periodic measurement...\n");
    runner.enable_wall_time_stats();
    runner.pre_allocate_stats();

    runner.run_periodic(settings.iterations_, settings.interval_period_, settings.interval_deadline_, [&]() {
      // Serial Matrix Multiplication
      matrix_result.multiply(matrix_a, matrix_b);
      // Parallel FFT
      scheduler.perform_work([&]() {
        pls_conquer(fft_data.begin(), fft_swap_array.begin(), fft_size);
      });
      // Reset data before each run
      fft::fill_input(fft_data);
    });
    runner.commit_results(true);
  }

  return 0;
}