Có thể viết hàm InvSqrt () nhanh của Quake trong Rust không?

Đây chỉ là để thỏa mãn sự tò mò của riêng tôi.

Có thực hiện điều này:

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

ở Rust? Nếu nó tồn tại, gửi mã.

Tôi đã thử nó và thất bại. Tôi không biết cách mã hóa số float bằng định dạng số nguyên. Đây là nỗ lực của tôi:

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
}

Tham khảo:
1. Nguồn gốc của InvSqrt nhanh của Quake3 () - Trang 1
2. Tìm hiểu căn bậc hai nghịch đảo nhanh của Quake
3. TÌM KIẾM NHANH CHÓNG ROOT.pdf
4. mã nguồn: q_math.c # L552-L572

Tôi không biết cách mã hóa số float bằng định dạng số nguyên.

Có một chức năng cho rằng: f32::to_bitstrả về một u32. Ngoài ra còn có chức năng cho hướng khác: f32::from_bitslấy tham u32số làm đối số. Các chức năng này được ưa thích hơn mem::transmutelà chức năng sau unsafevà khó sử dụng.

Cùng với đó, đây là việc thực hiện 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)
}

( Sân chơi )

Hàm này biên dịch thành cụm sau trên 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

Tôi chưa tìm thấy bất kỳ hội nghị tham khảo nào (nếu bạn có, xin vui lòng cho tôi biết!), Nhưng nó có vẻ khá tốt với tôi. Tôi chỉ không chắc chắn tại sao float được chuyển vào eaxchỉ để thực hiện phép trừ và thay đổi số nguyên. Có lẽ các thanh ghi SSE không hỗ trợ các hoạt động đó?

clang 9.0 với -O3biên dịch mã C về cơ bản giống nhau . Vì vậy, đó là một dấu hiệu tốt.

Điều đáng nói là nếu bạn thực sự muốn sử dụng điều này trong thực tế: xin đừng. Như benrg đã chỉ ra trong các bình luận , CPU x86 hiện đại có một hướng dẫn chuyên biệt cho chức năng này nhanh hơn và chính xác hơn bản hack này. Thật không may, 1.0 / x.sqrt() dường như không tối ưu hóa theo hướng dẫn đó . Vì vậy, nếu bạn thực sự cần tốc độ, sử dụng các _mm_rsqrt_psintrinsics có lẽ là con đường để đi. Điều này, tuy nhiên, một lần nữa yêu cầu unsafemã. Tôi sẽ không đi sâu vào chi tiết trong câu trả lời này, vì một số ít các lập trình viên sẽ thực sự cần nó.

Điều này được thực hiện với ít được biết đến uniontrong 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)
    }
}

Có một số điểm chuẩn vi mô bằng cách sử dụng criterionthùng trên hộp Linux x86-64. Đáng ngạc nhiên là riêng của Rust sqrt().recip()là nhanh nhất. Nhưng tất nhiên, bất kỳ kết quả điểm chuẩn vi mô nên được thực hiện với một hạt muối.

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]

Bạn có thể sử dụng std::mem::transmuteđể thực hiện chuyển đổi cần thiết:

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
}

Bạn có thể tìm một ví dụ trực tiếp tại đây: tại đây