ascii_simd.c File Reference

⚡ Main SIMD ASCII rendering dispatcher with architecture detection and fallback handling More...

Go to the source code of this file.

Functions
size_t	write_rgb_triplet (uint8_t value, char *dst)
	Write decimal RGB triplet using dec3 cache.
void	init_default_luminance_palette (void)
	Initialize default luminance palette.
void	init_dec3 (void)
	Initialize decimal lookup table.
void	ascii_simd_init (void)
	Initialize SIMD subsystem.
ImageRGB	alloc_image (int w, int h)
	Allocate a new ImageRGB (RGB8 format)
void	str_init (Str *s)
	Initialize string buffer.
void	str_free (Str *s)
	Free string buffer.
void	str_reserve (Str *s, size_t need)
	Reserve space in string buffer.
void	str_append_bytes (Str *s, const void *src, size_t n)
	Append bytes to string buffer.
void	str_append_c (Str *s, char c)
	Append character to string buffer.
void	str_printf (Str *s, const char *fmt,...)
	Append formatted string to buffer.
void	convert_pixels_scalar (const rgb_pixel_t *pixels, char *ascii_chars, int count, const char luminance_palette[256])
	Convert pixels to ASCII (scalar fallback)
char *	convert_pixels_scalar_with_newlines (image_t *image, const char luminance_palette[256])
	Convert image to ASCII with newlines (scalar fallback)
char *	image_print_simd (image_t *image, const char *ascii_chars)
	Print image as ASCII using SIMD (monochrome)
void	print_simd_capabilities (void)
	Print detected SIMD capabilities.
simd_benchmark_t	benchmark_simd_conversion (int width, int height, int __attribute__((unused)) iterations)
simd_benchmark_t	benchmark_simd_color_conversion (int width, int height, int iterations, bool background_mode)
	Benchmark SIMD color conversion methods.
simd_benchmark_t	benchmark_simd_conversion_with_source (int width, int height, int iterations, bool background_mode, const image_t *source_image, bool use_256color)
	Benchmark SIMD conversion with source image.
simd_benchmark_t	benchmark_simd_color_conversion_with_source (int width, int height, int __attribute__((unused)) iterations, bool background_mode, const image_t *source_image, bool use_256color)

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

Detailed Description

⚡ Main SIMD ASCII rendering dispatcher with architecture detection and fallback handling

Definition in file ascii_simd.c.

Function Documentation

benchmark_simd_color_conversion_with_source()

simd_benchmark_t benchmark_simd_color_conversion_with_source	(	int	width,
		int	height,
		int __attribute__((unused))	iterations,
		bool	background_mode,
		const image_t *	source_image,
		bool	use_256color
	)

