Benchmark: WebAssembly 2.0 vs Native Code for Image Processing – 10% Slower

#include 
#include 
#include 
#include 
#include 
#include 

// Custom error handler to avoid libjpeg's default exit() behavior
struct error_mgr {
    struct jpeg_error_mgr pub;
    jmp_buf setjmp_buffer;
};

void error_exit(j_common_ptr cinfo) {
    struct error_mgr *err = (struct error_mgr *)cinfo->err;
    (*cinfo->err->output_message)(cinfo);
    longjmp(err->setjmp_buffer, 1);
}

// Resize 4K JPEG to 1080p using libjpeg-turbo
int resize_jpeg(const char *input_path, const char *output_path, int target_width, int target_height) {
    struct jpeg_decompress_struct cinfo;
    struct error_mgr jerr;
    FILE *input_file = NULL, *output_file = NULL;
    JSAMPARRAY buffer;
    int row_stride;

    // Initialize decompress struct
    cinfo.err = jpeg_std_error(&jerr.pub);
    jerr.pub.error_exit = error_exit;
    if (setjmp(jerr.setjmp_buffer)) {
        fprintf(stderr, "JPEG decompression error\n");
        jpeg_destroy_decompress(&cinfo);
        if (input_file) fclose(input_file);
        if (output_file) fclose(output_file);
        return -1;
    }

    jpeg_create_decompress(&cinfo);
    input_file = fopen(input_path, "rb");
    if (!input_file) {
        fprintf(stderr, "Failed to open input file %s\n", input_path);
        jpeg_destroy_decompress(&cinfo);
        return -1;
    }
    jpeg_stdio_src(&cinfo, input_file);

    // Read JPEG header
    jpeg_read_header(&cinfo, TRUE);
    // Set target scaling (4K is 3840x2160, target 1920x1080 is 0.5x scale)
    cinfo.scale_num = target_width;
    cinfo.scale_denom = cinfo.image_width;
    jpeg_start_decompress(&cinfo);

    row_stride = cinfo.output_width * cinfo.output_components;
    buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr)&cinfo, JPOOL_IMAGE, row_stride, 1);

    // Initialize compress struct for output
    struct jpeg_compress_struct cinfo_out;
    struct jpeg_error_mgr jerr_out;
    cinfo_out.err = jpeg_std_error(&jerr_out);
    jpeg_create_compress(&cinfo_out);
    output_file = fopen(output_path, "wb");
    if (!output_file) {
        fprintf(stderr, "Failed to open output file %s\n", output_path);
        jpeg_destroy_decompress(&cinfo);
        fclose(input_file);
        return -1;
    }
    jpeg_stdio_dest(&cinfo_out, output_file);
    cinfo_out.image_width = cinfo.output_width;
    cinfo_out.image_height = cinfo.output_height;
    cinfo_out.input_components = cinfo.output_components;
    cinfo_out.in_color_space = cinfo.out_color_space;
    jpeg_set_defaults(&cinfo_out);
    jpeg_set_quality(&cinfo_out, 85, TRUE);
    jpeg_start_compress(&cinfo_out, TRUE);

    // Write resized rows
    while (cinfo.output_scanline < cinfo.output_height) {
        jpeg_read_scanlines(&cinfo, buffer, 1);
        jpeg_write_scanlines(&cinfo_out, buffer, 1);
    }

    // Cleanup
    jpeg_finish_compress(&cinfo_out);
    jpeg_destroy_compress(&cinfo_out);
    fclose(output_file);
    jpeg_finish_decompress(&cinfo);
    jpeg_destroy_decompress(&cinfo);
    fclose(input_file);
    return 0;
}

int main(int argc, char **argv) {
    if (argc != 4) {
        fprintf(stderr, "Usage: %s   \n", argv[0]);
        return 1;
    }
    const char *input = argv[1];
    const char *output = argv[2];
    int iterations = atoi(argv[3]);
    if (iterations <= 0) {
        fprintf(stderr, "Iterations must be positive integer\n");
        return 1;
    }

    clock_t start = clock();
    for (int i = 0; i < iterations; i++) {
        if (resize_jpeg(input, output, 1920, 1080) != 0) {
            fprintf(stderr, "Resize failed on iteration %d\n", i);
            return 1;
        }
    }
    clock_t end = clock();
    double elapsed = (double)(end - start) / CLOCKS_PER_SEC;
    printf("Native C: %d iterations in %.2fs (%.2f ops/sec)\n", iterations, elapsed, iterations / elapsed);
    return 0;
}

