AETHER-Link

A sub-20ns I/O prefetching kernel written in Rust. It is designed specifically for latency-critical applications like High-Frequency Trading (HFT), DirectStorage gaming, and WSL2 acceleration.

What it actually does

AETHER-Link sits between your application and your storage layer. You feed it a stream of Logical Block Addresses (LBAs), and it returns a boolean indicating whether you should aggressively prefetch the data or let the standard OS page cache handle it. Instead of using slow machine learning models or naive stride detection, it uses a quantum-inspired probabilistic algorithm known as POVM (Positive Operator-Valued Measure). This allows the kernel to adapt to shifting workload patterns continuously in real-time without the multi-millisecond overhead associated with neural networks.

The Numbers

This library is built for the hot path, utilizes #![no_std] compatibility for kernel space, and strictly avoids heap allocations in the decision loop.

• Decision Latency: The full decision loop takes ~14.6 ns on average.
• Throughput: It achieves ~65.3 million operations per second per thread.
• Jitter: The jitter (measured as P99 minus P50) is tightly constrained at 1.9 ns.
• Telemetry Extraction: The zero-copy DSP extraction takes roughly 0.99 ns. For context, NVMe hardware latency is typically ~10-25 µs. AETHER-Link's decision overhead is imperceptible relative to actual I/O times.

Quick Start

Add the dependency to your Cargo.toml:

[dependencies]
aether-link = "0.1.0"

use aether_link::AetherLinkKernel;
fn main() {
    // Initialize the kernel. 
    // Use `new_hft()` for conservative prefetching or `new_gaming()` for aggressive.
    let mut kernel = AetherLinkKernel::new_hft();
    // Pass in your recent stream of Logical Block Addresses (LBAs)
    let lba_stream = [1000, 1001, 1002, 1003, 1010];
    // Process the cycle
    let should_prefetch = kernel.process_io_cycle(&lba_stream);
    if should_prefetch {
        // -> Dispatch via DirectStorage / GPU Direct / io_uring
        println!("Aggressive prefetch triggered.");
    } else {
        // -> Rely on standard OS page cache
        println!("Deferring to OS page cache.");
    }
}

How it works (The Math)

1. Event Radar: Extracts 6D telemetry from the LBA stream, calculating metrics like spatial span and a velocity proxy.
2. State Encoding: Maps these real-valued features to an angular probability space using fast Padé approximants for atan operations, bypassing slow standard library math functions.
3. Adaptive POVM Decision: Evaluates three observables and dynamically updates its measurement basis angle and fetch probability threshold based on the results. (Note: It is considered "quantum-inspired" because it models unknown workloads similarly to quantum states and utilizes adaptive basis rotations. However, it operates entirely on standard classical hardware architecture and does not utilize actual qubits.)

Hardware Integration

While the standard CPU kernel is highly optimized, the architecture has been designed for direct hardware offloading:

• NVIDIA BlueField DPUs: The decision kernel can be compiled and run directly on the ARM cores of a DPU, completely bypassing the host CPU and making inline decisions before data even hits the PCIe bus.
• CUDA GPUs: Thousands of concurrent I/O streams can be evaluated simultaneously by batching POVM states on a GPU, working in tandem with GPUDirect Storage.

Contributing

We welcome contributions! Please see CONTRIBUTING.md for details on how to submit pull requests, run the benchmark suite, and our code of conduct.

License

This project is licensed under the Apache License, Version 2.0.