เป็นไปได้ไหมที่จะเขียนฟังก์ชัน InvSqrt () ของ Quake ใน Rust?

นี่เป็นเพียงเพื่อสนองความอยากรู้อยากเห็นของฉันเอง

มีการดำเนินการตามนี้หรือไม่:

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

ในสนิม ถ้ามีอยู่โพสต์รหัส

ฉันลองแล้วล้มเหลว ฉันไม่ทราบวิธีเข้ารหัสตัวเลขทศนิยมโดยใช้รูปแบบจำนวนเต็ม นี่คือความพยายามของฉัน:

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
}

การอ้างอิง:
1. ต้นกำเนิดของ Fast InvSqrt () ของ Quake3 - หน้า 1
2. ทำความเข้าใจกับรากที่สองของ Quake ได้อย่างรวดเร็ว
3. FAST INVERSE SQUARE ROOT.pdf
4. ซอร์สโค้ด: q_math.c # L552-L572

ฉันไม่ทราบวิธีเข้ารหัสตัวเลขทศนิยมโดยใช้รูปแบบจำนวนเต็ม

: มีฟังก์ชั่นที่เป็นที่ส่งกลับf32::to_bits u32นอกจากนี้ยังมีฟังก์ชั่นสำหรับทิศทางอื่น: f32::from_bitsซึ่งใช้u32เป็นอาร์กิวเมนต์ ฟังก์ชั่นเหล่านี้เป็นที่นิยมมากกว่าmem::transmuteเนื่องจากมีความunsafeยุ่งยากในการใช้งาน

โดยที่นี่คือการดำเนินการของ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)
}

( สนามเด็กเล่น )

ฟังก์ชันนี้รวบรวมการประกอบต่อไปนี้ใน 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

ฉันไม่พบชุดข้อมูลอ้างอิงใด ๆ (ถ้าคุณมีโปรดบอกฉัน!) แต่มันดูดีสำหรับฉัน ฉันไม่แน่ใจว่าทำไมการเลื่อนถูกย้ายเข้ามาeaxเพียงแค่ทำการเปลี่ยนกะและการลบจำนวนเต็ม บางทีการลงทะเบียน SSE ไม่สนับสนุนการดำเนินการเหล่านั้น

เสียงดังกราว 9.0 -O3compiles รหัส C เพื่อพื้นการชุมนุมเดียวกัน นั่นเป็นสัญญาณที่ดี

เป็นมูลค่าชี้ให้เห็นว่าถ้าคุณต้องการใช้สิ่งนี้ในทางปฏิบัติ: โปรดอย่า benrg ชี้ให้เห็นในความคิดเห็นซีพียู x86 ที่ทันสมัยมีคำสั่งพิเศษสำหรับฟังก์ชั่นนี้ซึ่งเร็วกว่าและแม่นยำกว่าแฮ็คนี้ น่าเสียดายที่1.0 / x.sqrt() ดูเหมือนจะไม่ได้ปรับการเรียนการสอนให้เหมาะสม ดังนั้นหากคุณต้องการความเร็วจริงๆใช้intrinsicsน่าจะเป็นวิธีที่จะไป อย่างไรก็ตามสิ่งนี้ต้องการรหัสอีกครั้ง ฉันจะไม่ลงรายละเอียดมากนักในคำตอบนี้เนื่องจากโปรแกรมเมอร์ส่วนน้อยจะต้องการมัน_mm_rsqrt_psunsafe

สิ่งนี้ถูกนำไปใช้งานโดยที่ไม่ค่อยมีคนรู้จักunionในสนิม:

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

ทำเกณฑ์มาตรฐานขนาดเล็กบางอย่างโดยใช้criterionลังบนกล่อง x86-64 Linux น่าประหลาดใจที่ Rust เป็นของตัวเองsqrt().recip()เร็วที่สุด แต่แน่นอนว่าผลการวัดประสิทธิภาพขนาดเล็กควรได้รับเม็ดเกลือ

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]

คุณอาจใช้std::mem::transmuteเพื่อทำการแปลงที่ต้องการ:

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
}

คุณสามารถค้นหาตัวอย่างสดได้ที่นี่: ที่นี่