cache_bench_report.c

Go to the documentation of this file.

#include <string.h>
 
#include "cache_bench.h"
#include "cache_bench_host.h"
#include "cache_bench_io.h"
#include "ra8_attributes.h"
#include "sweep_block.h"
#include "trace.h"

typedef enum : uint32_t {
  k_cb_size_64   = 64U,   
  k_cb_size_128  = 128U,  
  k_cb_size_256  = 256U,  
  k_cb_size_512  = 512U,  
  k_cb_size_1024 = 1024U, 
  k_cb_size_2048 = 2048U, 
} cb_bench_size_t;

typedef enum : uint32_t {
  k_cb_mid_cap = 256U, 
} cb_mid_cap_t;

typedef enum : uint32_t {
  k_cb_pct_scale = 100U, 
} cb_pct_scale_t;

static const double s_cb_pct_scale_f = 100.0; 

static const uint32_t s_cb_sizes[] = {
  32U,
  (uint32_t)k_cb_size_64,
  (uint32_t)k_cb_size_128,
  (uint32_t)k_cb_size_256,
  (uint32_t)k_cb_size_512,
  (uint32_t)k_cb_size_1024,
  (uint32_t)k_cb_size_2048,
};

RA8_INTERNAL
static int internal_report_trace_header(const cb_trace_t* tr, cb_sink_t* sink, uint32_t nsz)
{
  if (cb_sink_format(sink,
                     "\n### %s  (%llu accesses, footprint %u pages)\n\n",
                     tr->name,
                     (unsigned long long)tr->n,
                     tr->footprint) != k_cb_io_ok ||
      cb_sink_format(sink, "| policy |") != k_cb_io_ok) {
    return 1;
  }
  for (uint32_t s = 0U; s < nsz; ++s) {
    if (cb_sink_format(sink, " %u |", s_cb_sizes[s]) != k_cb_io_ok) {
      return 1;
    }
  }
  if (cb_sink_format(sink, "\n|--------|") != k_cb_io_ok) {
    return 1;
  }
  for (uint32_t s = 0U; s < nsz; ++s) {
    if (cb_sink_format(sink, "------|") != k_cb_io_ok) {
      return 1;
    }
  }
  return cb_sink_format(sink, "\n") != k_cb_io_ok ? 1 : 0;
}

RA8_INTERNAL
static int internal_report_trace_row(const cache_policy_t* policy,
                                     const cb_trace_t*     tr,
                                     cb_workspace_t*       workspace,
                                     cb_sink_t*            sink,
                                     uint32_t              nsz)
{
  if (cb_sink_format(sink, "| %-14s |", policy->name) != k_cb_io_ok) {
    return 1;
  }
  for (uint32_t s = 0U; s < nsz; ++s) {
    cb_result_t r = {};
    if (cb_replay(policy, tr, s_cb_sizes[s], workspace, &r) != 0) {
      return 1;
    }
    const double hit =
      (r.accesses == 0U) ? 0.0 : (s_cb_pct_scale_f * (double)r.hits / (double)r.accesses);
    if (cb_sink_format(sink, " %5.1f |", hit) != k_cb_io_ok) {
      return 1;
    }
  }
  return cb_sink_format(sink, "\n") != k_cb_io_ok ? 1 : 0;
}

RA8_INTERNAL
static int internal_report_trace(const cb_trace_t* tr, cb_workspace_t* workspace, cb_sink_t* sink)
{
  const uint32_t nsz = (uint32_t)(sizeof(s_cb_sizes) / sizeof(s_cb_sizes[0]));
  if (internal_report_trace_header(tr, sink, nsz) != 0) {
    return 1;
  }
  for (uint32_t p = 0U; p < g_cb_policy_count; ++p) {
    if (internal_report_trace_row(g_cb_policies[p], tr, workspace, sink, nsz) != 0) {
      return 1;
    }
  }
  return 0;
}

