Demystify when in WebAssembly vs Rust: What You Need to Know

// Rust 1.79 Native HTTP Server Benchmark Example
// Dependencies (Cargo.toml):
// [dependencies]
// axum = "0.7.5"
// tokio = { version = "1.38.0", features = ["full"] }
// tower = "0.4.13"
// tower-http = { version = "0.5.2", features = ["full"] }
// serde = { version = "1.0.203", features = ["derive"] }
// serde_json = "1.0.117"

use axum::{
    extract::Path,
    http::StatusCode,
    response::Json,
    routing::get,
    Router,
};
use serde::{Deserialize, Serialize};
use tower_http::trace::TraceLayer;

// Define a serializable response struct with error handling
#[derive(Serialize, Deserialize)]
struct HealthResponse {
    status: String,
    version: String,
    uptime_ms: u64,
}

#[derive(Serialize, Deserialize)]
struct ErrorResponse {
    code: u16,
    message: String,
}

// In-memory uptime tracker (simplified for example)
static START_TIME: std::sync::LazyLock = std::sync::LazyLock::new(std::time::Instant::now);

/// Handler for health check endpoint with error handling
async fn health_check() -> Result, (StatusCode, Json)> {
    let uptime = START_TIME.elapsed().as_millis() as u64;
    let response = HealthResponse {
        status: "healthy".to_string(),
        version: env!("CARGO_PKG_VERSION").to_string(),
        uptime_ms: uptime,
    };
    Ok(Json(response))
}

/// Handler for user fetch endpoint (simulated)
async fn get_user(Path(user_id): Path) -> Result, (StatusCode, Json)> {
    if user_id.is_empty() || user_id.len() > 36 {
        let error = ErrorResponse {
            code: 400,
            message: "Invalid user ID: must be non-empty and ≤36 characters".to_string(),
        };
        return Err((StatusCode::BAD_REQUEST, Json(error)));
    }

    // Simulate database fetch with error handling
    if user_id == "error" {
        let error = ErrorResponse {
            code: 500,
            message: "Simulated database connection failure".to_string(),
        };
        return Err((StatusCode::INTERNAL_SERVER_ERROR, Json(error)));
    }

    let user = serde_json::json!({
        "id": user_id,
        "name": "Alice Smith",
        "email": "alice@example.com",
        "created_at": "2024-01-15T08:30:00Z"
    });
    Ok(Json(user))
}

#[tokio::main]
async fn main() {
    // Initialize tracing for observability
    tracing_subscriber::fmt::init();

    // Build router with endpoints
    let app = Router::new()
        .route("/health", get(health_check))
        .route("/users/:user_id", get(get_user))
        .layer(TraceLayer::new_for_http());

    // Bind to address with error handling
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await;
    let listener = match listener {
        Ok(l) => l,
        Err(e) => {
            eprintln!("Failed to bind to port 3000: {}", e);
            std::process::exit(1);
        }
    };

    println!("Rust native server running on http://0.0.0.0:3000");
    if let Err(e) = axum::serve(listener, app).await {
        eprintln!("Server crashed: {}", e);
        std::process::exit(1);
    }
}

// Rust to Wasm HTTP Server (wasm32-wasi target) Example
// Compile with: cargo build --target wasm32-wasi --release
// Run with: wasmtime --dir=. target/wasm32-wasi/release/wasm-server.wasm
// Dependencies (Cargo.toml):
// [dependencies]
// wasi-http = { version = "0.2.0", features = ["http-router"] }
// serde = { version = "1.0.203", features = ["derive"] }
// serde_json = "1.0.117"
// anyhow = "1.0.86"
// thiserror = "1.0.61"

use serde::{Deserialize, Serialize};
use wasi_http::{
    router::{self, Router},
    HttpRequest, HttpResponse,
};

// Response structs matching native example for parity
#[derive(Serialize, Deserialize)]
struct HealthResponse {
    status: String,
    version: String,
    uptime_ms: u64,
}

#[derive(Serialize, Deserialize)]
struct ErrorResponse {
    code: u16,
    message: String,
}

// Uptime tracker using WASI monotonic clock
fn get_uptime_ms() -> u64 {
    // WASI 0.2.0 uses monotonic-clock for portable time tracking
    let now = wasi::clocks::monotonic_clock::now();
    // Assume start time is 0 for simplified example; in production, persist start time
    now / 1_000_000 // Convert nanoseconds to milliseconds
}

