Apakah mungkin untuk menulis fungsi InvSqrt () cepat Quake di Rust?

Ini hanya untuk memuaskan rasa penasaran saya sendiri.

Apakah ada implementasi ini:

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

di Rust? Jika ada, kirim kode.

Saya mencobanya dan gagal. Saya tidak tahu cara menyandikan angka float menggunakan format integer. Ini usaha saya:

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
}

Referensi:
1. Origin of Quake3's Fast InvSqrt () - Halaman 1
2. Memahami Root Inverse Square Cepat Quake
3. ROAST INVESTE SQUARE ROOT.pdf
4. kode sumber: q_math.c # L552-L572

Saya tidak tahu cara menyandikan angka float menggunakan format integer.

Ada fungsi untuk itu: f32::to_bitsmengembalikan suatu u32. Ada juga fungsi untuk arah lain: f32::from_bitsyang mengambil u32argumen sebagai. Fungsi-fungsi ini lebih disukai daripada mem::transmuteyang terakhir unsafedan sulit untuk digunakan.

Dengan itu, berikut adalah implementasi dari 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)
}

( Taman bermain )

Fungsi ini mengkompilasi ke rakitan berikut pada 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

Saya belum menemukan rakitan referensi (jika ada, tolong beri tahu saya!), Tetapi tampaknya cukup baik bagi saya. Saya hanya tidak yakin mengapa float dipindahkan ke eaxhanya untuk melakukan shift dan pengurangan integer. Mungkin register SSE tidak mendukung operasi itu?

dentang 9.0 dengan -O3mengkompilasi kode C pada dasarnya majelis yang sama . Jadi itu pertanda baik.

Perlu ditunjukkan bahwa jika Anda benar-benar ingin menggunakan ini dalam praktik: tolong jangan. Seperti yang ditunjukkan Benrg dalam komentar , CPU x86 modern memiliki instruksi khusus untuk fungsi ini yang lebih cepat dan lebih akurat daripada peretasan ini. Sayangnya, 1.0 / x.sqrt() sepertinya tidak mengoptimalkan instruksi itu . Jadi, jika Anda benar-benar membutuhkan kecepatan, menggunakan yang _mm_rsqrt_psintrinsik mungkin adalah cara untuk pergi. Namun, ini tidak lagi membutuhkan unsafekode. Saya tidak akan membahas banyak detail dalam jawaban ini, karena sebagian kecil programmer benar-benar membutuhkannya.

Yang ini diimplementasikan dengan kurang dikenal uniondi 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)
    }
}

Apakah beberapa tolok ukur mikro menggunakan criterionpeti pada kotak Linux x86-64. Anehnya Rust sendiri sqrt().recip()yang tercepat. Tetapi tentu saja, setiap hasil patokan mikro harus diambil dengan sebutir garam.

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]

Anda dapat menggunakan std::mem::transmuteuntuk membuat konversi yang dibutuhkan:

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
}

Anda dapat mencari contoh langsung di sini: di sini