I've developed an attention mechanism called the Waller Operator that maintains constant ~14ms latency regardless of sequence length, compared to FlashAttention's O(N²) scaling.
Benchmarks on NVIDIA H100 with Mistral-7B:
• Constant latency: 14.168-14.305ms across 512 → 524,288 tokens (0.96% variance)
• 24.5x faster than FlashAttention v2.8.3 at 32K tokens
• O(N log N) memory complexity vs O(N²)
• Zero throughput degradation (FlashAttention shows 76% loss from 4K→32K)
• Successfully executes at 524K tokens (FlashAttention OOMs beyond 32K)
I've been working on a problem in quantitative finance where we need reproducible results for audit trails. Simple stuff like sin(0.5) returns different bits on ARM vs x86, or CPU vs GPU.
Traced it down to libm implementations using different polynomial approximations, FMA instructions, and compiler optimizations. Even the same binary can produce different results depending on CPU microarchitecture.
Ended up building a REST API that forces determinism by using fixed Remez polynomial coefficients, disabling FMA, and enforcing strict evaluation order. Every response includes a SHA256 hash of the output bytes.
Just shipped an update with 19 validated unary functions (trig, hyperbolic, exp, log, roots) plus support for compound expressions. Tested across M1 Mac, x86 Linux, and H100 GPU. Same inputs produce identical hashes on all three.
Curious if others have hit this problem. How do you handle determinism in distributed systems where floating point consistency matters? Is there interest in a tool like this or are people just accepting the drift?
Love seeing more Rust-based edge AI tooling. The 100% offline constraint is underrated – too many "edge" solutions quietly phone home.
Question: how are you handling numerical precision for the geo-spatial queries? I've been working on deterministic math for similar use cases (autonomous systems, orbital mechanics) and the edge hardware constraints are fascinating.
Benchmarks on NVIDIA H100 with Mistral-7B:
• Constant latency: 14.168-14.305ms across 512 → 524,288 tokens (0.96% variance) • 24.5x faster than FlashAttention v2.8.3 at 32K tokens • O(N log N) memory complexity vs O(N²) • Zero throughput degradation (FlashAttention shows 76% loss from 4K→32K) • Successfully executes at 524K tokens (FlashAttention OOMs beyond 32K)
Full benchmark data: https://github.com/RegularJoe-CEO/vllm/blob/waller-operator-...
FlashAttention baseline for comparison: https://github.com/vllm-project/vllm/pull/33860
The kernel achieves ~492-496 TFLOPS consistently across all sequence lengths.
Looking for feedback on the approach and additional validation suggestions.