Best Use & Engineering Application Guide

Engineering Category: Deterministic Sovereign Compute Kernel

Best Use in Production: Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition.

When to Select This Capsule: Sole canonical implementation for its 64-vector functional equivalence class. Sub-10-cycle hardware kernel (1331441/400000 cyc/op); safe for ultra-hot per-sample or per-packet inner loops.

Snap-Circuit Wiring Role: 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches.

Hardware _rdtsc: 1331441/400000 cycles/op
Latency: 634243/400000 ns/op
Throughput: 400000000/634243 ops/us
Compiled ELF64 .text: 114 B (34 x86_64 insns)
C64 64KB RAM Budget: 687/65536 (687 B source)
Ternary Vote: + (score 1) | Salience: 72355/832
Pure-Rust Capsule Source Code (687 B)
#[inline(always)]
pub fn branchless_sort4_u64(packed4x16: u64) -> u64 {
    let mut a = packed4x16 & 0xFFFF;
    let mut b = (packed4x16 >> 16) & 0xFFFF;
    let mut c = (packed4x16 >> 32) & 0xFFFF;
    let mut d = (packed4x16 >> 48) & 0xFFFF;
    let (mn1, mx1) = if a < b { (a, b) } else { (b, a) };
    a = mn1; b = mx1;
    let (mn2, mx2) = if c < d { (c, d) } else { (d, c) };
    c = mn2; d = mx2;
    let (mn3, mx3) = if a < c { (a, c) } else { (c, a) };
    a = mn3; c = mx3;
    let (mn4, mx4) = if b < d { (b, d) } else { (d, b) };
    b = mn4; d = mx4;
    let (mn5, mx5) = if b < c { (b, c) } else { (c, b) };
    b = mn5; c = mx5;
    a | (b << 16) | (c << 32) | (d << 48)
}
rustc -C opt-level=3 x86_64 Disassembly (114 B .text / 34 insns)
branchless_sort4_u64:
    movzx    eax, di
    mov    ecx, edi
    shr    ecx, 16
    mov    rdx, rdi
    shr    rdx, 32
    shr    rdi, 48
    cmp    rax, rcx
    mov    rsi, rcx
    cmova    rsi, rax
    movzx    edx, dx
    cmovb    rcx, rax
    cmp    rdx, rdi
    mov    r8, rdi
    cmova    r8, rdx
    cmovae    rdx, rdi
    cmp    rcx, rdx
    mov    rdi, rdx
    cmova    rdi, rcx
    cmovb    rdx, rcx
    cmp    rsi, r8
    mov    rax, r8
    cmova    rax, rsi
    cmovb    r8, rsi
    cmp    r8, rdi
    mov    rcx, rdi
    cmova    rcx, r8
    cmovae    r8, rdi
    shl    r8d, 16
    or    r8, rdx
    shl    rcx, 32
    or    rcx, r8
    shl    rax, 48
    or    rax, rcx
    ret

Head-to-Head Functional Equivalence Class Peers (1 Implementation(s) Matching 64 Test Vectors)

Global RankCapsule & DomainHardware _rdtscLatencyThroughputELF .textTernary VoteAuthor Aye
#38branchless_sort4_u64 (THIS CAPSULE)
domain: sort | id: 4ec62cf5f69d72eab388ab133d5d2943
1331441/400000 cyc/op634243/400000 ns/op400000000/634243 ops/us114 B .text (34 insns)+ (1)aye::Hue+Gemini(0+1)::x86_64 @ 432Hz