Pass array into Rust thread without cloning

[winstxnhdw]

Hey, I am wondering if there's a way to pass &[u8] into a Rust thread without having to clone it.

#[pyfunction]
fn gxhash128_async<'p>(py: Python<'p>, input_bytes: &[u8], seed: i64) -> PyResult<Bound<'p, PyAny>> {
    pyo3_async_runtimes::tokio::future_into_py(py, async move {
        let result = tokio::task::spawn_blocking(move || gxhash::gxhash128(&input_bytes, seed)).await.unwrap();
        Ok(result)
    })
}

input_bytes can be very very large, perhaps larger than 100 GB. Cloning wouldn't be feasible here for performance and memory reasons. Doing to_vec() made this binding 6x slower than its non-cloned counterpart.

My guess is that there is no way as this is also the reason why Polars is so slow when creating a DataFrame.

[ghost]

Have you considered using Arc::clone()? It is supposed to be faster than cloning a vector since it does not clone all the data, just a reference instead. Additionally, when using Arc::clone() one can share a value between multiple threads. I am not quite sure whether it can be done without cloning. However, if you will use just a one thread you can pass the ownership.

[winstxnhdw]

ChatGPT is cooking the new generation of programmers 😭

[winstxnhdw]

Anyways, my solution to overcome the slow data marshaling is by passing the file descriptor from Python and mmaping it in Rust. I might also experiment and profile passing a Rust memoryview into Python and letting Python populate the view.

[mejrs]

bytes is easier to share and you can keep around a reference to its contents without the gil.

[winstxnhdw]

Unfortunately, the issue here is that the Rust thread can technically outlive Python. That's why as long as the memory is owned by Python, I won't be able to move the memory into the thread without cloning in some form.