or is it???
“”"
It’s All Sunshine and Rainbows (2023)
Weather Professional Melonie Sunshine (Priyanka) returns home to set the family wedding business right. Her unexpected business partner, Nick Rainbow (Curtis Lovell), has other plans.
“”"
https://www.imdb.com/title/tt28816987/

Beyond Fearless Concurrency: The Challenges of Parallelism in Rust

Rust’s fearless concurrency model is one of its biggest selling points.

By enforcing memory safety at compile time, Rust eliminates many of the data races and deadlocks that plague traditional languages like C++ and Java. H

However, a recent study of Rust Parallel Benchmark Suite (RPB) suggests that while Rust makes regular parallelism easy and safe, it struggles with irregular parallelism.

The study referenced is from the University of Toronto’s Electrical and Computer Engineering Department

When Is Parallelism Fearless and Zero-Cost with Rust?
https://dl.acm.org/doi/10.1145/3626183.3659966

Slides for Presentation on the Paper
https://www.eecg.utoronto.ca/~mcj/talks/2024.rpb.slides.spaa.pdf

The Paper
https://www.eecg.utoronto.ca/~mcj/papers/2024.rpb.spaa.pdf

The Two Faces of Parallelism

Parallel programming can generally be classified into two broad categories:

Regular Parallelism – Operations are structured, predictable, and easy to parallelize (e.g., matrix multiplications, parallel sorting, array summation).
Irregular Parallelism – Operations have dynamic or unpredictable access patterns (e.g., graph algorithms, adaptive mesh refinement, dynamic scheduling).

Rust excels at regular parallelism, but its strict ownership and borrowing rules make expressing irregular parallelism challenging.

Strengths: Rust’s Fearless Concurrency in Regular Parallelism

Rust provides a safe and efficient model for structured parallelism through libraries like Rayon.

Example: Parallel Array Summation in Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
use rayon::prelude::*;

fn parallel_sum(arr: &[i32]) -> i32 {
    arr.par_iter().sum()
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let result = parallel_sum(&numbers);
    println!("Sum: {}", result);
}

Why This Works Well in Rust

✅ Immutable references prevent data races.
✅ Workloads are evenly distributed among threads.
✅ No unsafe code needed – Rayon manages parallel execution.

For workloads where data dependencies are clear, Rust’s concurrency model shines. However, the story changes when dealing with irregular data structures like graphs and dynamically allocated tasks.

Weaknesses: Rust’s Challenges in Irregular Parallelism

Rust’s ownership model can make it difficult to express algorithms with dynamic memory access patterns, such as graph traversal, load balancing, and dynamic task scheduling.

Example: Attempting Parallel Graph Traversal in Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
use rayon::prelude::*;
use std::collections::HashMap;
use std::sync::Mutex;

fn parallel_graph_traversal(graph: &HashMap<i32, Vec<i32>>) {
    let visited = Mutex::new(vec![]);
    
    graph.par_iter().for_each(|(node, neighbors)| {
        let mut v = visited.lock().unwrap();
        v.push(*node);
    });
}

Why This Is a Problem

❌ Mutex usage creates contention, slowing down parallel execution.
❌ Graph nodes may be accessed in arbitrary order, making borrowing rules hard to enforce.
❌ Dynamic memory access prevents static compile-time guarantees.

This leads developers to resort to unsafe Rust, negating many of Rust’s safety benefits.

Key Findings from the Rust Parallel Benchmark Suite (RPB)

A study on Rust vs. C++ benchmarks found that:

Rust performs well for regular parallelism but struggles with irregular parallelism.
Using unsafe code is often necessary for competitive performance in irregular workloads.
Rust incurs performance penalties when strict ownership rules force unnecessary synchronization.

In benchmarks using irregular access patterns, Rust was on average 1.44x slower than C++ when using safe Rust.

Potential Solutions for Rust’s Irregular Parallelism Problem

While Rust currently struggles with irregular parallelism, the community is exploring solutions:

1. More Advanced Parallel Libraries

Libraries like Rayon work great for simple parallel workloads but need extensions for dynamic task scheduling.

2. Transactional Memory Support

Rust could benefit from transactional memory models to support dynamic workloads without locks.

3. Compiler Enhancements

Better compiler optimizations for dynamic data structures could reduce synchronization overhead.

4. Safe Abstractions for Unsafe Code

Instead of forcing developers to use unsafe, Rust could introduce higher-level APIs for irregular parallelism.

Conclusion: Rust’s Path to More Versatile Parallelism

Rust’s fearless concurrency makes it excellent for structured parallel workloads. However, its strict ownership and borrowing rules pose challenges for irregular parallel workloads.

To compete with C++ in all areas of parallel computing, Rust needs better abstractions for irregular parallelism without sacrificing safety. With active research and library development, Rust is likely to become a more versatile parallel programming language in the near future.

Rust Concurrency-Not All Sunshine and Rainbows

Exploring how Rust truggles with irregular parallelism