Tracking Issue for `slice_swap_unchecked`

[ibraheemdev]

Feature gate: #![feature(slice_swap_unchecked)]

This is a tracking issue for slice::swap_unchecked, an unsafe version of slice::swap that does not do bounds checking.

Public API

impl<T> [T] {
    pub const unsafe fn swap_unchecked(&mut self, a: usize, b: usize);
}

Steps / History

• Implementation: add slice::swap_unchecked #88540
• Revert implementation of slice::swap: Revert implementation of slice::swap #94342.
• Final comment period (FCP)
• Stabilization PR

Unresolved Questions

• None yet.

[workingjubilee]

This function seems pretty niche, not actually that hard to implement as unsafe code goes, and it seems doubtful it is going to have a lot of users, while it will add more noise to every single instance of the slice method documentation which is transcluded into... many other types. Is it really appropriate for std?

And if it was to make it easier for performance wins, it seems an unfounded assumption based on the idea that unsafe code is inherently faster (as opposed to potentially a blocker for optimization). The attempt to use it in std to implement swap was itself reverted.

[ZuseZ4]

@workingjubilee (shouldn't there be a zulip thread for discussions)?

During my autodiff benchmarking, I noticed that a fast Fourier transformation in safe Rust was 20% slower than in unsafe Rust or C++. Usually under autodiff safe Rust is (much) faster, so I profiled it, and it was due to bounds checking in swap. I talked about it with Nikita, who told me that recursive divide-and-conquer implementations (like this fft benchmark) are a hard case for LLVM and unlikely to get optimized in the foreseeable future. My autodiff fft benchmark (which I just upstream as tests from r-l/enzyme to r-l/r) therefore uses this feature.

I agree that it's probably too niche to be worth a spot in our documentation/std.
However, to address your second paragraph, there are cases out there where this function helps and where we get significant perf improvements. https://github.com/rust-lang/enzyme/blob/098e4dacef0a5c984ace21b522cdb95b21c238b8/enzyme/benchmarks/ReverseMode/fft/src/safe.rs#L15

// Safe option
            //data.swap(j-1, i-1);
            //data.swap(j, i);
// Unsafe option
            unsafe {
                let myptr = data.as_mut_ptr();
                std::ptr::swap(myptr.add(j-1), myptr.add(i-1));
                std::ptr::swap(myptr.add(j), myptr.add(i));
            }
// Unsafe option with this feature
            //unsafe {
            //    data.swap_unchecked(j - 1, i - 1);
            //    data.swap_unchecked(j, i);
            //}