Definition at line 861 of file ascii_simd.c.

                                                                                {
  simd_benchmark_t result = {0};
  (void)use_256color; // Suppress unused parameter warning
 
  // Check for integer overflow in pixel count calculation
  size_t pixel_count;
  if (checked_size_mul((size_t)width, (size_t)height, &pixel_count) != ASCIICHAT_OK) {
    log_error("Image dimensions %d x %d too large (overflow)", width, height);
    return result;
  }
 
  size_t output_buffer_size = pixel_count * 30 + (size_t)width * 10;
 
  // Allocate buffers for benchmarking
  rgb_pixel_t *test_pixels;
  char *output_buffer;
  test_pixels = SAFE_CALLOC_SIMD(pixel_count, sizeof(rgb_pixel_t), rgb_pixel_t *);
  output_buffer = SAFE_MALLOC(output_buffer_size, char *);
 
  // Calculate adaptive iterations for color benchmarking (ignore passed iterations)
  int adaptive_iterations = calculate_adaptive_iterations(pixel_count, 10.0);
 
  const char *mode_str = background_mode ? "background" : "foreground";
 
  // Variables for webcam capture cleanup
 
  if (source_image) {
    printf("Using provided source image data for COLOR %s %dx%d benchmarking with %d iterations...\n", mode_str, width,
           height, adaptive_iterations);
 
    // Use provided source image - resize if needed
    if (source_image->w == width && source_image->h == height) {
      // Direct copy
      for (size_t i = 0; i < pixel_count; i++) {
        test_pixels[i].r = source_image->pixels[i].r;
        test_pixels[i].g = source_image->pixels[i].g;
        test_pixels[i].b = source_image->pixels[i].b;
      }
    } else {
      // Resize source image to target dimensions
      float x_ratio = (float)source_image->w / width;
      float y_ratio = (float)source_image->h / height;
 
      for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
          int src_x = (int)(x * x_ratio);
          int src_y = (int)(y * y_ratio);
 
          // Bounds check
          if (src_x >= source_image->w)
            src_x = source_image->w - 1;
          if (src_y >= source_image->h)
            src_y = source_image->h - 1;
 
          // Use size_t for index calculations to prevent integer overflow
          size_t src_idx = (size_t)src_y * (size_t)source_image->w + (size_t)src_x;
          size_t dst_idx = (size_t)y * (size_t)width + (size_t)x;
 
          test_pixels[dst_idx].r = source_image->pixels[src_idx].r;
          test_pixels[dst_idx].g = source_image->pixels[src_idx].g;
          test_pixels[dst_idx].b = source_image->pixels[src_idx].b;
        }
      }
    }
  } else {
    // No source image provided: use synthetic gradient data for consistent testing
    printf("Using synthetic gradient data for COLOR %s %dx%d benchmarking with %d iterations...\n", mode_str, width,
           height, adaptive_iterations);
 
    // NOLINTNEXTLINE(bugprone-random-generator-seed)
    srand(12345); // Consistent results across runs
    for (size_t i = 0; i < pixel_count; i++) {
      int x = i % width;
      int y = i / width;
      int base_r = (x * 255) / width;
      int base_g = (y * 255) / height;
      int base_b = ((x + y) * 127) / (width + height);
 
      int temp_r = base_r + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
      int temp_g = base_g + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
      int temp_b = base_b + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
 
      test_pixels[i].r = clamp_rgb(temp_r);
      test_pixels[i].g = clamp_rgb(temp_g);
      test_pixels[i].b = clamp_rgb(temp_b);
    }
  }
 
  printf("Benchmarking COLOR %s conversion using %d iterations...\n", mode_str, adaptive_iterations);
 
  // FIX #5: Prewarm 256-color caches to avoid first-frame penalty (~1.5-2MB cache build)
  prewarm_sgr256_fg_cache(); // Warmup 256-entry FG cache
  prewarm_sgr256_cache();    // Warmup 65,536-entry FG+BG cache
 
  // Benchmark scalar color conversion (pure conversion, no I/O)
  double start = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    image_t *test_image = image_new(width, height);
    if (test_image == NULL) {
      SAFE_FREE(test_pixels);
      SAFE_FREE(output_buffer);
      FATAL(ERROR_MEMORY, "Failed to allocate test_image in benchmark iteration %d", i);
    }
    memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
    char *result_ascii = ascii_convert(test_image, width, height, false, false, false, DEFAULT_ASCII_PALETTE,
                                       g_default_luminance_palette);
    if (result_ascii)
      SAFE_FREE(result_ascii);
    image_destroy(test_image);
  }
  result.scalar_time = get_time_seconds() - start;
 
  // Find best method -- default to scalar and let simd beat it.
  double best_time = result.scalar_time;
  result.best_method = "scalar";
 
#if SIMD_SUPPORT_SSE2
  start = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    image_t *test_image = image_new(width, height);
    if (test_image) {
      memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
      char *result_str =
          render_ascii_sse2_unified_optimized(test_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
      if (result_str)
        SAFE_FREE(result_str);
      image_destroy(test_image);
    }
  }
  result.sse2_time = get_time_seconds() - start;
#endif
 