RA8_INTERNAL
static int internal_report_summary(const cb_trace_t* traces,
                                   uint32_t          ntr,
                                   cb_workspace_t*   workspace,
                                   cb_sink_t*        sink)
{
  const uint32_t mid_cap = (uint32_t)k_cb_mid_cap;
  if (cb_sink_format(sink, "\n## Summary at %u frames (mean over all workloads)\n\n", mid_cap) !=
        k_cb_io_ok ||
      cb_sink_format(sink, "| policy | mean hit %% | worst scan/evict | meta bytes/frame |\n") !=
        k_cb_io_ok ||
      cb_sink_format(sink, "|--------|-----------:|-----------------:|-----------------:|\n") !=
        k_cb_io_ok) {
    return 1;
  }
  for (uint32_t p = 0U; p < g_cb_policy_count; ++p) {
    double   sum_hit = 0.0;
    uint32_t worst   = 0U;
    for (uint32_t t = 0U; t < ntr; ++t) {
      cb_result_t r = {};
      if (cb_replay(g_cb_policies[p], &traces[t], mid_cap, workspace, &r) != 0) {
        return 1;
      }
      sum_hit +=
        (r.accesses == 0U) ? 0.0 : (s_cb_pct_scale_f * (double)r.hits / (double)r.accesses);
      if (r.worst_scan > worst) {
        worst = r.worst_scan;
      }
    }
    if (cb_sink_format(sink,
                       "| %-14s | %10.2f | %16u | %16zu |\n",
                       g_cb_policies[p]->name,
                       sum_hit / (double)ntr,
                       worst,
                       g_cb_policies[p]->meta_bytes) != k_cb_io_ok) {
      return 1;
    }
  }
  return 0;
}

typedef enum : uint8_t {
  k_cb_max_loaded          = 8U, 
  k_cb_output_prefix_bytes = 9U, 
} cb_loaded_cap_t;
 
typedef enum : size_t {
  k_cb_composition_workspace_bytes = 131072U, 
} cb_composition_limit_t;
 
alignas(max_align_t) static uint8_t s_cb_composition_workspace[k_cb_composition_workspace_bytes];
typedef struct {
  uint64_t before;                              
  alignas(max_align_t) uint8_t bytes[1048576U]; 
  uint64_t after;                               
} cb_sweep_backing_t;
 
typedef enum : uint64_t {
  k_cb_sweep_canary_before = 0x0CACEB00C0FFEE11ULL, 
  k_cb_sweep_canary_after  = 0xA11CE55E0BADC0DEULL, 
} cb_sweep_canary_t;

RA8_INTERNAL
static uint32_t
internal_load_argv_traces(int argc, char** argv, cb_trace_t* loaded, cb_host_source_t* sources)
{
  uint32_t nloaded = 0U;
  for (int a = 1; (a < argc) && (nloaded < (uint32_t)k_cb_max_loaded); ++a) {
    const size_t name_length = strcspn(argv[a], "=");
    if ((argv[a][name_length] != '=') ||
        (strncmp(argv[a], "--output=", (size_t)k_cb_output_prefix_bytes) == 0)) {
      continue;
    }
    cb_source_t source = {};
    if ((cb_host_source_open(&argv[a][name_length + 1U], &sources[nloaded], &source) ==
         k_cb_io_ok) &&
        (cb_trace_bind(&source, argv[a], name_length, &loaded[nloaded]) == k_cb_io_ok)) {
      nloaded++;
    } else if (sources[nloaded].fd >= 0) {
      (void)cb_host_source_close(&sources[nloaded]);
    } else {
      /* The open bound no descriptor, so there is nothing to close here. */
    }
  }
  return nloaded;
}

RA8_INTERNAL
static const char* internal_output_path(int argc, char** argv)
{
  for (int i = 1; i < argc; ++i) {
    if (strncmp(argv[i], "--output=", (size_t)k_cb_output_prefix_bytes) == 0) {
      return &argv[i][k_cb_output_prefix_bytes];
    }
  }
  return nullptr;
}

