Rust Cookbook - Data Parallelism

[asbates]

Linking this here for reference. The Rust Cookbook chapter on concurrency has a section called Data Parallelism. This should be really helpful because it gives examples which are effectively mutate, filter, and arrange in parallel.

[jdhoffa]

Originally posted by @jonocarroll in #25 (comment)

I don't know where better to put this - I was curious about the difference between thread and rayon and had a go at building a comparison myself. Rayon seems easier to set up, unless you want to specify the number of threads and re-use a thread pool, but even then it wasn't so bad.

What surprised me was that compared to just doing x.iter().sum() it's a lot more overhead and it's not clear that it's worth it, at least for the 'sum this random data' test case I implemented

> cargo run --release

567270539
Sum with single thread: 56.96µs
567270539
Sum with 2 threads: 229.21µs
567270539
Sum with rayon (2 threads): 173.04µs
567270539
Sum with 4 threads: 185.79µs
567270539
Sum with rayon (4 threads): 101.29µs
567270539
Sum with 8 threads: 229.67µs
567270539
Sum with rayon (8 threads): 276.13µs

Maybe I implemented something wrong - I haven't played with multithreading in Rust before, so this is a great opportunity for me to learn.

[jdhoffa]

@jonocarroll responding here 😊

As we are still in the learning stage (e.g. learning Rust, learning about multi-threading, learning about savvy, etc.) I thought it would be simplest to build a "dummy-feature" re-implementing a vector sum with multiple threads (see #15), and using thread implicitly as this is the simplest suggestion in the Rust handbook. The function is just a proof-of-concept that we can write a multi-threaded Rust back-end and expose it to an R session.

However, I didn't really expect performance gains yet (with the operation implemented), as I think with such a simple operation, splitting the vector into chunks (and re-combining) is probably more expensive than any performance gains we would get using multiple threads.

I did some benchmarking, and it looks like we might start to see some performance gains when summing very large vectors (~1 million elements), however, this is only comparing the single and multi-threaded versions of the function we wrote. base::sum still seems to out-perform in every case.

Really though, the goal of the package, is to implement multi-threading for some standard dplyr functions on data-frames (See #22). My expectation/ strong suspicion is that we will end up using rayon once we start to build out those features, and that we may actually be able to see performance improvements when operating on very large data-frames (I hope 😃)

[jdhoffa]

There is also totally a chance that the price of copying those data to the Rust session will make it so that it's never actually worth it to do this 🤣

We shall see!!