glyph_bench.c

Go to the documentation of this file.

#include <signal.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_glyph_atlas.h"
#include "ra8_io_stream.h"
#include "ra8_io_stream_posix.h"
#include "ra8_keycache.h"
#include "ra8_log.h"

typedef enum : uint32_t {
  k_gb_pages         = 200U,  
  k_gb_page_glyphs   = 1800U, 
  k_gb_reread_pages  = 3U,    
  k_gb_body_px       = 24U,   
  k_gb_heading_px    = 36U,   
  k_gb_heading_pct   = 3U,    
  k_gb_cap_pct       = 8U,    
  k_gb_punct_pct     = 6U,    
  k_gb_digit_pct     = 2U,    
  k_gb_pct_base      = 100U,  
  k_gb_cell_bytes    = 64U,   
  k_gb_buckets       = 512U,  
  k_gb_prod_cell_kib = 36U,   
  k_gb_max_budget    = 256U,  
  k_gb_decimal_scale = 100U,  
  k_gb_dec_radix     = 10U,   
  k_gb_budget_width  = 5U,    
  k_gb_ram_width     = 12U,   
  k_gb_hit_width     = 7U,    
  k_gb_raster_width  = 14U,   
} gb_dim_t;

typedef enum : uint32_t {
  k_gb_xs_a       = 13U, 
  k_gb_xs_b       = 7U,  
  k_gb_xs_c       = 17U, 
  k_gb_ascii_az_a = 97U, 
  k_gb_ascii_az_z = 26U, 
  k_gb_case_delta = 32U, 
  k_gb_ascii_0    = 48U, 
  k_gb_digits     = 10U, 
} gb_const_t;

typedef enum : uint64_t {
  k_gb_seed = 0xD1B54A32D192ED03ULL, 
} gb_seed_t;

static const uint32_t s_gb_budgets[] =
  {16U, 32U, 48U, 64U, 96U, 128U, 192U, 256U}; /* MAGIC-OK: swept cache-budget data */

static const uint16_t s_gb_letter_freq[26] = {
  817U, 150U, 278U, 425U, 1270U, 223U, 202U, 609U, 697U, /* MAGIC-OK: frequency data */
  15U,  77U,  403U, 241U, 675U,  751U, 193U, 10U,  599U, /* MAGIC-OK: frequency data */
  633U, 906U, 276U, 98U,  236U,  15U,  197U, 7U};        /* MAGIC-OK: frequency data */

typedef enum : uint32_t {
  k_gb_freq_total = 9999U, 
} gb_freq_t;

typedef struct {
  uint8_t             cells[k_gb_max_budget * k_gb_cell_bytes]; 
  ra8_glyph_key_t     keys[k_gb_max_budget];                    
  ra8_glyph_dims_t    dims[k_gb_max_budget];                    
  ra8_keycache_cell_t meta[k_gb_max_budget];                    
  int32_t             buckets[k_gb_buckets];                    
} gb_workspace_t;

static gb_workspace_t s_gb_workspace;
static ra8_io_stream_t s_gb_output;
static ra8_io_stream_t s_gb_diagnostic;
static ra8_io_stream_posix_state_t s_gb_output_posix;
static ra8_io_stream_posix_state_t s_gb_diagnostic_posix;

