Benchmarks

All numbers on this page are measured values from the HORUS benchmark suite, not estimates. Run on Intel i9-14900K (32 cores), WSL2, release mode, RDTSC cycle-accurate timing on 2026-03-22.

Reproduce on your hardware:

cargo run --release -p horus_benchmarks --bin all_paths_latency

Quick Reference

IPC Latency — All Backend Paths

Measured with all_paths_latency: 100,000 iterations per scenario, RDTSC timing with 6ns overhead subtracted, Tukey IQR outlier removal, bootstrap 95% confidence intervals.

Intra-Process

Cross-Process

Hardware Floor

Framework Overhead

HORUS adds 34–114ns over the hardware minimum for cross-process IPC. FanoutShm achieves the lowest overhead because its contention-free SPSC channel matrix eliminates CAS operations on the hot path.

Robotics Message Types

Measured with robotics_messages_benchmark: 50,000 iterations, cross-thread producer/consumer on separate cores.

Real-Time Suitability

All message types pass real-time suitability at their typical robotics frequencies.

HORUS vs Competition

Measured with competitor_comparison: 5 seconds sustained per transport, same machine.

Speedup: 54x (8B), 49x (32B) over raw UDP on the same machine.

HORUS eliminates the kernel network stack entirely. UDP requires sendto() + recvfrom() system calls (~1,100ns of kernel overhead). HORUS uses direct shared memory access (~23ns total).

HORUS vs iceoryx2

iceoryx2 is Eclipse's lock-free zero-copy IPC middleware. Measured with iceoryx2_comparison and fanout_shm_bench: same machine, same message types, release mode.

HORUS beats iceoryx2 on every IPC path. The cross-process MPMC advantage comes from FanoutShm — a contention-free SPSC channel matrix that eliminates all CAS operations on the hot path.

# Reproduce (requires iceoryx2 feature)
cargo run --release -p horus_benchmarks --bin iceoryx2_comparison --features iceoryx2

# HORUS-only cross-process MPMC
cargo run --release -p horus_benchmarks --bin fanout_shm_bench

Scalability

Measured with scalability_benchmark: sustained throughput with varying producer/consumer thread counts.

Thread Scaling

Producer Scaling (1 Consumer)

1 producer:   3.0 M/s  ████████████
2 producers:  8.7 M/s  ██████████████████████████████████
3 producers: 11.5 M/s  ████████████████████████████████████████████
4 producers: 11.9 M/s  ████████████████████████████████████████████
6 producers: 13.5 M/s  █████████████████████████████████████████████████  ← peak
8 producers: 11.5 M/s  ████████████████████████████████████████████

Peak throughput at 6 producers (13.5M msg/s). Beyond 6, contention on the atomic head pointer causes slight degradation.

Consumer Scaling (1 Producer)

1 consumer:  2.8 M/s  ███████████
2 consumers: 4.8 M/s  ██████████████████
4 consumers: 4.8 M/s  ██████████████████
8 consumers: 3.7 M/s  ██████████████

Consumer scaling plateaus at 2 — the ring buffer uses broadcast semantics (all consumers read the same data), so adding consumers doesn't increase total throughput.

Real-Time Determinism

Measured with determinism_benchmark: 10 runs of 100,000 iterations each, CPU-pinned to cores 0 and 1.

Interpretation: The 7.9ns standard deviation and 0.06 run-to-run coefficient of variation indicate highly deterministic behavior. The 0.02% deadline miss rate at the extremely aggressive 1μs deadline is due to OS scheduling jitter in WSL2 — on a bare-metal Linux system with PREEMPT_RT kernel and isolcpus, expect zero misses.

Python Binding Performance

Measured with research_bench_python.py: 5 seconds sustained per test, Python 3.12, PyO3 bindings v0.1.9.

Typed Message IPC (Zero-Copy Pod Path)

Generic Message IPC (Serialization Path)

Typed messages are 4-65x faster than dicts because they bypass serialization and use direct Pod memcpy through the Rust layer.

Image Zero-Copy

np.from_dlpack() is 13x faster than np.copy() — it returns a numpy array backed by the shared memory pool with no data movement.

FFI Overhead Attribution

The ~1.7μs Python overhead comes from: PyO3 boundary crossing (~500ns), GIL acquisition (~500ns), and Python object allocation (~700ns). This overhead is constant regardless of message size.

Scheduler Tick Overhead

The GIL is the bottleneck for Python tick rate. For control loops above ~5kHz, use Rust nodes.

When to Use Python vs Rust

