Struct BarrierSync

pub struct BarrierSync { /* private fields */ }

Available on crate feature chili only.

This very simple implementation uses the [hurdles::Barrier] struct which should in theory perform faster than the std::sync::Barrier struct from the standard library.

By using the SyncSubDomains trait, we can automatically create a collection of syncers which can then be simply given to the respective threads and handle synchronization.

let map = BTreeMap::from_iter([
    (0, std::collections::BTreeSet::from([1])),
    (1, std::collections::BTreeSet::from([0])),
]);
let mut syncers = BarrierSync::from_map(&map).unwrap();
assert_eq!(syncers.len(), 2);

let mut syncer_0 = syncers.remove(&0).unwrap();
let mut syncer_1 = syncers.remove(&1).unwrap();

// Define the number of iterations to run
let n_iterations = 10;
let shared_counter = std::sync::Arc::new(std::sync::Mutex::new(0_i64));

let shared_counter_0 = std::sync::Arc::clone(&shared_counter);
let handle_0 = std::thread::spawn(move || {
    for _ in 0..n_iterations {
        syncer_0.sync().unwrap();
        *shared_counter_0.lock().unwrap() += 1;
        syncer_0.sync().unwrap();
    }
});

for i in 0..n_iterations {
    syncer_1.sync().unwrap();
    syncer_1.sync().unwrap();
    assert_eq!(*shared_counter.lock().unwrap(), i+1);
}
handle_0.join();

Trait Implementations

impl<I> BuildFromGraph<I> for BarrierSync

where I: Clone + Eq + Hash + Ord,

fn build_from_graph( graph: UDGraph<I>, ) -> Result<BTreeMap<I, BarrierSync>, IndexError>

Builds the BTreeMap

impl<I> FromMap<I> for BarrierSync

fn from_map( map: &BTreeMap<I, BTreeSet<I>>, ) -> Result<BTreeMap<I, BarrierSync>, IndexError>

where I: Eq + Hash + Clone + Ord,

SubDomains can be neighboring each other via complicated graphs. An easy way to represent this is by using a BTreeMap. We want to create Barriers which match the specified subdomain indices.

impl SyncSubDomains for BarrierSync

fn sync(&mut self) -> Result<(), SimulationError>

Function which forces connected syncers to wait for each other. This approach does not necessarily require all threads to wait but can mean that only depending threads wait for each other.

fn store_error( &mut self, maybe_error: Result<(), SimulationError>, ) -> Result<bool, SimulationError>

TODO