emu_run_guards.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
 
#include "emu_host_io_internal.h"
#include "emu_prof.h"
#include "emu_run.h"
#include "emu_view.h"

enum : uint32_t {
  /* ra8_delay_ms(16) in the render loop spins on SysTick, which advances one
   * tick per chunk, so ~16 chunks == one loop iteration. Give the injected
   * tap many iterations to flow DOWN -> UP -> CLICKED -> tab switch -> repaint. */
  k_click_settle_chunks = 512U, 
};

RA8_INTERNAL static uint32_t internal_guard_env_u32(const char* name, uint32_t dflt)
{
  const char* const e = getenv(name);
  if (e == nullptr) {
    return dflt;
  }
  const long v = strtol(e, nullptr, (int)k_env_strtol_base);
  return (v > 0L) ? (uint32_t)v : dflt;
}

RA8_INTERNAL static uint32_t
internal_guard_env_u32_headless(const char* name, uint32_t dflt, const board_view_t* view)
{
  if (view != nullptr) {
    return dflt;
  }
  return internal_guard_env_u32(name, dflt);
}

RA8_INTERNAL static void internal_guard_read_wall(double* wall_s, bool* wall_guard_on)
{
  const char* const e_wall = getenv("RA8_EMU_WALL_S");
  if (e_wall == nullptr) {
    return;
  }
  const long v = strtol(e_wall, nullptr, (int)k_env_strtol_base);
  if (v > 0L) {
    *wall_s = (double)v;
  } else if (v == 0L) {
    *wall_guard_on = false; /* explicit opt-out: bound the run by chunks only */
  }
}

RA8_INTERNAL static void internal_guard_setup_record(const emu_run_cfg_t* cfg,
                                                     const board_view_t*  view,
                                                     uint32_t*            max_chunks)
{
  const char* const record_dir  = cfg->record_dir;
  const uint32_t    record_secs = cfg->record_secs;
  if ((record_dir != nullptr) && (record_secs > 0U) && (view == nullptr)) {
    *max_chunks = record_secs * (uint32_t)k_record_ms_per_sec;
  }
  if (record_dir != nullptr) {
    (void)mkdir(record_dir, (mode_t)k_record_dir_mode);
    (void)priv_emu_io_errf(
      "ra8_emulator: recording to %s/frame_NNNNNN.ppm (every %u chunks, ~%u fps)\n",
      record_dir,
      (unsigned)k_record_every,
      (unsigned)k_record_fps);
  }
}

RA8_INTERNAL static const char* internal_guard_read_stop_on(const board_view_t* view)
{
  const char* stop_on = getenv("RA8_EMU_STOP_ON");
  if ((stop_on != nullptr) && ((stop_on[0] == '\0') || (view != nullptr))) {
    stop_on = nullptr;
  }
  return stop_on;
}

RA8_INTERNAL static void internal_guard_apply_stop_pc(void)
{
  const char* const e_spc = getenv("RA8_EMU_STOP_PC");
  if (e_spc != nullptr) {
    const unsigned long v = strtoul(e_spc, nullptr, (int)k_env_strtol_base);
    emu_prof_set_stop_pc((uint32_t)(v & ~1UL)); /* clear the Thumb bit if supplied. */
  }
}

RA8_INTERNAL static void
internal_guard_read_prof_idle(uint32_t* insns, uint32_t* need, uint32_t* arm)
{
  enum : uint32_t {
    k_prof_idle_insns = 4000U, 
    k_prof_idle_need  = 600U,  
    k_prof_idle_arm   = 16U,   
  };
  *insns                 = (uint32_t)k_prof_idle_insns;
  *need                  = (uint32_t)k_prof_idle_need;
  *arm                   = (uint32_t)k_prof_idle_arm;
  const char* const e_pi = getenv("RA8_EMU_PROFILE_IDLE_INSNS");
  const char* const e_pn = getenv("RA8_EMU_PROFILE_IDLE_NEED");
  const char* const e_pa = getenv("RA8_EMU_PROFILE_IDLE_ARM");
  if (e_pi != nullptr) {
    *insns = (uint32_t)strtoul(e_pi, nullptr, (int)k_strtol_base10);
  }
  if (e_pn != nullptr) {
    *need = (uint32_t)strtoul(e_pn, nullptr, (int)k_strtol_base10);
  }
  if (e_pa != nullptr) {
    *arm = (uint32_t)strtoul(e_pa, nullptr, (int)k_strtol_base10);
  }
}
 
run_guards_t run_read_guards(const emu_run_cfg_t* cfg, const board_view_t* view)
{
  /* RA8_EMU_CLICK_SETTLE=N: widen the post-click drain for a tap that kicks off
   * a long operation (e.g. opening a big book from SD). Unset keeps the default. */
  const uint32_t click_settle_chunks =
    internal_guard_env_u32("RA8_EMU_CLICK_SETTLE", (uint32_t)k_click_settle_chunks);
 
  /* Chunked run: one SysTick (one ThreadX tick) per outer chunk. Headless runs
   * stop on a chunk budget + wall-clock guard; --view runs until the window is
   * closed. RA8_EMU_WALL_S / MAX_CHUNKS override the guards without a recompile
   * and have no effect in --view mode. */
  uint32_t max_chunks =
    (view != nullptr) ? (uint32_t)k_view_max_chunks : (uint32_t)k_run_max_chunks;
  double wall_s        = (double)k_run_wall_s;
  bool   wall_guard_on = true;
  internal_guard_read_wall(&wall_s, &wall_guard_on);
  max_chunks = internal_guard_env_u32_headless("RA8_EMU_MAX_CHUNKS", max_chunks, view);
  internal_guard_setup_record(cfg, view, &max_chunks);
 
  /* Headless-only early-stop knobs: idle steady-state (IDLE_STOP), USB device
   * CONFIGURED (USB_STOP) and USB host complete (USBH_STOP). Off (0) by default. */
  const uint32_t idle_stop_chunks = internal_guard_env_u32_headless("RA8_EMU_IDLE_STOP", 0U, view);
  const uint32_t usb_stop_settle  = internal_guard_env_u32_headless("RA8_EMU_USB_STOP", 0U, view);
  const uint32_t usbh_stop_settle = internal_guard_env_u32_headless("RA8_EMU_USBH_STOP", 0U, view);
  const char* const stop_on       = internal_guard_read_stop_on(view);
  internal_guard_apply_stop_pc();
  uint32_t prof_idle_insns = 0U;
  uint32_t prof_idle_need  = 0U;
  uint32_t prof_idle_arm   = 0U;
  internal_guard_read_prof_idle(&prof_idle_insns, &prof_idle_need, &prof_idle_arm);
 
  return (run_guards_t){
    .click_settle_chunks = click_settle_chunks,
    .max_chunks          = max_chunks,
    .wall_s              = wall_s,
    .wall_guard_on       = wall_guard_on,
    .idle_stop_chunks    = idle_stop_chunks,
    .usb_stop_settle     = usb_stop_settle,
    .usbh_stop_settle    = usbh_stop_settle,
    .stop_on             = stop_on,
    .prof_idle_insns     = prof_idle_insns,
    .prof_idle_need      = prof_idle_need,
    .prof_idle_arm       = prof_idle_arm,
  };
}