Bench Hdr

cargo add --dev hdrhistogram@^7

[[bench]]
name = "mixed_70_20_10_hdr"
path = "benches/order_book/mixed_70_20_10_hdr.rs"
harness = false

use hdrhistogram::Histogram;
use std::time::Instant;

/// Histogram sized for 1 ns .. 1 s with 3 significant figures.
pub fn new_histogram() -> Histogram<u64> {
    Histogram::<u64>::new_with_bounds(1, 1_000_000_000, 3).expect("hist bounds")
}

/// Measure a closure once, record nanoseconds into the histogram.
#[inline(always)]
pub fn record<F, R>(h: &mut Histogram<u64>, f: F) -> R
where
    F: FnOnce() -> R,
{
    let t0 = Instant::now();
    let r = std::hint::black_box(f());
    let elapsed = t0.elapsed().as_nanos() as u64;
    h.record(elapsed.max(1)).expect("record");
    r
}

pub fn report(name: &str, h: &Histogram<u64>) {
    println!("scenario   : {}", name);
    println!("samples    : {}", h.len());
    println!("p50   (ns) : {}", h.value_at_quantile(0.50));
    println!("p99   (ns) : {}", h.value_at_quantile(0.99));
    println!("p99.9 (ns) : {}", h.value_at_quantile(0.999));
    println!("p99.99(ns) : {}", h.value_at_quantile(0.9999));
    println!("max   (ns) : {}", h.max());
    println!("min   (ns) : {}", h.min());
}

pub fn persist(name: &str, h: &Histogram<u64>) -> std::io::Result<()> {
    use hdrhistogram::serialization::V2Serializer;
    std::fs::create_dir_all("target/bench-hdr")?;
    let path = format!("target/bench-hdr/{}.hgrm", name);
    let mut f = std::fs::File::create(&path)?;
    V2Serializer::new()
        .serialize(h, &mut f)
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
    eprintln!("wrote {}", path);
    Ok(())
}

#[path = "hdr_common.rs"]
mod hdr_common;

use hdr_common::{new_histogram, persist, record, report};
use orderbook_rs::prelude::*;

const WARMUP_OPS:   usize =   200_000;
const MEASURED_OPS: usize = 1_000_000;
const SEED:         u64   = 0xA5A5_A5A5;

enum Op {
    Submit { id: Id, owner: u64, side: Side, price: Price, qty: Quantity, tif: TimeInForce },
    Cancel(Id),
    Aggressive { id: Id, owner: u64, side: Side, qty: Quantity },
}

fn build_mixed_workload(n: usize, seed: u64) -> Vec<Op> {
    // Deterministic PRNG from `seed`; no rand crate — use a small xorshift so the bench
    // is self-contained and reproducible. Tight price band (99..=101) for frequent
    // crossings on the aggressive slice.
    let mut s = seed;
    let mut next = || { s ^= s << 13; s ^= s >> 7; s ^= s << 17; s };
    let mut ops = Vec::with_capacity(n);
    for i in 0..n {
        let bucket = next() % 100;
        let id = Id::from_u64(i as u64 + 1);
        let owner = (next() % 4) + 1;
        let side = if next() % 2 == 0 { Side::Buy } else { Side::Sell };
        let price = Price::from_u64(99 + (next() % 3));
        let qty = Quantity::from_u64(1 + (next() % 100));
        if bucket < 70 {
            ops.push(Op::Submit { id, owner, side, price, qty, tif: TimeInForce::Gtc });
        } else if bucket < 90 {
            ops.push(Op::Cancel(Id::from_u64(1 + (next() % (i as u64).max(1)))));
        } else {
            ops.push(Op::Aggressive { id, owner, side, qty });
        }
    }
    ops
}

fn apply(book: &OrderBook<()>, op: &Op) {
    match op {
        Op::Submit { id, owner, side, price, qty, tif } => {
            let _ = book.submit_limit(*id, *owner, *side, *price, *qty, *tif);
        }
        Op::Cancel(id) => {
            let _ = book.cancel(*id);
        }
        Op::Aggressive { id, owner, side, qty } => {
            let _ = book.submit_market(*id, *owner, *side, *qty);
        }
    }
}

fn main() {
    let workload = build_mixed_workload(WARMUP_OPS + MEASURED_OPS, SEED);
    let book = OrderBook::<()>::new("BENCH");
    let mut h = new_histogram();

    // Warmup — discarded.
    for op in &workload[..WARMUP_OPS] { apply(&book, op); }

    // Measurement.
    for op in &workload[WARMUP_OPS..] {
        record(&mut h, || apply(&book, op));
    }

    report("mixed_70_20_10", &h);
    persist("mixed_70_20_10", &h).expect("persist");
}