AETHER-Link

By Teerth Sharma

An allocation-free I/O prefetch decision kernel in Rust, aimed at latency-sensitive storage paths: HFT, DirectStorage-style gaming loads, and WSL2.

What it actually does

AETHER-Link is a decision function, not an I/O path. You feed it a slice of Logical Block Addresses and it returns a bool — prefetch, or defer to the OS page cache.

It does not open files, issue syscalls, touch NVMe, or move data. Wiring the decision into a real prefetch path (DirectStorage, io_uring, GPUDirect) is the caller's job and is not implemented in this crate.

Instead of an ML model or stride detection, it uses a quantum-inspired adaptive measurement scheme (POVM formalism) that evolves its decision basis from the stream itself. No training, no heap, no network.

"Quantum-inspired" means the mathematical formalism only — Bloch sphere, POVM observables, basis rotation. No qubits, no quantum hardware.

The Numbers

All figures below are the mean of the committed Criterion run in docs/, with 95% confidence intervals. Reproduce with:

cargo bench

Core

Benchmark	Mean	95% CI
process_io_cycle	244.77 ns	[244.59, 244.95]
extract_telemetry	90.48 ns	[90.44, 90.52]
prepare_quantum_state	61.14 ns	[61.03, 61.28]

Presets

Benchmark	Mean	95% CI
HFT cycle	243.61 ns	[243.49, 243.75]
Gaming cycle	243.56 ns	[243.44, 243.69]

Fast math

Benchmark	Mean	95% CI
fast_atan	4.69 ns	[4.68, 4.70]
fast_exp	2.97 ns	[2.97, 2.97]
fast_sigmoid	3.35 ns	[3.34, 3.36]

Throughput

1,000,000 cycles in 239.3 ms → ≈ 4.18 M decisions/sec, single thread.

Stream-size scaling

Stream length	Mean	vs. len 10
10	215.40 ns	—
100	245.19 ns	+13.8 %
1,000	235.49 ns	+9.3 %
10,000	235.64 ns	+9.4 %

Scaling is not flat and not monotonic — cost varies ~14 % across the range and peaks at length 100. Telemetry extraction is O(1) in principle; this spread is not yet explained, and is an open item.

Context

NVMe hardware latency is ~10–25 µs. A 244.77 ns decision is roughly 40–100× smaller than the I/O it schedules.

Not measured

The following are not benchmarked in this crate and any previously published figures for them have been withdrawn:

• Latency percentiles (P50/P90/P99/P99.9) and jitter. Criterion reports batch-mean timings; it does not give per-decision tail latency. Establishing these needs a dedicated harness.
• Prefetch-ratio comparisons across sequential/random workload patterns. No benchmark in benches/ produces these.
• End-to-end I/O throughput or NVMe latency reduction. The crate performs no I/O.

Quick Start

Not yet published to crates.io. Use a git dependency:

[dependencies]
aether-link = { git = "https://github.com/teerthsharma/aether-link" }

use aether_link::AetherLinkKernel;

let mut kernel = AetherLinkKernel::new_hft();
let lba_stream = [1000, 1001, 1002, 1003, 1010];

if kernel.process_io_cycle(&lba_stream) {
    // Caller dispatches via DirectStorage / GPUDirect / io_uring — not provided here.
} else {
    // Defer to standard OS page cache.
}

Requirements

• Rust: 1.70+ (MSRV)
• Architecture: x86_64, AArch64, or RISC-V with FPU
• #![no_std] compatible; zero heap allocation in the decision loop

How It Works

1. Telemetry extraction — 90.48 ns

Six features from the LBA stream, no hardcoded constants:

Feature	Symbol	Description
Delta	Δ	LBA span: last − first
Velocity	V	Δ × 0.5 (acceleration proxy)
Variance	σ²	Welford running variance across seen streams
Spectrum	C	Chebyshev spectral energy (running RMS of delta-diff)
History	H	Exponential decay temporal weight (decay = 0.8)
Context	Ω	Log-density entropy of recent inter-arrival rates

2. State encoding — 61.14 ns

Features map to a Bloch-sphere state:

θᵢ = 2 × atan(fᵢ / scale)     // polar angle
φ  = weighted azimuthal average
Bloch vector (normalised): [rx, ry, rz] on S²

Normalisation keeps the subsequent POVM expectation values bounded.

3. Adaptive POVM measurement — 244.77 ns end to end

Three observables probe the Bloch vector against the adaptive basis φ:

E₁ = cos(θ + φ)    → spatial (LBA velocity alignment)
E₂ = sin(θ/2 − φ)  → temporal phase (drives basis rotation)
E₃ = cos(θ · φ)    → spectral (drives fetch sigmoid)

φ updates after each measurement, giving continuous adaptation with no trained parameters.

Possible integrations — design notes, not implemented

None of the following exist in this crate today. They are sketches of where a decision kernel of this shape could sit:

• NVIDIA BlueField DPUs — run the decision on DPU ARM cores, inline before PCIe.
• CUDA GPUs — batch many streams by encoding POVM states as tensors.
• no_std / bare metal — the crate does build no_std; kernel-space integration is untested.

Roadmap

1. Explain and flatten the stream-size scaling spread.
2. Add a tail-latency harness so percentile claims can be made honestly.
3. Wire one real prefetch path end to end and measure against an OS-cache baseline.
4. Publish to crates.io once (1)–(3) land.

Contributing

See CONTRIBUTING.md.

License

Apache License 2.0 — Teerth Sharma, 2026.