common.c File Reference

Go to the source code of this file.

Functions
void	build_ramp64 (uint8_t ramp64[RAMP64_SIZE], const char *ascii_chars)
double	calculate_cache_eviction_score (uint64_t last_access_time, uint32_t access_count, uint64_t creation_time, uint64_t current_time)
utf8_palette_cache_t *	get_utf8_palette_cache (const char *ascii_chars)
	Get UTF-8 palette cache for a character set.
void	build_utf8_luminance_cache (const char *ascii_chars, utf8_char_t cache[256])
	Build UTF-8 luminance cache for all 256 levels.
void	build_utf8_ramp64_cache (const char *ascii_chars, utf8_char_t cache64[64], uint8_t char_index_ramp[ASCII_LUMINANCE_LEVELS])
void	simd_caches_destroy_all (void)
	Destroy all SIMD caches (palette and other caches).
void	init_dec3 (void)
	Initialize decimal-to-ASCII cache (0-255 → "0" to "255").
void	init_default_luminance_palette (void)
	Initialize default luminance palette.
void	ascii_simd_init (void)
	Initialize SIMD subsystem.

Variables
global_dec3_cache_t	g_dec3_cache = {0}
	Global decimal cache instance.
char	g_default_luminance_palette [ASCII_LUMINANCE_LEVELS] = {0}
	Default luminance palette (256 characters).

Function Documentation

build_ramp64()

void build_ramp64	(	uint8_t	ramp64[RAMP64_SIZE],
		const char *	ascii_chars )

Definition at line 42 of file video/ascii/common.c.

                                                                        {
  if (!ascii_chars) {
    // Fallback to space character
    for (int i = 0; i < RAMP64_SIZE; i++) {
      ramp64[i] = ' ';
    }
    return;
  }
 
  // Use UTF-8 palette functions for proper character handling
  utf8_palette_t *utf8_pal = utf8_palette_create(ascii_chars);
  if (!utf8_pal) {
    // Fallback to space character
    for (int i = 0; i < RAMP64_SIZE; i++) {
      ramp64[i] = ' ';
    }
    return;
  }
 
  size_t char_count = utf8_palette_get_char_count(utf8_pal);
  if (char_count == 0) {
    // No valid characters found, use space
    for (int i = 0; i < RAMP64_SIZE; i++) {
      ramp64[i] = ' ';
    }
    utf8_palette_destroy(utf8_pal);
    return;
  }
 
  // Build the ramp64 lookup using UTF-8 character indices
  for (int i = 0; i < RAMP64_SIZE; i++) {
    // Map 0-63 to 0-(char_count-1) using proper character indexing
    size_t char_idx = (i * (char_count - 1) + (RAMP64_SIZE - 1) / 2) / (RAMP64_SIZE - 1);
    if (char_idx >= char_count) {
      char_idx = char_count - 1;
    }
 
    // Get the first byte of the character at this character index
    const utf8_char_info_t *char_info = utf8_palette_get_char(utf8_pal, char_idx);
    if (char_info) {
      ramp64[i] = (uint8_t)char_info->bytes[0];
    } else {
      ramp64[i] = ' '; // Fallback
    }
  }
 
  utf8_palette_destroy(utf8_pal);
}

References utf8_char_info_t::bytes, RAMP64_SIZE, utf8_palette_create(), utf8_palette_destroy(), utf8_palette_get_char(), and utf8_palette_get_char_count().

build_utf8_ramp64_cache()

void build_utf8_ramp64_cache	(	const char *	ascii_chars,
		utf8_char_t	cache64[64],
		uint8_t	char_index_ramp[ASCII_LUMINANCE_LEVELS] )

Definition at line 449 of file video/ascii/common.c.

                                                                              {
  if (!ascii_chars || !cache64 || !char_index_ramp)
    return;
 
  // Reuse the luminance cache building logic but for 64 entries
  // (Same UTF-8 parsing as above, but map to 64 entries instead of 256)
 
  // Parse characters (same as above)
  typedef struct {
    const char *start;
    int byte_len;
  } char_info_t;
 
  char_info_t char_infos[256];
  int char_count = 0;
  const char *p = ascii_chars;
 
  while (*p && char_count < 255) {
    char_infos[char_count].start = p;
 
    if ((*p & 0xE0) == 0xC0) {
      char_infos[char_count].byte_len = 2;
      p += 2;
    } else if ((*p & 0xF0) == 0xE0) {
      char_infos[char_count].byte_len = 3;
      p += 3;
    } else if ((*p & 0xF8) == 0xF0) {
      char_infos[char_count].byte_len = 4;
      p += 4;
    } else {
      // ASCII characters (0x00-0x7F) and invalid sequences: treat as single byte
      char_infos[char_count].byte_len = 1;
      p++;
    }
    char_count++;
  }
 
  // Handle empty string case
  if (char_count == 0)
    return;
 
  // Build 64-entry cache and index ramp
  for (int i = 0; i < 64; i++) {
    int char_idx = char_count > 1 ? (i * (char_count - 1) + 31) / 63 : 0;
    if (char_idx >= char_count)
      char_idx = char_count - 1;
 
    // Store character index for SIMD lookup
    char_index_ramp[i] = (uint8_t)char_idx;
 
    // Cache UTF-8 character
    cache64[i].byte_len = char_infos[char_idx].byte_len;
    memcpy(cache64[i].utf8_bytes, char_infos[char_idx].start, char_infos[char_idx].byte_len);
    if (cache64[i].byte_len < 4) {
      cache64[i].utf8_bytes[cache64[i].byte_len] = '\0';
    }
  }
}

References ASCII_LUMINANCE_LEVELS, utf8_char_t::byte_len, and utf8_char_t::utf8_bytes.

Referenced by get_utf8_palette_cache().

calculate_cache_eviction_score()

double calculate_cache_eviction_score	(	uint64_t	last_access_time,
		uint32_t	access_count,
		uint64_t	creation_time,
		uint64_t	current_time )

Definition at line 92 of file video/ascii/common.c.

                                                             {
  // Protect against unsigned underflow if times are inconsistent (clock adjustments, etc.)
  uint64_t age_ns = (current_time >= last_access_time) ? (current_time - last_access_time) : 0;
  uint64_t total_age_ns = (current_time >= creation_time) ? (current_time - creation_time) : 0;
 
  uint64_t age_seconds = age_ns / NS_PER_SEC_INT;
  uint64_t total_age_seconds = total_age_ns / NS_PER_SEC_INT;
 
  // Frequency factor: high-use palettes get protection (logarithmic scaling)
  double frequency_factor = 1.0 + log10(1.0 + access_count);
 
  // Aging factor: frequency bonus decays over time (5-minute half-life)
  double aging_factor = exp(-(double)age_seconds / CACHE_FREQUENCY_DECAY_TIME);
 
  // Recent access bonus: strong protection for recently used (1-minute protection)
  double recency_bonus = exp(-(double)age_seconds / CACHE_RECENCY_SCALE);
 
  // Cache lifetime penalty: prevent immortal caches (1-hour max lifetime)
  double lifetime_penalty = total_age_seconds > CACHE_MAX_LIFETIME ? 0.5 : 1.0;
 
  // Final score: higher = keep longer
  return (frequency_factor * aging_factor + recency_bonus) * lifetime_penalty;
}

References CACHE_FREQUENCY_DECAY_TIME, CACHE_MAX_LIFETIME, CACHE_RECENCY_SCALE, and NS_PER_SEC_INT.

Referenced by get_utf8_palette_cache().