#if SIMD_SUPPORT_SSSE3
  start = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    image_t *test_image = image_new(width, height);
    if (test_image) {
      memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
      char *result_str =
          render_ascii_ssse3_unified_optimized(test_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
      if (result_str)
        SAFE_FREE(result_str);
      image_destroy(test_image);
    }
  }
  result.ssse3_time = get_time_seconds() - start;
#endif
 
#if SIMD_SUPPORT_AVX2
  start = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    image_t *test_image = image_new(width, height);
    if (test_image) {
      memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
      char *result_str =
          render_ascii_avx2_unified_optimized(test_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
      if (result_str)
        SAFE_FREE(result_str);
      image_destroy(test_image);
    }
  }
  result.avx2_time = get_time_seconds() - start;
#endif
 
#if SIMD_SUPPORT_NEON
  start = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    // Create temporary image for unified function
    image_t temp_image = {.pixels = test_pixels, .w = width, .h = height, .alloc_method = IMAGE_ALLOC_SIMD};
    char *result =
        render_ascii_neon_unified_optimized(&temp_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
    if (result)
      SAFE_FREE(result);
  }
  result.neon_time = get_time_seconds() - start;
#endif
 
#if SIMD_SUPPORT_SVE
  start = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    // Create temporary image for unified function
    image_t temp_image = {.pixels = test_pixels, .w = width, .h = height, .alloc_method = IMAGE_ALLOC_SIMD};
    char *result =
        render_ascii_sve_unified_optimized(&temp_image, background_mode, use_256color, DEFAULT_ASCII_PALETTE);
    if (result)
      SAFE_FREE(result);
  }
  result.sve_time = get_time_seconds() - start;
#endif
 
#if SIMD_SUPPORT_SSE2
  if (result.sse2_time > 0 && result.sse2_time < best_time) {
    best_time = result.sse2_time;
    result.best_method = "SSE2";
  }
#endif
 
#if SIMD_SUPPORT_SSSE3
  if (result.ssse3_time > 0 && result.ssse3_time < best_time) {
    best_time = result.ssse3_time;
    result.best_method = "SSSE3";
  }
#endif
 
#if SIMD_SUPPORT_AVX2
  if (result.avx2_time > 0 && result.avx2_time < best_time) {
    best_time = result.avx2_time;
    result.best_method = "AVX2";
  }
#endif
 
#if SIMD_SUPPORT_NEON
  if (result.neon_time > 0 && result.neon_time < best_time) {
    best_time = result.neon_time;
    result.best_method = "NEON";
  }
#endif
 
  // Normalize timing results by iteration count to get per-frame times
  result.scalar_time /= adaptive_iterations;
  if (result.sse2_time > 0)
    result.sse2_time /= adaptive_iterations;
  if (result.ssse3_time > 0)
    result.ssse3_time /= adaptive_iterations;
  if (result.avx2_time > 0)
    result.avx2_time /= adaptive_iterations;
  if (result.neon_time > 0)
    result.neon_time /= adaptive_iterations;
  // Recalculate best time after normalization
  best_time = result.scalar_time;
 
#if SIMD_SUPPORT_SSE2
  if (result.sse2_time > 0 && result.sse2_time < best_time)
    best_time = result.sse2_time;
#endif
#if SIMD_SUPPORT_SSSE3
  if (result.ssse3_time > 0 && result.ssse3_time < best_time)
    best_time = result.ssse3_time;
#endif
#if SIMD_SUPPORT_AVX2
  if (result.avx2_time > 0 && result.avx2_time < best_time)
    best_time = result.avx2_time;
#endif
#if SIMD_SUPPORT_NEON
  if (result.neon_time > 0 && result.neon_time < best_time)
    best_time = result.neon_time;
#endif
#if SIMD_SUPPORT_SVE
  if (result.sve_time > 0 && result.sve_time < best_time)
    best_time = result.sve_time;
