Rust zero-cost handling of C two-dimensional array without pointer arithmetic?

Question

I’m porting old C audio processing code to Rust. All over the place there are functions that receive two-dimensional float arrays (float**), along with their respective lengths (in other words, audio sample buffers, with their number of channels and samples).

In C those are accessed like

for (int c=0; c<channels; c++) {
    for (int s=0; s<samples; s++) {
        buffer[c][s] = 0.0f;
    }
}

In Rust, I suppose one could go with the usual pointer arithmetic (*(*buffer.add(c)).add(s)) just as well considering the length of the arrays are known at all times, but if there is a method that

incurs no considerable extra cost/extra allocations relative to the C/pointer arithmetic method (considering the cost of bound checks negligible, since it would also incur if the function was pure Rust without FFI in the first place)
involves no pointer arithmetic (or is at least safer than direct raw pointer manipulation)

I would like to know of such a method.

At first I assumed C arrays of arrays would translate to Rust slices of slices (&mut [&mut [f32]]) in Rust, but that conversion seems to be neither trivial nor ideal, hence the new question.

If performance is critical then I don't see a problem with pointer arithmetic. — freakish
– freakish, Commented May 21, 2024 at 15:29
Are the channel and sample counts only passed because of C's limitations on passing arrays, or are they being passed because you're working with a subset of the 2D array? And to be clear, do they need to be arrays of refs/pointers to arrays (as in C), or is a flat 2D array (single contiguous allocation) okay? — ShadowRanger
– ShadowRanger, Commented May 21, 2024 at 15:30
@freakish Thank you for the confirmation. Performance is critical, but if there is a safer alternative that is just as performant... (wishful thinking?) — arghhh
– arghhh, Commented May 21, 2024 at 15:33
@ShadowRanger I'd say it's because of C's limitations. The original C API passes them around as float**, but (if my memory serves me right) they should be contiguous in memory. Does that allow for a specific trick that wouldn't be possible otherwise? — arghhh
– arghhh, Commented May 21, 2024 at 15:37
Seems unlikely that they would be contiguous in memory, the top-level array has to store pointers to the sub-arrays, so it's not just a reshaping. What you could do for safety is wrap the entire thing in a 2D API which would take care of the pointer management for you. Also the top-level array can be converted to a slice, it's the internal arrays which can't because the type signature for a slice is a fat pointer. — Masklinn
– Masklinn, Commented May 21, 2024 at 15:47

ShadowRanger · Accepted Answer · 2024-05-21 16:09:18Z

You can make a contiguous 2D slice of slices from a Rust Vec without too much trouble, and let Rust optimize away most bounds checking:

fn init_buffer(buffer: &mut [&mut [f32]]) -> () {
    let mut f = 1.0;
    for row in buffer {
        for cell in row.iter_mut() {
            *cell = f;
            f += 1.0;
        }
    }
}

fn main() {
    let channels = 10;
    let samples = 15;
    // Base 1d array
    let mut buf_raw = vec![0.0; channels * samples];

    // Vector of 'width' elements slices
    let mut buf: Vec<_> = buf_raw.as_mut_slice().chunks_mut(samples).collect();

    init_buffer(buf.as_mut_slice());
    println!("{buf:?}");
}

Rust Playground link

I had it assign differing values just to make it obvious that it's working. The function, not knowing the data is contiguous, does need to check the slice widths per-slice to bound the loop, but the incremental overhead should be pretty minimal; it's not bounds-checking per cell. If the function gets inlined, the optimizer may be able to eliminate that work. It's may be faster than the C code (depending on precisely how the C code created the 2D array), as the underlying data is fully contiguous (the layout is very close to the ideal C code for runtime defined "contiguous" 2D arrays, where C would use an array of pointers into a 1D array containing all the data contiguously), reducing cache misses and the like, where a C array of pointers that dynamically allocates each sub-array would be more fragmented.

Collectives™ on Stack Overflow

Rust zero-cost handling of C two-dimensional array without pointer arithmetic?

1 Answer 1

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related