Ist es möglich, Quakes schnelle InvSqrt () -Funktion in Rust zu schreiben?

Dies ist nur, um meine eigene Neugier zu befriedigen.

Gibt es eine Implementierung davon:

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 Rust? Wenn es existiert, geben Sie den Code ein.

Ich habe es versucht und bin gescheitert. Ich weiß nicht, wie ich die Gleitkommazahl im Ganzzahlformat codieren soll. Hier ist mein Versuch:

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
}

Referenz:
1. Ursprung von Quake3s Fast InvSqrt () - Page 1
2. Grundlegendes zu Quakes Fast Inverse Square Root
3. FAST INVERSE SQUARE ROOT.pdf
4. Quellcode: q_math.c # L552-L572

Ich weiß nicht, wie ich die Gleitkommazahl im Ganzzahlformat codieren soll.

Dafür gibt es eine Funktion: f32::to_bitsdie ein zurückgibt u32. Es gibt auch die Funktion für die andere Richtung: f32::from_bitsdie ein u32als Argument nimmt. Diese Funktionen werden gegenüber mem::transmuteletzteren bevorzugt unsafeund sind schwierig zu bedienen.

Damit ist hier die Implementierung von 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)
}

( Spielplatz )

Diese Funktion wird auf x86-64 in die folgende Assembly kompiliert:

.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

Ich habe keine Referenzbaugruppe gefunden (wenn ja, bitte sagen Sie es mir!), Aber es scheint mir ziemlich gut zu sein. Ich bin mir nur nicht sicher, warum der Float nur bewegt wurde eax, um die Verschiebung und die Ganzzahlsubtraktion durchzuführen. Vielleicht unterstützen SSE-Register diese Operationen nicht?

clang 9.0 mit -O3kompiliert den C-Code auf im Grunde dieselbe Assembly . Das ist also ein gutes Zeichen.

Es sei darauf hingewiesen, dass Sie dies bitte nicht tun sollten, wenn Sie dies tatsächlich in der Praxis anwenden möchten. Wie benrg in den Kommentaren hervorhob , verfügen moderne x86-CPUs über eine spezielle Anweisung für diese Funktion, die schneller und genauer als dieser Hack ist. Leider 1.0 / x.sqrt() scheint sich diese Anweisung nicht zu optimieren . Wenn Sie also wirklich die Geschwindigkeit brauchen, ist die Verwendung der _mm_rsqrt_psIntrinsics wahrscheinlich der richtige Weg. Dies erfordert jedoch wieder unsafeCode. Ich werde in dieser Antwort nicht ins Detail gehen, da eine Minderheit der Programmierer sie tatsächlich brauchen wird.

Dieser ist mit weniger bekannt unionin Rust implementiert :

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)
    }
}

Habe einige Micro-Benchmarks mit criterioncrate auf einer x86-64-Linux-Box durchgeführt. Überraschenderweise ist Rusts eigene sqrt().recip()die schnellste. Aber natürlich sollte jedes Mikro-Benchmark-Ergebnis mit einem Körnchen Salz aufgenommen werden.

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]

Sie können verwenden std::mem::transmute, um die erforderliche Konvertierung vorzunehmen:

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
}

Hier können Sie nach einem Live-Beispiel suchen: hier