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[256])
	Build UTF-8 ramp64 cache and character index ramp.
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 [256] = {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 41 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().

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 91 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().