C++ Binding Performance

Measured with cpp_benchmark: release mode, g++ -O2, 10,000 iterations per test, high_resolution_clock timing with warmup.

FFI Boundary Cost

The raw cost of crossing the Rust-C++ boundary is 15-17ns — comparable to a C++ virtual function call.

Scheduler Tick from C++

Per-node overhead is ~220ns, which includes catch_unwind safety wrapper + closure dispatch through the FFI boundary.

Throughput

Scalability

Linear scaling — per-node cost is constant at ~220ns regardless of node count.

C++ vs Rust vs Python Overhead

C++ adds 161ns over native Rust — the cost of the extern "C" boundary and panic safety wrapper. For perspective, this is 0.16 microseconds — invisible at any practical control rate.

Memory Safety

Validated with AddressSanitizer (g++ -fsanitize=address):

Zero memory safety violations across the entire FFI surface.

Running C++ Benchmarks

# Build release
cargo build --release --no-default-features -p horus_cpp

# Compile benchmark
g++ -std=c++17 -O2 -o cpp_benchmark \
    horus_cpp/tests/cpp_benchmark.cpp \
    -L target/release -lhorus_cpp -lpthread -ldl -lm

# Run
LD_LIBRARY_PATH=target/release ./cpp_benchmark

# With ASAN
g++ -std=c++17 -O2 -fsanitize=address -fno-omit-frame-pointer \
    -o cpp_stress_asan horus_cpp/tests/cpp_stress_test.cpp \
    -L target/release -lhorus_cpp -lpthread -ldl -lm
LD_LIBRARY_PATH=target/release ./cpp_stress_asan

Running Benchmarks

Rust Benchmarks

# Main benchmark: all 10 backend paths (~2 min)
cargo run --release -p horus_benchmarks --bin all_paths_latency

# Robotics message types: CmdVel, Imu, LaserScan, JointCommand
cargo run --release -p horus_benchmarks --bin robotics_messages_benchmark

# HORUS vs UDP comparison
cargo run --release -p horus_benchmarks --bin competitor_comparison

# Scalability: thread count sweep
cargo run --release -p horus_benchmarks --bin scalability_benchmark

# RT determinism: jitter analysis
cargo run --release -p horus_benchmarks --bin determinism_benchmark

# Hardware floor: raw memcpy, atomic, mmap
cargo run --release -p horus_benchmarks --bin raw_baselines

# Cross-process: true inter-process IPC
cargo run --release -p horus_benchmarks --bin cross_process_benchmark

# Full research suite (~30 min)
./benchmarks/research/run_all.sh

# Quick validation (~3 min)
./benchmarks/research/run_all.sh --quick

Python Benchmarks

cd horus_py

# Quick validation (2s per test)
PYTHONPATH=. python3 benchmarks/research_bench_python.py --duration 2

# Full research run (10s per test)
PYTHONPATH=. python3 benchmarks/research_bench_python.py --duration 10 --csv results.csv

# JSON summary for CI
PYTHONPATH=. python3 benchmarks/research_bench_python.py --json summary.json

Criterion Micro-Benchmarks

# All criterion benches (HTML reports in target/criterion/)
cargo bench -p horus_benchmarks

# Filter by name
cargo bench -p horus_benchmarks -- topic_latency

Methodology

Timing

• RDTSC (x86_64) with serializing fences (lfence + mfence), calibrated per-run (~3.37 GHz on test machine)
• Overhead: ~6ns per measurement, subtracted from all samples
• Fallback: Instant::now() (~11ns) on non-x86

Statistical Analysis

• Percentiles: p1, p5, p25, p50, p75, p95, p99, p99.9, p99.99
• Confidence intervals: Bootstrap with 10,000 resamples, 95% level
• Outlier filtering: Tukey IQR (1.5x fence)
• Determinism metrics: Coefficient of variation, run-to-run variance

Environment Control

• CPU governor: Performance mode recommended (numbers above measured with powersave in WSL2)
• CPU affinity: Producer and consumer pinned to separate physical cores
• Warmup: 5,000-10,000 iterations discarded before measurement
• Measurement: 50,000-100,000 iterations per test
• Turbo boost: Disabled recommended for reproducibility

Reproducing These Numbers

Your numbers will differ based on CPU, OS, governor, and VM/bare-metal:

See Also

• Performance Optimization — How to write fast HORUS code
• Shared Memory — SHM architecture and ring buffer details
• Scheduler API — Timing configuration and execution classes
• Python API — Python binding overhead and usage patterns