263-0007-00L-Advanced-Systems-Lab/main-float.cpp

#include "./headers/board_float.hpp"
#include "./headers/constants_float.hpp"
#include "./headers/pedestrian_float.hpp"
#include "./headers/social_force_float.hpp"

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <vector>

#ifndef BENCHMARK
#define BENCHMARK 0
#endif

#ifndef ROOFLINE
#define ROOFLINE 0
#endif

#ifdef __x86_64__
#include "./headers/tsc_x86.h"
#include <immintrin.h>
#define TRASH_BUFFER_SIZE (16ULL * 1024 * 1024 * 2) // 2x L3 (~16MB) on the x86 machine we use for measurements
#define PAGE_SIZE 4096
#endif

#ifdef __aarch64__
#include "./headers/kperf.h"
#include <arm_acle.h>
#define TRASH_BUFFER_SIZE (1502838784ULL * 2) // 2x SLC (~1.5GB) on M3 Pro
#define PAGE_SIZE 16384
#endif

#define N_OBSTACLES 2

// Benchmark parameters (mostly copied from mvm.c in hw1)
#define WARMUP_ITERS 3
#define NUM_REPS 15
#define NUM_RUNS 1
#define CYCLES_REQUIRED 1e8
#define MAX_NUM_RUNS (1 << 14)

// Flushes caches by streaming reads through a large persistent buffer.
long long flush_cache() {
  static volatile char *trash_buffer = nullptr;
  static bool initialized = false;

  if (!initialized) {
    trash_buffer = new volatile char[TRASH_BUFFER_SIZE];

    // Touch one byte per page once so pages are physically mapped. And we avoid paying the cost of page faults during cache trashing below.
    for (size_t i = 0; i < TRASH_BUFFER_SIZE; i += PAGE_SIZE) {
      trash_buffer[i] = 1;
    }

    initialized = true;
  }

  long long acc = 0;

  for (size_t i = 0; i < TRASH_BUFFER_SIZE; i += CACHE_BLOCK_SIZE) {
    // Access one byte per cache block is enough to populate the entire block
    acc += trash_buffer[i];
  }

#ifdef __x86_64__
  _mm_lfence();
#endif

#ifdef __aarch64__
  __isb(0xF);
#endif

  asm volatile("" ::: "memory");

  return acc;
}