RA8_INTERNAL static ra8_err_t
internal_write_parts(ra8_io_stream_t* stream, const char* const* parts, size_t count)
{
  for (size_t i = 0U; i < count; ++i) {
    const ra8_err_t error = ra8_io_stream_puts(stream, parts[i]);
    if (error != k_ra8_ok) {
      return error;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static void internal_log_byte(void* context, uint8_t byte)
{
  (void)ra8_io_stream_putc((ra8_io_stream_t*)context, (char)byte);
}

RA8_INTERNAL static ra8_err_t internal_output_init(void)
{
  struct sigaction action = {.sa_handler = SIG_IGN};
  if ((sigemptyset(&action.sa_mask) != 0) || (sigaction(SIGPIPE, &action, nullptr) != 0)) {
    return k_ra8_err_comm_error;
  }
  ra8_err_t error = ra8_io_stream_posix_init(&s_gb_output, &s_gb_output_posix, STDOUT_FILENO);
  if (error == k_ra8_ok) {
    error = ra8_io_stream_posix_init(&s_gb_diagnostic, &s_gb_diagnostic_posix, STDERR_FILENO);
  }
  if (error == k_ra8_ok) {
    ra8_log_init();
    ra8_log_set_byte_sink(internal_log_byte, &s_gb_diagnostic);
  }
  return error;
}

RA8_INTERNAL static uint64_t internal_gb_rng(uint64_t* s)
{
  uint64_t x = *s;
  x ^= x << (uint32_t)k_gb_xs_a;
  x ^= x >> (uint32_t)k_gb_xs_b;
  x ^= x << (uint32_t)k_gb_xs_c;
  *s = x;
  return x;
}

RA8_INTERNAL static uint32_t internal_gb_below(uint64_t* s, uint32_t span)
{
  return (span == 0U) ? 0U : (uint32_t)(internal_gb_rng(s) % (uint64_t)span);
}

RA8_INTERNAL static uint32_t internal_gb_pick_letter(uint64_t* s)
{
  uint32_t r = internal_gb_below(s, (uint32_t)k_gb_freq_total);
  for (uint32_t i = 0U; i < (uint32_t)k_gb_ascii_az_z; ++i) {
    if (r < (uint32_t)s_gb_letter_freq[i]) {
      return (uint32_t)k_gb_ascii_az_a + i;
    }
    r -= (uint32_t)s_gb_letter_freq[i];
  }
  return (uint32_t)k_gb_ascii_az_a; /* fallthrough: 'a' */
}

static const uint32_t s_gb_punct[] = {' ', '.', ',', ';', ':', '\'', '"', '-', '!', '?'};

RA8_INTERNAL static uint32_t internal_gb_pick_codepoint(uint64_t* s)
{
  const uint32_t roll = internal_gb_below(s, (uint32_t)k_gb_pct_base);
  if (roll < (uint32_t)k_gb_punct_pct) {
    const uint32_t n = (uint32_t)(sizeof(s_gb_punct) / sizeof(s_gb_punct[0]));
    return s_gb_punct[internal_gb_below(s, n)];
  }
  if (roll < (uint32_t)k_gb_punct_pct + (uint32_t)k_gb_digit_pct) {
    return (uint32_t)k_gb_ascii_0 + internal_gb_below(s, (uint32_t)k_gb_digits);
  }
  uint32_t cp = internal_gb_pick_letter(s);
  if (internal_gb_below(s, (uint32_t)k_gb_pct_base) < (uint32_t)k_gb_cap_pct) {
    cp -= (uint32_t)k_gb_case_delta; /* uppercase variant */
  }
  return cp;
}

RA8_INTERNAL static ra8_err_t internal_gb_render(void*                  ctx,
                                                 const ra8_glyph_key_t* key,
                                                 uint8_t*               cell,
                                                 uint32_t               cell_bytes,
                                                 uint16_t*              out_w,
                                                 uint16_t*              out_h)
{
  (void)ctx;
  (void)key;
  (void)memset(cell, 0, (size_t)cell_bytes);
  *out_w = 1U;
  *out_h = 1U;
  return k_ra8_ok;
}

static const uint64_t s_gb_access_total =
  (uint64_t)k_gb_pages * (uint64_t)k_gb_reread_pages * (uint64_t)k_gb_page_glyphs;

RA8_INTERNAL static ra8_err_t internal_submit_access(ra8_glyph_atlas_t* atlas, uint64_t* rng)
{
  const bool heading = internal_gb_below(rng, (uint32_t)k_gb_pct_base) < (uint32_t)k_gb_heading_pct;
  ra8_glyph_key_t key   = {.glyph_id = internal_gb_pick_codepoint(rng),
                           .size_px  = heading ? (uint16_t)k_gb_heading_px : (uint16_t)k_gb_body_px};
  ra8_glyph_t     glyph = {};
  ra8_err_t       error = ra8_glyph_atlas_get(atlas, &key, &glyph);
  if (error == k_ra8_ok) {
    error = ra8_glyph_atlas_put(atlas, glyph.bitmap);
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_replay_page_glyphs(ra8_glyph_atlas_t* atlas,
                                                          uint64_t*          page_rng)
{
  for (uint32_t glyph = 0U; glyph < (uint32_t)k_gb_page_glyphs; ++glyph) {
    const ra8_err_t error = internal_submit_access(atlas, page_rng);
    if (error != k_ra8_ok) {
      return error;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_replay_workload(ra8_glyph_atlas_t* atlas)
{
  uint64_t session_rng = (uint64_t)k_gb_seed;
  for (uint32_t page = 0U; page < (uint32_t)k_gb_pages; ++page) {
    const uint64_t page_start = session_rng;
    uint64_t       next_page  = page_start;
    for (uint32_t repeat = 0U; repeat < (uint32_t)k_gb_reread_pages; ++repeat) {
      uint64_t        page_rng = page_start;
      const ra8_err_t error    = internal_replay_page_glyphs(atlas, &page_rng);
      if (error != k_ra8_ok) {
        return error;
      }
      if (repeat == 0U) {
        next_page = page_rng;
      }
    }
    session_rng = next_page;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t
internal_run_budget(uint32_t budget, uint32_t* out_hits, uint32_t* out_rasters)
{
  (void)memset(&s_gb_workspace, 0, sizeof(s_gb_workspace));
  const ra8_glyph_atlas_cfg_t cfg   = {.cell_mem     = s_gb_workspace.cells,
                                       .cell_bytes   = (uint32_t)k_gb_cell_bytes,
                                       .cell_count   = budget,
                                       .meta         = s_gb_workspace.meta,
                                       .keys         = s_gb_workspace.keys,
                                       .dims         = s_gb_workspace.dims,
                                       .buckets      = s_gb_workspace.buckets,
                                       .bucket_count = (uint32_t)k_gb_buckets,
                                       .render       = internal_gb_render,
                                       .render_ctx   = nullptr};
  ra8_glyph_atlas_t           atlas = {};
  ra8_err_t                   error = ra8_glyph_atlas_init(&atlas, &cfg);
  if (error == k_ra8_ok) {
    error = internal_replay_workload(&atlas);
  }
  if (error == k_ra8_ok) {
    error = ra8_glyph_atlas_stats(&atlas, out_hits, out_rasters, nullptr);
  }
  return error;
}

RA8_INTERNAL static ra8_err_t
internal_put_padded_u64(ra8_io_stream_t* stream, uint64_t value, uint32_t width)
{
  uint32_t digits = 1U;
  for (uint64_t copy = value; copy >= (uint64_t)k_gb_dec_radix; copy /= (uint64_t)k_gb_dec_radix) {
    ++digits;
  }
  for (uint32_t i = digits; i < width; ++i) {
    const ra8_err_t error = ra8_io_stream_putc(stream, ' ');
    if (error != k_ra8_ok) {
      return error;
    }
  }
  return ra8_io_stream_put_u64(stream, value);
}

RA8_INTERNAL static ra8_err_t internal_report_header(void)
{
  const char* const prefix[] = {"# #147/#164 glyph-cache budget sweep\n\nWorkload: "};
  ra8_err_t         error    = internal_write_parts(&s_gb_output, prefix, 1U);
  if (error == k_ra8_ok) {
    error = ra8_io_stream_put_u32(&s_gb_output, (uint32_t)k_gb_pages);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output, " pages x ");
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_put_u32(&s_gb_output, (uint32_t)k_gb_reread_pages);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output, " re-renders x ");
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_put_u32(&s_gb_output, (uint32_t)k_gb_page_glyphs);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output, " glyphs = ");
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_put_u64(&s_gb_output, s_gb_access_total);
  }
  if (error == k_ra8_ok) {
    error =
      ra8_io_stream_puts(&s_gb_output,
                         " glyph gets\n(English letter frequencies + caps/punct/digits; body ");
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_put_u32(&s_gb_output, (uint32_t)k_gb_body_px);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output, "px, heading ");
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_put_u32(&s_gb_output, (uint32_t)k_gb_heading_px);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(
      &s_gb_output,
      "px)\n\n| cells | RAM @36KiB/cell | hit rate % | rasterisations |\n|------:|----------------:|-----------:|---------------:|\n");
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_report_row(uint32_t budget, uint32_t hits, uint32_t rasters)
{
  const uint64_t scaled =
    (((uint64_t)hits * (uint64_t)k_gb_pct_base * (uint64_t)k_gb_decimal_scale) +
     (s_gb_access_total / 2U)) /
    s_gb_access_total;
  const uint64_t whole    = scaled / (uint64_t)k_gb_decimal_scale;
  const uint32_t fraction = (uint32_t)(scaled % (uint64_t)k_gb_decimal_scale);
  ra8_err_t      error    = ra8_io_stream_puts(&s_gb_output, "| ");
  if (error == k_ra8_ok) {
    error = internal_put_padded_u64(&s_gb_output, budget, (uint32_t)k_gb_budget_width);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output, " | ");
  }
  if (error == k_ra8_ok) {
    error = internal_put_padded_u64(&s_gb_output,
                                    (uint64_t)budget * (uint64_t)k_gb_prod_cell_kib,
                                    (uint32_t)k_gb_ram_width);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output, " KiB | ");
  }
  if (error == k_ra8_ok) {
    error = internal_put_padded_u64(&s_gb_output, whole, (uint32_t)k_gb_hit_width);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_putc(&s_gb_output, '.');
  }
  if ((error == k_ra8_ok) && (fraction < (uint32_t)k_gb_dec_radix)) {
    error = ra8_io_stream_putc(&s_gb_output, '0');
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_put_u32(&s_gb_output, fraction);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output, " | ");
  }
  if (error == k_ra8_ok) {
    error = internal_put_padded_u64(&s_gb_output, rasters, (uint32_t)k_gb_raster_width);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output, " |\n");
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_run_report(void)
{
  ra8_err_t    error = internal_report_header();
  const size_t count = sizeof(s_gb_budgets) / sizeof(s_gb_budgets[0]);
  for (size_t i = 0U; (i < count) && (error == k_ra8_ok); ++i) {
    uint32_t hits    = 0U;
    uint32_t rasters = 0U;
    error            = internal_run_budget(s_gb_budgets[i], &hits, &rasters);
    if (error == k_ra8_ok) {
      error = internal_report_row(s_gb_budgets[i], hits, rasters);
    }
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output,
                               "\nWithout a cache the renderer rasterises once per glyph get (");
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_put_u64(&s_gb_output, s_gb_access_total);
  }
  if (error == k_ra8_ok) {
    error = ra8_io_stream_puts(&s_gb_output, ").\n");
  }
  return error;
}
 
int main(void)
{
  if (internal_output_init() != k_ra8_ok) {
    return 1;
  }
  const ra8_err_t error = internal_run_report();
  if (error != k_ra8_ok) {
    const char* const parts[] = {"glyph_bench: workload or output failed\n"};
    (void)internal_write_parts(&s_gb_diagnostic, parts, 1U);
    return 1;
  }
  return 0;
}