RA8_INTERNAL
static int internal_run_sweep(cb_sink_t* output, cb_sink_t* error)
{
  cb_host_scratch_t scratch_binding = {.fd = -1};
  cb_scratch_t      scratch         = {};
  if (cb_host_scratch_open(&scratch_binding, &scratch) != k_cb_io_ok) {
    return 1;
  }
  static cb_sweep_backing_t s_cb_sweep_backing;
  s_cb_sweep_backing.before = (uint64_t)k_cb_sweep_canary_before;
  s_cb_sweep_backing.after  = (uint64_t)k_cb_sweep_canary_after;
  cb_sweep_config_t config  = {.cache_backing      = s_cb_sweep_backing.bytes,
                               .cache_capacity     = sizeof(s_cb_sweep_backing.bytes),
                               .workspace          = s_cb_composition_workspace,
                               .workspace_capacity = sizeof(s_cb_composition_workspace),
                               .scratch            = &scratch,
                               .output             = output,
                               .error              = error};
  int               result  = cb_sweep_block(&config);
  if ((s_cb_sweep_backing.before != (uint64_t)k_cb_sweep_canary_before) ||
      (s_cb_sweep_backing.after != (uint64_t)k_cb_sweep_canary_after) ||
      (cb_host_scratch_close(&scratch_binding) != k_cb_io_ok)) {
    result = 1;
  }
  return result;
}

RA8_INTERNAL
static int internal_close_sources(cb_host_source_t* sources, uint32_t count)
{
  int result = 0;
  for (uint32_t index = 0U; index < count; ++index) {
    if (cb_host_source_close(&sources[index]) != k_cb_io_ok) {
      result = 1;
    }
  }
  return result;
}

RA8_INTERNAL
static int internal_run_capacity(int argc, char** argv, cb_sink_t* output, cb_sink_t* error)
{
  cb_trace_t traces[k_cb_synthetic_trace_count] = {};
  cb_traces_synthetic(traces);
  cb_trace_t       loaded[k_cb_max_loaded]  = {};
  cb_host_source_t sources[k_cb_max_loaded] = {};
  for (uint32_t i = 0U; i < (uint32_t)k_cb_max_loaded; ++i) {
    sources[i].fd = -1;
  }
  const uint32_t nloaded   = internal_load_argv_traces(argc, argv, loaded, sources);
  cb_workspace_t workspace = {.data     = s_cb_composition_workspace,
                              .capacity = sizeof(s_cb_composition_workspace)};
  const bool     banner_ok =
    (cb_sink_format(output, "# #147 eviction-policy benchmark\n") == k_cb_io_ok) &&
    (cb_sink_format(output, "\nHit rate (%%) by cache size (frames). Higher is better.\n") ==
     k_cb_io_ok);
  int result = 1;
  if (banner_ok) {
    result = 0;
  }
  for (uint32_t t = 0U; (t < (uint32_t)k_cb_synthetic_trace_count) && (result == 0); ++t) {
    result = internal_report_trace(&traces[t], &workspace, output);
  }
  for (uint32_t t = 0U; (t < nloaded) && (result == 0); ++t) {
    result = internal_report_trace(&loaded[t], &workspace, output);
  }
  if (result == 0) {
    result =
      internal_report_summary(traces, (uint32_t)k_cb_synthetic_trace_count, &workspace, output);
  }
  result |= internal_close_sources(sources, nloaded);
  if (result != 0) {
    (void)cb_sink_format(error,
                         "cache_bench: run failed (workspace required=%zu supplied=%zu)\n",
                         workspace.required,
                         workspace.capacity);
  }
  return result;
}
 
int main(int argc, char** argv)
{
  cb_sink_t error = {};
  cb_host_standard_sinks(nullptr, &error);
  cb_host_output_t output_binding = {};
  cb_sink_t        output         = {};
  if (cb_host_output_open(internal_output_path(argc, argv), &output_binding, &output) !=
      k_cb_io_ok) {
    (void)cb_sink_format(&error, "cache_bench: output open failed\n");
    return 1;
  }
  const int result = ((argc > 1) && (strcmp(argv[1], "--sweep-block") == 0))
                       ? internal_run_sweep(&output, &error)
                       : internal_run_capacity(argc, argv, &output, &error);
  if ((result == 0) && (cb_host_output_commit(&output_binding) == k_cb_io_ok)) {
    return 0;
  }
  cb_host_output_abort(&output_binding);
  return 1;
}