#endif
 
  result.speedup_best = result.scalar_time / best_time;
 
  printf("------------\n");
  printf("scalar: %f\n", result.scalar_time);
  if (result.sse2_time > 0)
    printf("SSE2: %f\n", result.sse2_time);
  if (result.ssse3_time > 0)
    printf("SSSE3: %f\n", result.ssse3_time);
  if (result.avx2_time > 0)
    printf("avx2: %f\n", result.avx2_time);
  if (result.neon_time > 0)
    printf("neon: %f\n", result.neon_time);
  if (result.sve_time > 0)
    printf("sve: %f\n", result.sve_time);
  printf("Best method: %s, time: %f (%.2fx speedup (<1.0 = bad))\n", result.best_method, best_time,
         result.speedup_best);
  printf("------------\n");
 
  // Frame data already cleaned up in webcam capture section
  SAFE_FREE(test_pixels);
  SAFE_FREE(output_buffer);
 
  return result;
}

References ascii_convert(), ASCIICHAT_OK, simd_benchmark_t::avx2_time, simd_benchmark_t::best_method, DEFAULT_ASCII_PALETTE, ERROR_MEMORY, FATAL, g_default_luminance_palette, image_t::h, IMAGE_ALLOC_SIMD, image_destroy(), image_new(), log_error, simd_benchmark_t::neon_time, image_t::pixels, prewarm_sgr256_cache(), prewarm_sgr256_fg_cache(), SAFE_CALLOC_SIMD, SAFE_FREE, SAFE_MALLOC, simd_benchmark_t::scalar_time, simd_benchmark_t::speedup_best, simd_benchmark_t::sse2_time, simd_benchmark_t::ssse3_time, simd_benchmark_t::sve_time, and image_t::w.

benchmark_simd_conversion()

simd_benchmark_t benchmark_simd_conversion	(	int	width,
		int	height,
		int __attribute__((unused))	iterations
	)