int main(int argc, const char *argv[]) {
#ifdef __x86_64__
  // flush denormals to zero via MXCSR. one-time, per thread.
  // any subnormal in the j-loop chain stalls fma for 100+ cycles, this kills that.
  _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
  _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
#endif

  // Check that the correct number of arguments has been passed.
  //
  // Expected usage:
  //
  //   ./main <number_of_pedestrians> <number_of_iterations> [csv_output_path]
  //
  // The optional third argument enables CSV dumping for visualization.
  if (argc < 3) {
    printf("Usage: ./main <number_of_pedestrians> <number_of_iterations> [csv_output_path]\n");
    printf("Each iteration takes %.2f seconds in the simulation.\n", dt);
    return 1;
  }

  // Parse command-line arguments.
  int n_p = atoi(argv[1]);
  int n_iter = atoi(argv[2]);

  if (n_p <= 0) {
    printf("Error: <number_of_pedestrians> must be a positive integer, got '%s'\n", argv[1]);
    return 1;
  }
  if (n_iter <= 0) {
    printf("Error: <number_of_iterations> must be a positive integer, got '%s'\n", argv[2]);
    return 1;
  }

  // If provided, dump_path is used to write simulation states to CSV.
  // In benchmark mode, this path is intentionally ignored to avoid measuring
  // file I/O overhead.
  const char *dump_path = (argc >= 4) ? argv[3] : nullptr;

#if BENCHMARK

#if ROOFLINE
  volatile long long trash_value;
#endif

#ifdef __aarch64__
  // Initialize ARM performance counters.
  kperf_init();
  struct performance_counters startperf, endperf;
#endif

  // Warmup runs, to bring caches, predictors, frequency to steady state. These are not measured.
  // Each run gets a fresh initialized state because run_simulation mutates the
  // pedestrians and board state.
  for (int i = 0; i < WARMUP_ITERS; i++) {
    Pedestrian *P = init_pedestrians(n_p);
    Board board = init_board_without_obstacles();
    run_simulation(P, board, n_p, n_iter, nullptr);
    delete[] P;
  }

  // Calibration: finds num_runs such that one batch runs for at least
  // CYCLES_REQUIRED cycles. A long batch keeps makes the timer and other
  // noise overhead, negligible relative to the kernel execution cost we're
  // actually trying to measure.
  //
  // Skipped when ROOFLINE is enabled: cold-cache measurements need
  // exactly one timed simulation per batch, otherwise only the first
  // call starts cold and subsequent calls measure warm-cache behavior.
  // We can use large enough inputs so a single call already exceeds CYCLES_REQUIRED,
  // when measuring for roofline plot.
  // Note: we implemented the calibration exactly as it is done in mvm.c from hw1, we also
  // used the same values for NUM_RUNS, etc
  int num_runs = NUM_RUNS;
#if !ROOFLINE
  while (num_runs < MAX_NUM_RUNS) {
    Pedestrian *P = init_pedestrians(n_p);
    Board board = init_board_without_obstacles();

    float cycles;

#ifdef __x86_64__
    myInt64 start = start_tsc();
#endif

#ifdef __aarch64__
    startperf = kperf_get_counters();
#endif

    for (int j = 0; j < num_runs; j++) {
      run_simulation(P, board, n_p, n_iter, nullptr);
    }

#ifdef __x86_64__
    cycles = (float)stop_tsc(start);
#endif

#ifdef __aarch64__
    endperf = kperf_get_counters();
    cycles = (float)(endperf.cycles - startperf.cycles);
#endif

    delete[] P;

    if (cycles >= CYCLES_REQUIRED)
      break;
    num_runs *= 2;
  }
#endif

  // Store the cycle count of each measured repetition.
  // The median is then used as the final timing result.
  std::vector<float> cycles_v;
  cycles_v.reserve(NUM_REPS);

  // Measurement phase
  for (int i = 0; i < NUM_REPS; i++) {
    Pedestrian *P = init_pedestrians(n_p);
    Board board = init_board_without_obstacles();

#if ROOFLINE
    trash_value = flush_cache();
#endif

#ifdef __x86_64__
    myInt64 start = start_tsc();
#endif
#ifdef __aarch64__
    startperf = kperf_get_counters();
#endif

    for (int j = 0; j < num_runs; j++) {
      // Disable CSV dumping during benchmarking to avoid measuring file I/O
      // overhead. Initialization is also excluded from the measured region.

      run_simulation(P, board, n_p, n_iter, nullptr);
    }

#ifdef __x86_64__
    float cycles = (float)stop_tsc(start) / num_runs;
#endif
#ifdef __aarch64__
    endperf = kperf_get_counters();
    float cycles = (float)(endperf.cycles - startperf.cycles) / num_runs;
#endif

    delete[] P;
    cycles_v.push_back(cycles);
  }

  std::sort(cycles_v.begin(), cycles_v.end());
  // Use the median cycle count to reduce the effect of noisy measurements.
  float T = cycles_v[NUM_REPS / 2];

#else

  // Normal execution mode. If dump_path is provided, the simulation writes a CSV
  // file that can later be used to generate a video of the simulation.
  Pedestrian *P = init_pedestrians(n_p);
  Board board = init_board_without_obstacles();
  run_simulation(P, board, n_p, n_iter, dump_path);

  delete[] P;

#endif

#if BENCHMARK

  // Flop-count per simulation iteration.
  //
  // The total work W(n) is estimated from the number of additions,
  // multiplications, divisions, square roots, and exponentials performed by the
  // simulation kernels.

  long long add_count_per_iter = n_p * (2 + (n_p - 1) * 14 + N_OBSTACLES * 10 + 2) + n_p * 7;
  long long mult_count_per_iter = n_p * (4 + (n_p - 1) * 24 + N_OBSTACLES * 13) + n_p * 16;
  long long div_count_per_iter = n_p * ((n_p - 1) * 1 + N_OBSTACLES * 1) + n_p * 2;
  long long sqrt_count_per_iter = n_p * ((n_p - 1) * 3 + N_OBSTACLES * 1) + n_p * 3;
  long long exp_count_per_iter = n_p * ((n_p - 1) * 1 + N_OBSTACLES * 1);

  float W_per_iter = add_count_per_iter * cost_add + mult_count_per_iter * cost_mult + div_count_per_iter * cost_div + sqrt_count_per_iter * cost_sqrt + exp_count_per_iter * cost_exp;

  // Estimated memory traffic per iteration.
  // TODO: refine this model to account for actual memory accesses, cache reuse,
  // and the full interaction loop.

  long long Q_per_iter = sizeof(Pedestrian) * n_p + sizeof(Obstacle) * N_OBSTACLES;

  // Operational intensity:
  //
  //   I(n) = W(n) / Q(n)
  //
  // where W is estimated work in flops and Q is estimated memory traffic in
  // bytes.

  float I = W_per_iter / Q_per_iter;
  float W = W_per_iter * n_iter;

  // Performance in estimated flops per cycle.
  float P = W / T;

  printf("W(n) per iteration: %.2f flops\n", W_per_iter);
  printf("Q(n) per iteration: %lld bytes\n", Q_per_iter);
  printf("I(n): %.2f flops/byte\n", I);
  printf("W(n): %.2f flops\n", W);
  printf("T(n): %.2f cycles\n", T);
  printf("P(n): %.2f flops/cycle\n", P);

#endif

  return 0;
}