// Wasm 2.0 Gaussian Blur Implementation (3x3 kernel, 4K RGB image)
// Compile with: clang -O3 -target wasm32-wasi -mattr=+simd128 -o gaussian_blur.wasm gaussian_blur.c -nostdlib -Wl,--export-dynamic -Wl,--no-entry
// WASI SDK 18.0+ required

#include 
#include 

// Export memory for host runtime to access pixel data
__attribute__((export_name("memory"))) uint8_t memory[3840 * 2160 * 3]; // 4K RGB buffer

// Gaussian 3x3 kernel weights (normalized to 16 for integer arithmetic)
static const uint16_t kernel[9] = {1, 2, 1, 2, 4, 2, 1, 2, 1};
static const uint16_t kernel_sum = 16;

// Apply 3x3 Gaussian blur to RGB image
// Parameters: width (i32), height (i32), input_offset (i32), output_offset (i32)
__attribute__((export_name("apply_blur"))) void apply_blur(int32_t width, int32_t height, int32_t input_offset, int32_t output_offset) {
    // Validate inputs
    if (width <= 2 || height <= 2) return;
    if (input_offset < 0 || output_offset < 0) return;
    if (input_offset + (width * height * 3) > (int32_t)sizeof(memory)) return;
    if (output_offset + (width * height * 3) > (int32_t)sizeof(memory)) return;

    // Process each pixel (skip border pixels)
    for (int32_t y = 1; y < height - 1; y++) {
        for (int32_t x = 1; x < width - 1; x++) {
            // Process each color channel (R, G, B)
            for (int32_t c = 0; c < 3; c++) {
                uint16_t sum = 0;
                // Convolve with 3x3 kernel
                for (int32_t ky = -1; ky <= 1; ky++) {
                    for (int32_t kx = -1; kx <= 1; kx++) {
                        int32_t px = x + kx;
                        int32_t py = y + ky;
                        int32_t pixel_offset = input_offset + (py * width * 3) + (px * 3) + c;
                        sum += memory[pixel_offset] * kernel[(ky + 1) * 3 + (kx + 1)];
                    }
                }
                // Normalize and clamp to 0-255
                uint8_t result = (sum / kernel_sum) > 255 ? 255 : (sum / kernel_sum);
                int32_t out_offset = output_offset + (y * width * 3) + (x * 3) + c;
                memory[out_offset] = result;
            }
        }
    }
}

// Helper to zero out border pixels in output (avoid uninitialized data)
__attribute__((export_name("clear_borders"))) void clear_borders(int32_t width, int32_t height, int32_t output_offset) {
    if (width <= 0 || height <= 0 || output_offset < 0) return;
    if (output_offset + (width * height * 3) > (int32_t)sizeof(memory)) return;

    // Top and bottom borders
    for (int32_t x = 0; x < width; x++) {
        for (int32_t c = 0; c < 3; c++) {
            // Top border (y=0)
            int32_t top_offset = output_offset + (0 * width * 3) + (x * 3) + c;
            memory[top_offset] = 0;
            // Bottom border (y=height-1)
            int32_t bottom_offset = output_offset + ((height - 1) * width * 3) + (x * 3) + c;
            memory[bottom_offset] = 0;
        }
    }
    // Left and right borders
    for (int32_t y = 0; y < height; y++) {
        for (int32_t c = 0; c < 3; c++) {
            // Left border (x=0)
            int32_t left_offset = output_offset + (y * width * 3) + (0 * 3) + c;
            memory[left_offset] = 0;
            // Right border (x=width-1)
            int32_t right_offset = output_offset + (y * width * 3) + ((width - 1) * 3) + c;
            memory[right_offset] = 0;
        }
    }
}

// Native Rust Gaussian Blur Implementation (3x3 kernel, 4K RGB)
// Compile with: rustc -O -C target-cpu=native gaussian_blur.rs
// Rust 1.76+ required

use std::error::Error;
use std::fs;

#[derive(Debug)]
struct ImageBuffer {
    width: usize,
    height: usize,
    pixels: Vec, // RGB: 3 bytes per pixel
}

impl ImageBuffer {
    fn new(width: usize, height: usize) -> Result {
        if width == 0 || height == 0 {
            return Err("Width and height must be non-zero");
        }
        let pixels = vec![0u8; width * height * 3];
        Ok(Self { width, height, pixels })
    }

