È possibile scrivere la funzione invSqrt () di Quake in Rust?

Questo è solo per soddisfare la mia curiosità.

C'è un'implementazione di questo:

float InvSqrt (float x)
{
   float xhalf = 0.5f*x;
   int i = *(int*)&x;
   i = 0x5f3759df - (i>>1);
   x = *(float*)&i;
   x = x*(1.5f - xhalf*x*x);
   return x;
}

in ruggine? Se esiste, pubblica il codice.

L'ho provato e non ci sono riuscito. Non so come codificare il numero float usando il formato intero. Ecco il mio tentativo:

fn main() {
    println!("Hello, world!");
    println!("sqrt1: {}, ",sqrt2(100f64));
}

fn sqrt1(x: f64) -> f64 {
    x.sqrt()
}

fn sqrt2(x: f64) -> f64 {
    let mut x = x;
    let xhalf = 0.5*x;
    let mut i = x as i64;
    println!("sqrt1: {}, ", i);

    i = 0x5f375a86 as i64 - (i>>1);

    x = i as f64;
    x = x*(1.5f64 - xhalf*x*x);
    1.0/x
}

Riferimento:
1. Origine di Fast InvSqrt di Quake3 () - Pagina 1
2. Comprensione della radice quadrata inversa veloce di Quake
3. FAST INVERSE SQUARE ROOT.pdf
4. codice sorgente: q_math.c # L552-L572

Non so come codificare il numero float usando il formato intero.

C'è una funzione per questo: f32::to_bitsche restituisce un u32. C'è anche la funzione per l'altra direzione: f32::from_bitsche accetta un u32argomento come. Queste funzioni sono preferite rispetto mem::transmutea quest'ultimaunsafe e difficili da usare.

Con ciò, ecco l'implementazione di InvSqrt:

fn inv_sqrt(x: f32) -> f32 {
    let i = x.to_bits();
    let i = 0x5f3759df - (i >> 1);
    let y = f32::from_bits(i);

    y * (1.5 - 0.5 * x * y * y)
}

( Parco giochi )

Questa funzione viene compilata nel seguente assembly su x86-64:

.LCPI0_0:
        .long   3204448256        ; f32 -0.5
.LCPI0_1:
        .long   1069547520        ; f32  1.5
example::inv_sqrt:
        movd    eax, xmm0
        shr     eax                   ; i << 1
        mov     ecx, 1597463007       ; 0x5f3759df
        sub     ecx, eax              ; 0x5f3759df - ...
        movd    xmm1, ecx
        mulss   xmm0, dword ptr [rip + .LCPI0_0]    ; x *= 0.5
        mulss   xmm0, xmm1                          ; x *= y
        mulss   xmm0, xmm1                          ; x *= y
        addss   xmm0, dword ptr [rip + .LCPI0_1]    ; x += 1.5
        mulss   xmm0, xmm1                          ; x *= y
        ret

Non ho trovato alcun assemblaggio di riferimento (se sì, per favore dimmelo!), Ma mi sembra abbastanza buono. Non sono sicuro del perché il float sia stato spostatoeax solo per fare la sottrazione di spostamento e numero intero. Forse i registri SSE non supportano tali operazioni?

clang 9.0 con -O3compila il codice C sostanzialmente nello stesso assembly . Quindi questo è un buon segno.

Vale la pena sottolineare che se in realtà si desidera utilizzare questo in pratica: per favore non farlo. Come sottolineato da Benrg nei commenti , le moderne CPU x86 hanno un'istruzione specializzata per questa funzione che è più veloce e più accurata di questo hack. Sfortunatamente, 1.0 / x.sqrt() non sembra ottimizzare a tale istruzione . Quindi, se hai davvero bisogno della velocità, usare l' _mm_rsqrt_psintrinseca è probabilmente la strada da percorrere. Ciò, tuttavia, richiede nuovamente il unsafecodice. Non entrerò nei dettagli in questa risposta, in quanto una minoranza di programmatori ne avrà effettivamente bisogno.

Questo è implementato con meno conosciuto unionin Rust:

union FI {
    f: f32,
    i: i32,
}

fn inv_sqrt(x: f32) -> f32 {
    let mut u = FI { f: x };
    unsafe {
        u.i = 0x5f3759df - (u.i >> 1);
        u.f * (1.5 - 0.5 * x * u.f * u.f)
    }
}

Alcuni micro benchmark hanno usato la criterioncassa su una scatola Linux x86-64. Sorprendentemente, quello di Rust sqrt().recip()è il più veloce. Ma ovviamente, qualsiasi risultato di micro benchmark dovrebbe essere preso con un granello di sale.

inv sqrt with transmute time:   [1.6605 ns 1.6638 ns 1.6679 ns]
inv sqrt with union     time:   [1.6543 ns 1.6583 ns 1.6633 ns]
inv sqrt with to and from bits
                        time:   [1.7659 ns 1.7677 ns 1.7697 ns]
inv sqrt with powf      time:   [7.1037 ns 7.1125 ns 7.1223 ns]
inv sqrt with sqrt then recip
                        time:   [1.5466 ns 1.5488 ns 1.5513 ns]

È possibile utilizzare std::mem::transmuteper effettuare la conversione necessaria:

fn inv_sqrt(x: f32) -> f32 {
    let xhalf = 0.5f32 * x;
    let mut i: i32 = unsafe { std::mem::transmute(x) };
    i = 0x5f3759df - (i >> 1);
    let mut res: f32 = unsafe { std::mem::transmute(i) };
    res = res * (1.5f32 - xhalf * res * res);
    res
}

Puoi cercare un esempio dal vivo qui: qui