⚡️ UltraSlayer – DRAM Refresh‑Stall Killer

UltraSlayer is a lock‑free, hardware‑aware memory slab that eliminates the “DRAM refresh stall” (tREFI) tail‑latency that destroys nanosecond‑level determinism in High‑Frequency‑Trading (HFT) and other ultra‑low‑latency workloads.

It mirrors every hot‑path object across a configurable number of physical DRAM channels and lets a dedicated Slayer Core race the reads in parallel, guaranteeing that at least one channel will answer before a refresh can stall the request.

⚠️ WARNING – UltraSlayer uses unsafe, volatile loads/stores and a core that spins 100 % of the time. Use it only for the critical hot‑path of a latency‑sensitive application.

🎯 The Problem – DRAM “Tail”

A single 200 ns jitter can be the difference between a profitable trade and a missed opportunity.

🚀 The Solution – Hardware Hedging

The core spins continuously to keep the core hot and avoid C‑state exits that would re‑introduce jitter.

❤️ Inspiration – Laurie Wired’s TailSlayer

UltraSlayer is a Rust port of the original TailSlayer implementation created by Laurie Wired.

• TailSlayer (C++ version) – https://github.com/LaurieWired/tailslayer
• Video explanation (Laurie Wired) – https://www.youtube.com/watch?v=KKbgulTp3FE

Laurie Wired’s work introduced the concept of hardware‑level hedging to eliminate DRAM refresh‑stall tail latency. UltraSlayer adapts that concept to safe‑ish Rust while preserving the same deterministic guarantees.

🛠️ New Features (v0.2)

📋 System Requirements

📦 Getting Started – Build & Install

1️⃣ Clone the repository

git clone https://github.com/absalomedia/ultraslayer.git

cd ultraslayer

2️⃣ Build the core library (default)

cargo build --release

3️⃣ Optional builds

The release profile already uses full LTO, opt-level = 3, panic = "abort" and a single codegen unit for maximum inlining.

▶️ Running UltraSlayer (demo binary)

Linux (with Real‑Time priority)

# Use the binary located in the examples directory

sudo chrt -f 99 taskset -c 2 target/release/examples/ultraslayer_cli \

    --channels 4 \

    --size 2GiB \

    --spin busy

Windows

# Use the binary located in the examples directory
.\target\release\examples\ultraslayer_cli.exe --channels 4 --size 2GiB --spin busy

Alternatively, run directly via Cargo:

cargo run --release --features cli --example ultraslayer_cli -- --channels 4 --size 2GiB --spin busy

Flags

📊 Benchmarking

UltraSlayer ships with two ways to benchmark latency.

1️⃣ Criterion read‑latency benchmark

cargo bench --features benchmark

The benchmark creates slabs with 2, 4, and 8 channels, fills them with deterministic data, then performs 1 000 000 random reads per configuration while measuring nanosecond‑resolution latency.

2️⃣ Stand‑alone micro‑benchmark binary

Via Cargo:

cargo run --release --features benchmark --example benchmark -- --channels 4 --size 2GiB --ops 1_000_000 --spin busy

Via binary (for Real-Time priority on Linux):

# First, build the example

cargo build --release --features benchmark


# Then run the resulting binary from the examples folder

sudo chrt -f 99 taskset -c 2 target/release/examples/benchmark \

    --channels 4 --size 2GiB --ops 1_000_000 --spin busy

Windows execution:

.\target\release\examples\benchmark.exe --channels 4 --size 2GiB --ops 1_000_000 --spin busy

🔌 Integration Guide

A️ Pure Rust Engine

use std::sync::Arc;
use ultraslayer::{UltraSlayer, SpinPolicy};

fn main() {
    // 2 GiB slab, 4 mirrored channels, busy‑spin policy
    let slayer = Arc::new(
        UltraSlayer::<u64>::new(4, 2 << 30) // Direct allocation
    );
    slayer.set_spin_policy(SpinPolicy::Busy);
    slayer.spawn_slayer_core(0);       // start core on CPU 0
    slayer.pin_to_core(0);            // pin current thread to core 0

    // Hot‑path usage (example: reading a price)
    let price = slayer.read(PRICE_IDX);
    
    // Optional: Bulk read via slice (requires --features slice)
    // let view = unsafe { slayer.slice() };
    // let first_val = view[0];
}

All public methods (read, write, slice, stats, set_spin_policy, pin_to_core) are exposed through the crate root (ultraslayer::UltraSlayer).

B️ Non‑Rust Languages (C / Node / Python) – Side‑car

cargo build --release --features sidecar

The exported C API (in src/ffi.rs) provides ul_init, ul_start_core, ul_read_u64, ul_write_u64, and ul_destroy.

C️ Multiple Processes – POSIX Shared‑Memory (Linux Only)

use ultraslayer::ShmSlab;

// Process A – creates the slab
let shm = ShmSlab::<u64>::create("ultra_slab", 4, 2 << 30)?;
let slayer = shm.into_ultraslayer();

📁 Project Layout

ultraslayer/
├─ src/
│   ├─ lib.rs            ← public UltraSlayer API
│   ├─ slab.rs           ← low‑level mirroring & volatile ops
│   ├─ arch.rs           ← CPU‑affinity helpers
│   ├─ reader.rs         ← internal read‑path logic
│   ├─ main.rs           ← optional entry point
│   ├─ shm.rs            ← POSIX shared‑memory wrapper (Linux)
│   ├─ ffi.rs            ← C‑FFI side‑car (feature = "sidecar")
│   └─ slice.rs          ← zero‑copy slice view
├─ benches/
│   └─ read_latency.rs   ← Criterion read‑latency benchmark
├─ examples/
│   ├─ ultraslayer_cli.rs    ← CLI demo binary (feature = "cli")
│   └─ benchmark.rs      ← micro‑benchmark binary (feature = "benchmark")
├─ Cargo.toml
└─ README.md            ← this file

📜 License

UltraSlayer is released under the Apache License, Version 2.0.

TL;DR – Quick start for a typical HFT node

# 1️⃣ Reserve huge pages (Linux only)

sudo sysctl -w vm.nr_hugepages=2048


# 2️⃣ Build with the CLI demo + side‑car + slice view

cargo build --release --features "cli sidecar slice"


# 3️⃣ Run the demo (core 2, 4 channels, 2 GiB per channel)

sudo chrt -f 99 taskset -c 2 target/release/examples/ultraslayer_cli \

    --channels 4 --size 2GiB --spin busy

UltraSlayer – the practical, Rust‑native answer to Laurie Wired’s TailSlayer concept. 🚀