    fn from_file(path: &str) -> Result> {
        let data = fs::read(path)?;
        // Parse minimal BMP header (24-bit, uncompressed) for demo purposes
        if data.len() < 54 {
            return Err("Invalid BMP file: too small".into());
        }
        let width = u32::from_le_bytes([data[18], data[19], data[20], data[21]]) as usize;
        let height = u32::from_le_bytes([data[22], data[23], data[24], data[25]]) as usize;
        let pixel_data_offset = u32::from_le_bytes([data[10], data[11], data[12], data[13]]) as usize;
        let pixels = data[pixel_data_offset..].to_vec();
        if pixels.len() != width * height * 3 {
            return Err("Pixel data size mismatch".into());
        }
        Ok(Self { width, height, pixels })
    }

    fn apply_gaussian_blur(&mut self) -> Result<(), &'static str> {
        if self.width <= 2 || self.height <= 2 {
            return Err("Image too small for 3x3 blur");
        }
        let mut output = vec![0u8; self.pixels.len()];
        let kernel: [u16; 9] = [1, 2, 1, 2, 4, 2, 1, 2, 1];
        let kernel_sum: u16 = 16;

        for y in 1..self.height - 1 {
            for x in 1..self.width - 1 {
                for c in 0..3 {
                    let mut sum: u16 = 0;
                    for ky in -1..=1 {
                        for kx in -1..=1 {
                            let px = (x as i32 + kx) as usize;
                            let py = (y as i32 + ky) as usize;
                            let idx = (py * self.width + px) * 3 + c;
                            sum += self.pixels[idx] as u16 * kernel[(ky + 1) as usize * 3 + (kx + 1) as usize];
                        }
                    }
                    let result = (sum / kernel_sum).clamp(0, 255) as u8;
                    let out_idx = (y * self.width + x) * 3 + c;
                    output[out_idx] = result;
                }
            }
        }
        // Copy borders from input (unchanged)
        for y in 0..self.height {
            for x in 0..self.width {
                if y == 0 || y == self.height - 1 || x == 0 || x == self.width - 1 {
                    for c in 0..3 {
                        let idx = (y * self.width + x) * 3 + c;
                        output[idx] = self.pixels[idx];
                    }
                }
            }
        }
        self.pixels = output;
        Ok(())
    }
}

fn main() -> Result<(), Box> {
    let args: Vec = std::env::args().collect();
    if args.len() != 4 {
        eprintln!("Usage: {}   ", args[0]);
        std::process::exit(1);
    }
    let input_path = &args[1];
    let output_path = &args[2];
    let iterations: usize = args[3].parse()?;
    if iterations == 0 {
        eprintln!("Iterations must be positive");
        std::process::exit(1);
    }

    let start = std::time::Instant::now();
    for _ in 0..iterations {
        let mut img = ImageBuffer::from_file(input_path)?;
        img.apply_gaussian_blur()?;
        // Write output BMP (simplified for demo)
        let mut out_data = vec![0u8; 54 + img.pixels.len()];
        // BMP header (24-bit, uncompressed)
        out_data[0] = b'B';
        out_data[1] = b'M';
        let file_size = (54 + img.pixels.len()) as u32;
        out_data[2..6].copy_from_slice(&file_size.to_le_bytes());
        out_data[10] = 54;
        out_data[14] = 40;
        out_data[18..22].copy_from_slice(&(img.width as u32).to_le_bytes());
        out_data[22..26].copy_from_slice(&(img.height as u32).to_le_bytes());
        out_data[26] = 1;
        out_data[28] = 24;
        out_data[54..].copy_from_slice(&img.pixels);
        fs::write(output_path, out_data)?;
    }
    let elapsed = start.elapsed();
    println!(
        "Native Rust: {} iterations in {:.2}s ({:.2} ops/sec)",
        iterations,
        elapsed.as_secs_f64(),
        iterations as f64 / elapsed.as_secs_f64()
    );
    Ok(())
}

clang -O3 -target wasm32-wasi -mattr=+simd128 -o blur.wasm blur.c

__attribute__((export_name("memory"))) uint8_t shared_mem[3840 * 2160 * 3];

wasmtime --profile=wasm-profiler gaussian_blur.wasm apply_blur 3840 2160 0 0