# Always profile and debug with release mode
cargo build --release

# Debug builds can be 10–50x slower — never benchmark debug builds
cargo run --release -- --port 8080

use std::time::Instant;
use tracing::{info, instrument};

#[instrument(skip(input))]
async fn traced_infer(request_id: u64, input: Vec<f32>) -> Vec<f32> {
    let t0 = Instant::now();
    info!(request_id, input_len = input.len(), "inference started");

    let result = tokio::task::spawn_blocking(move || {
        input.iter().map(|x| x * 2.0).collect::<Vec<_>>()
    }).await.unwrap();

    info!(
        request_id,
        duration_ms = t0.elapsed().as_millis(),
        output_len = result.len(),
        "inference complete"
    );
    result
}

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();
    let r = traced_infer(1, vec![1.0, 2.0, 3.0]).await;
    println!("{:?}", r);
}

fn check_input(input: &[f32]) -> Result<(), String> {
    if input.is_empty() { return Err("empty input".into()); }
    if input.len() > 4096 { return Err(format!("too large: {}", input.len())); }
    if input.iter().any(|v| !v.is_finite()) { return Err("contains NaN or Inf".into()); }
    Ok(())
}

fn main() {
    let cases = [
        vec![1.0f32, 2.0, 3.0],
        vec![f32::NAN],
        vec![],
    ];
    for c in &cases {
        println!("{:?} → {:?}", &c[..c.len().min(2)], check_input(c));
    }
}

// Find any of these patterns in your async code:
// std::thread::sleep(...)  → replace with tokio::time::sleep(...)
// std::sync::Mutex::lock() → replace with tokio::sync::Mutex or RwLock
// Heavy CPU loops           → wrap in spawn_blocking

// Quick audit: search your codebase for these
// grep -r "std::thread::sleep" src/
// grep -r "\.lock()" src/ | grep -v "spawn_blocking"

use std::sync::atomic::{AtomicUsize, Ordering};

static QUEUE_DEPTH: AtomicUsize = AtomicUsize::new(0);
static IN_FLIGHT: AtomicUsize = AtomicUsize::new(0);

fn report_metrics() {
    println!(
        "queue_depth={} in_flight={}",
        QUEUE_DEPTH.load(Ordering::Relaxed),
        IN_FLIGHT.load(Ordering::Relaxed),
    );
}

fn main() { report_metrics(); }

fn output_ok(output: &[f32]) -> bool {
    !output.is_empty()
        && output.iter().all(|v| v.is_finite())
        && output.iter().any(|&v| v != 0.0) // not all zeros
}

fn main() {
    let good = vec![0.1f32, 0.9, 0.5];
    let bad = vec![0.0f32; 8];
    println!("good: {}", output_ok(&good));
    println!("bad (all zeros): {}", output_ok(&bad));
}

# Watch RSS over time
watch -n 5 'cat /proc/$(pgrep my-inference-server)/status | grep VmRSS'

# Check for leaks with valgrind (slower, but definitive)
valgrind --leak-check=full --track-origins=yes ./target/debug/my-server