Multithreading with multiple writes to same slice without lock

Michael-F-Bryan · December 7, 2020, 10:52am

I strongly suggest you read the first Rust Koan.

This feels complex because it is complex... Using unsafe Rust or C doesn't make it any less complex, it just makes the compiler warnings go away.

That said, you may want to have a look at rayon's implementation of a parallel merge sort for inspiration. It's mostly copied from the Rust standard library, with adaptations to enable parallelism.

github.com

rayon-rs/rayon/blob/1d0e9e240e1675c77eeb6bff0db8cf99d19cfc3d/src/slice/mergesort.rs

//! Parallel merge sort.
//!
//! This implementation is copied verbatim from `std::slice::sort` and then parallelized.
//! The only difference from the original is that the sequential `mergesort` returns
//! `MergesortResult` and leaves descending arrays intact.

use crate::iter::*;
use crate::slice::ParallelSliceMut;
use std::mem;
use std::mem::size_of;
use std::ptr;
use std::slice;

unsafe fn get_and_increment<T>(ptr: &mut *mut T) -> *mut T {
    let old = *ptr;
    *ptr = ptr.offset(1);
    old
}

unsafe fn decrement_and_get<T>(ptr: &mut *mut T) -> *mut T {

This file has been truncated. show original

Topic		Replies	Views
Lock-free parallel write to array and ownership help	6	2120	January 12, 2023
Writing to same array across threads help	9	3218	January 12, 2023
Unsafely share memory between threads (single sender, multiple receivers) help	24	3236	June 25, 2019
How can I modify data by muti-threading	3	813	January 12, 2023
Is there fine grained mutex in Rust? help	18	3203	January 12, 2023

Multithreading with multiple writes to same slice without lock

Related topics