/// Health check handler for Wasm server
fn health_handler(_req: HttpRequest) -> HttpResponse {
    let response = HealthResponse {
        status: "healthy".to_string(),
        version: env!("CARGO_PKG_VERSION").to_string(),
        uptime_ms: get_uptime_ms(),
    };

    match serde_json::to_vec(&response) {
        Ok(body) => HttpResponse::ok()
            .header("content-type", "application/json")
            .body(body),
        Err(e) => {
            let error = ErrorResponse {
                code: 500,
                message: format!("Failed to serialize health response: {}", e),
            };
            let body = serde_json::to_vec(&error).unwrap_or_default();
            HttpResponse::internal_server_error()
                .header("content-type", "application/json")
                .body(body)
        }
    }
}

/// User fetch handler for Wasm server
fn user_handler(req: HttpRequest) -> HttpResponse {
    let user_id = req.path_params().get("user_id").cloned();
    let user_id = match user_id {
        Some(id) => id,
        None => {
            let error = ErrorResponse {
                code: 400,
                message: "Missing user ID in path".to_string(),
            };
            let body = serde_json::to_vec(&error).unwrap_or_default();
            return HttpResponse::bad_request()
                .header("content-type", "application/json")
                .body(body);
        }
    };

    if user_id.is_empty() || user_id.len() > 36 {
        let error = ErrorResponse {
            code: 400,
            message: "Invalid user ID: must be non-empty and ≤36 characters".to_string(),
        };
        let body = serde_json::to_vec(&error).unwrap_or_default();
        return HttpResponse::bad_request()
            .header("content-type", "application/json")
            .body(body);
    }

    if user_id == "error" {
        let error = ErrorResponse {
            code: 500,
            message: "Simulated database connection failure".to_string(),
        };
        let body = serde_json::to_vec(&error).unwrap_or_default();
        return HttpResponse::internal_server_error()
            .header("content-type", "application/json")
            .body(body);
    }

    let user = serde_json::json!({
        "id": user_id,
        "name": "Alice Smith",
        "email": "alice@example.com",
        "created_at": "2024-01-15T08:30:00Z"
    });
    let body = match serde_json::to_vec(&user) {
        Ok(b) => b,
        Err(e) => {
            let error = ErrorResponse {
                code: 500,
                message: format!("Failed to serialize user: {}", e),
            };
            serde_json::to_vec(&error).unwrap_or_default()
        }
    };
    HttpResponse::ok()
        .header("content-type", "application/json")
        .body(body)
}

fn main() -> anyhow::Result<()> {
    // Initialize router with endpoints
    let mut router = Router::new();
    router.get("/health", health_handler);
    router.get("/users/:user_id", user_handler);

    // Start WASI HTTP server
    wasi_http::serve(router)?;
    Ok(())
}

// Benchmark: Rust Native vs Wasm (Wasmtime) CPU Performance
// Compile native: cargo run --release
// Compile Wasm: cargo build --target wasm32-wasi --release
// Run benchmark: cargo run --release -- --wasm-path target/wasm32-wasi/release/fib-wasm.wasm
// Dependencies (Cargo.toml):
// [dependencies]
// wasmtime = "21.0.0"
// wasmtime-wasi = "21.0.0"
// clap = { version = "4.5.8", features = ["derive"] }
// serde = { version = "1.0.203", features = ["derive"] }
// serde_json = "1.0.117"
// anyhow = "1.0.86"

use clap::{ArgAction, Parser};
use serde::{Deserialize, Serialize};
use std::time::Instant;

// CLI arguments for benchmark configuration
#[derive(Parser)]
#[command(version, about = "Compare Rust native vs Wasm performance for Fibonacci calculation")]
struct Cli {
    /// Path to Wasm binary for Wasm benchmarks
    #[arg(short, long)]
    wasm_path: Option,

    /// Number of Fibonacci iterations to run
    #[arg(short, long, default_value_t = 1000)]
    iterations: u32,

    /// Fibonacci number to calculate (n)
    #[arg(short, long, default_value_t = 40)]
    fib_n: u32,
}

// Native Fibonacci implementation (recursive with memoization for fairness)
fn fibonacci_native(n: u32, memo: &mut Vec>) -> u64 {
    if n <= 1 {
        return n as u64;
    }
    if let Some(cached) = memo[n as usize] {
        return cached;
    }
    let result = fibonacci_native(n - 1, memo) + fibonacci_native(n - 2, memo);
    memo[n as usize] = Some(result);
    result
}

