rayon

Rayon is a data-parallelism library for Rust that makes it easy to convert sequential computations into parallel ones. It aims to provide safe, efficient, and user-friendly parallel iterators and computations. The core idea behind Rayon is to take advantage of multi-core processors by distributing work across multiple threads, thereby speeding up computations, especially on large collections.

How it Works:
Rayon extends Rust's standard iterator traits with parallel versions. Instead of calling `iter()` on a collection, you can call `par_iter()` (or `par_iter_mut()` for mutable access, or `into_par_iter()` for consuming the collection). Once you have a parallel iterator, you can use a wide range of methods similar to standard iterators (e.g., `map`, `filter`, `fold`, `reduce`, `for_each`, `sum`, `collect`) but these operations will be executed in parallel by Rayon's internal thread pool.

Rayon automatically manages a thread pool and employs a work-stealing scheduler. This means that if one thread finishes its assigned tasks early, it can "steal" work from other busy threads, ensuring good load balancing and efficient utilization of all available CPU cores without requiring manual thread management from the programmer.

Key Features and Benefits:
* Ease of Use: Often, converting a sequential loop or iterator chain to its parallel equivalent is as simple as changing `iter()` to `par_iter()`. No complex thread management code is required.
* Safety: Built upon Rust's strong type system and ownership rules, Rayon guarantees data race freedom and memory safety. It leverages markers like `Send` and `Sync` to ensure that data accessed across threads is handled correctly.
* Performance: By utilizing all available CPU cores efficiently with its work-stealing scheduler, Rayon can significantly speed up computationally intensive tasks that can be parallelized.
* Composability: Rayon's parallel iterators are designed to compose seamlessly with other Rust features and standard library patterns.
* Flexibility: It supports a variety of parallel patterns including mapping, filtering, reducing, folding, and more specialized operations.

Common Use Cases:
* Processing large datasets (e.g., transforming elements in a `Vec`).
* Numerical computations (e.g., matrix operations, calculating sums or products).
* Image processing (e.g., applying filters to pixels).
* Any task where elements in a collection can be processed independently of each other.

use rayon::prelude::*;

fn main() {
    let data: Vec<u64> = (0..1_000_000).collect();

    // --- Sequential computation for comparison ---
    let start_seq = std::time::Instant::now();
    let sum_squares_seq: u64 = data.iter()
                                   .map(|&x| x * x)
                                   .sum();
    let duration_seq = start_seq.elapsed();
    println!("Sequential sum of squares: {} (took {:?})", sum_squares_seq, duration_seq);

    // --- Parallel computation using Rayon ---
    let start_par = std::time::Instant::now();
    let sum_squares_par: u64 = data.par_iter()
                                   .map(|&x| x * x)
                                   .sum();
    let duration_par = start_par.elapsed();
    println!("Parallel sum of squares: {} (took {:?})", sum_squares_par, duration_par);

    assert_eq!(sum_squares_seq, sum_squares_par);
    println!("Both sums are equal.");

    // Example of another parallel operation: filtering and collecting
    let even_numbers_squared_parallel: Vec<u64> = data.par_iter()
                                                    .filter(|&&x| x % 2 == 0)
                                                    .map(|&x| x * x)
                                                    .collect();
    println!("Number of even squares collected: {}", even_numbers_squared_parallel.len());
}

// To run this example, add the following to your Cargo.toml:
// [dependencies]
// rayon = "1.x"