Definition at line 334 of file ascii_simd.c.

                                                                                                          {
  simd_benchmark_t result = {0};
 
  // Check for integer overflow in pixel count calculation
  size_t pixel_count;
  if (checked_size_mul((size_t)width, (size_t)height, &pixel_count) != ASCIICHAT_OK) {
    log_error("Image dimensions %d x %d too large (overflow)", width, height);
    return result;
  }
 
  // Generate test data and test image
  rgb_pixel_t *test_pixels;
  char *output_buffer;
  test_pixels = SAFE_CALLOC_SIMD(pixel_count, sizeof(rgb_pixel_t), rgb_pixel_t *);
  output_buffer = SAFE_MALLOC(pixel_count, char *);
 
  // Create test image for new image-based functions
  image_t *test_image = image_new(width, height);
  if (!test_image) {
    SAFE_FREE(test_pixels);
    SAFE_FREE(output_buffer);
    return result;
  }
 
  // Use synthetic data for consistent cross-platform testing
  printf("Using synthetic gradient data for consistent benchmarking\n");
  srand(12345); // Consistent results across runs // NOLINT(cert-msc32-c,cert-msc51-cpp,bugprone-random-generator-seed)
  for (size_t i = 0; i < pixel_count; i++) {
    int x = i % width;
    int y = i / width;
    // Create realistic gradient pattern with some variation
    int base_r = (x * 255) / width;
    int base_g = (y * 255) / height;
    int base_b = ((x + y) * 127) / (width + height);
 
    // Add small random variation to make it realistic
    int temp_r = base_r + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
    int temp_g = base_g + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
    int temp_b = base_b + (rand() % 32 - 16); // NOLINT(cert-msc30-c,cert-msc50-cpp)
 
    test_pixels[i].r = clamp_rgb(temp_r);
    test_pixels[i].g = clamp_rgb(temp_g);
    test_pixels[i].b = clamp_rgb(temp_b);
  }
 
  // Copy test data to test image pixels
  memcpy(test_image->pixels, test_pixels, pixel_count * sizeof(rgb_pixel_t));
 
  // Calculate adaptive iterations for reliable timing
  int adaptive_iterations = calculate_adaptive_iterations(pixel_count, 10.0);
  printf("Benchmarking MONO %dx%d (%zu pixels) using %d adaptive iterations (ignoring passed iterations)...\n", width,
         height, pixel_count, adaptive_iterations);
 
  // Benchmark scalar using image-based API
  ensure_default_palette_ready();
  double start_mono = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = image_print(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.scalar_time = (get_time_seconds() - start_mono) / adaptive_iterations;
 
#if SIMD_SUPPORT_SSE2
  // Benchmark SSE2 using new image-based timing function
  // Benchmark SSE2 monochrome rendering
  double start_sse2 = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = render_ascii_image_monochrome_sse2(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.sse2_time = (get_time_seconds() - start_sse2) / adaptive_iterations;
#endif
 
#if SIMD_SUPPORT_SSSE3
  // Benchmark SSSE3 using new image-based timing function
  // Benchmark SSSE3 monochrome rendering
  double start_ssse3 = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = render_ascii_image_monochrome_ssse3(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.ssse3_time = (get_time_seconds() - start_ssse3) / adaptive_iterations;
#endif
 
#if SIMD_SUPPORT_AVX2
  // Benchmark AVX2 using optimized single-pass implementation
  // Benchmark AVX2 monochrome rendering
  double start_avx2 = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = render_ascii_image_monochrome_avx2(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.avx2_time = (get_time_seconds() - start_avx2) / adaptive_iterations;
#endif
 
#if SIMD_SUPPORT_NEON
  // Benchmark NEON using new image-based timing function
  // TODO: Update benchmark to use custom palette testing
  // Benchmark NEON monochrome rendering
  double start_neon = get_time_seconds();
  for (int i = 0; i < adaptive_iterations; i++) {
    char *result_str = render_ascii_image_monochrome_neon(test_image, DEFAULT_ASCII_PALETTE);
    if (result_str)
      SAFE_FREE(result_str);
  }
  result.neon_time = (get_time_seconds() - start_neon) / adaptive_iterations;
#endif
 
#if SIMD_SUPPORT_SVE
  // SVE benchmarking disabled - function removed
  result.sve_time = 0.0;
#endif
 
  // Find best method
  double best_time = result.scalar_time;
  result.best_method = "scalar";
 
#if SIMD_SUPPORT_SSE2
  if (result.sse2_time > 0 && result.sse2_time < best_time) {
    best_time = result.sse2_time;
    result.best_method = "SSE2";
  }
#endif
 
#if SIMD_SUPPORT_SSSE3
  if (result.ssse3_time > 0 && result.ssse3_time < best_time) {
    best_time = result.ssse3_time;
    result.best_method = "SSSE3";
  }
#endif
 
#if SIMD_SUPPORT_AVX2
  if (result.avx2_time > 0 && result.avx2_time < best_time) {
    best_time = result.avx2_time;
    result.best_method = "AVX2";
  }
#endif
 
#if SIMD_SUPPORT_NEON
  if (result.neon_time > 0 && result.neon_time < best_time) {
    best_time = result.neon_time;
    result.best_method = "NEON";
  }
#endif
 
  result.speedup_best = result.scalar_time / best_time;
 
#if SIMD_SUPPORT_SVE
  if (result.sve_time > 0 && result.sve_time < best_time) {
    best_time = result.sve_time;
    result.best_method = "SVE";
  }
#endif
 
  // Cleanup
  image_destroy(test_image);
  SAFE_FREE(test_pixels);
  SAFE_FREE(output_buffer);
 
  return result;
}

References ASCIICHAT_OK, simd_benchmark_t::avx2_time, simd_benchmark_t::best_method, DEFAULT_ASCII_PALETTE, image_destroy(), image_new(), image_print(), log_error, simd_benchmark_t::neon_time, image_t::pixels, SAFE_CALLOC_SIMD, SAFE_FREE, SAFE_MALLOC, simd_benchmark_t::scalar_time, simd_benchmark_t::speedup_best, simd_benchmark_t::sse2_time, simd_benchmark_t::ssse3_time, and simd_benchmark_t::sve_time.