// Wasm Fibonacci caller (loads Wasm binary and executes exported fib function)
fn fibonacci_wasm(wasm_path: &str, n: u32, iterations: u32) -> anyhow::Result> {
    // Initialize Wasmtime engine with WASI support
    let engine = wasmtime::Engine::default();
    let module = wasmtime::Module::from_file(&engine, wasm_path)?;
    let mut store = wasmtime::Store::new(&engine, ());
    let wasi_ctx = wasmtime_wasi::WasiCtxBuilder::new()
        .inherit_stdout()
        .inherit_stderr()
        .build();
    store.data_mut().push(wasi_ctx);

    // Link WASI and instantiate module
    let mut linker = wasmtime::Linker::new(&engine);
    wasmtime_wasi::add_to_linker(&mut linker, |s| s)?;
    let instance = linker.instantiate(&mut store, &module)?;

    // Get exported fib function from Wasm module
    let fib_fn = instance
        .get_typed_func::(&mut store, "fib")?;

    // Run iterations
    let mut results = Vec::with_capacity(iterations as usize);
    for _ in 0..iterations {
        let result = fib_fn.call(&mut store, n)?;
        results.push(result);
    }
    Ok(results)
}

// Benchmark results struct
#[derive(Serialize, Deserialize)]
struct BenchmarkResult {
    test_type: String,
    iterations: u32,
    fib_n: u32,
    total_time_ms: f64,
    avg_time_per_iter_ms: f64,
    result_sample: u64,
}

fn main() -> anyhow::Result<()> {
    let cli = Cli::parse();
    let mut results = Vec::new();

    // Run native benchmark
    println!("Running native Fibonacci({}) benchmark for {} iterations...", cli.fib_n, cli.iterations);
    let mut memo = vec![None; (cli.fib_n + 1) as usize];
    let start = Instant::now();
    let mut native_results = Vec::with_capacity(cli.iterations as usize);
    for _ in 0..cli.iterations {
        native_results.push(fibonacci_native(cli.fib_n, &mut memo));
    }
    let native_duration = start.elapsed();
    let native_result = BenchmarkResult {
        test_type: "Rust Native".to_string(),
        iterations: cli.iterations,
        fib_n: cli.fib_n,
        total_time_ms: native_duration.as_millis() as f64,
        avg_time_per_iter_ms: native_duration.as_millis() as f64 / cli.iterations as f64,
        result_sample: native_results[0],
    };
    results.push(native_result);

    // Run Wasm benchmark if path is provided
    if let Some(wasm_path) = &cli.wasm_path {
        println!("Running Wasm Fibonacci({}) benchmark for {} iterations...", cli.fib_n, cli.iterations);
        let start = Instant::now();
        let wasm_results = fibonacci_wasm(wasm_path, cli.fib_n, cli.iterations)?;
        let wasm_duration = start.elapsed();
        let wasm_result = BenchmarkResult {
            test_type: "Wasm (Wasmtime)".to_string(),
            iterations: cli.iterations,
            fib_n: cli.fib_n,
            total_time_ms: wasm_duration.as_millis() as f64,
            avg_time_per_iter_ms: wasm_duration.as_millis() as f64 / cli.iterations as f64,
            result_sample: wasm_results[0],
        };
        results.push(wasm_result);
    }

    // Print results as JSON
    println!("{}", serde_json::to_string_pretty(&results)?);
    Ok(())
}

// Minimal wasi-http Wasm handler (no JS glue)
use wasi_http::{router::Router, HttpRequest, HttpResponse};

fn hello_handler(_req: HttpRequest) -> HttpResponse {
    HttpResponse::ok()
        .header("content-type", "text/plain")
        .body(b"Hello from WASI HTTP Wasm!")
}

fn main() -> anyhow::Result<()> {
    let mut router = Router::new();
    router.get("/", hello_handler);
    wasi_http::serve(router)?;
    Ok(())
}

# GitHub Actions step for Wasm vs Native benchmark gate
- name: Run Wasm/Native Performance Gate
  run: |
    # Install Wasmtime
    curl https://wasmtime.dev/install.sh -sSf | bash
    # Build native benchmark
    cargo bench --bench perf_compare -- --output-format json > native_bench.json
    # Build Wasm benchmark
    cargo build --target wasm32-wasi --release --bench perf_compare
    # Run Wasm benchmark via Wasmtime
    wasmtime target/wasm32-wasi/release/bench-perf_compare.wasm --output-format json > wasm_bench.json
    # Compare results (fail if Wasm overhead >5%)
    python scripts/compare_bench.py native_bench.json wasm_bench.json --max-overhead 5

# Initialize a new Wasm component from Rust
cargo component init --lib my-wasm-component
# Add a WIT interface for your component
echo "package my:wasm-component;
interface user-service {
  get-user: func(id: string) -> result;
  record user {
    id: string,
    name: string,
    email: string
  }
}" > wit/user-service.wit
# Build the component
cargo component build --release