Struct RayonLanes 

pub struct RayonLanes<'d> { /* private fields */ }

The Lanes implementation over a domain’s Rayon pool.

Creating one admits the domain, so the executor holds the domain’s one coarse operation slot for its whole lifetime. Each lane is one Rayon worker; the lane resource is () because the callback already runs on that worker.

Entry from a Rayon worker that does not belong to the domain pool is rejected, and so is entry while another operation owns the domain.

Example

use hataori::{Domain, Lanes, RayonLanes};
use std::sync::Arc;

let pool = Arc::new(rayon::ThreadPoolBuilder::new().num_threads(2).build().unwrap());
let domain = Domain::external(Arc::clone(&pool), vec![0, 1], 2).unwrap();
let mut lanes = RayonLanes::new(&domain).unwrap();
assert_eq!(lanes.lane_count(), 2);
let visited = std::sync::atomic::AtomicUsize::new(0);
lanes
    .run(|_index, (), _control| {
        visited.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
        Ok::<_, std::convert::Infallible>(())
    })
    .unwrap();
assert_eq!(visited.into_inner(), 2);

Implementations

impl<'d> RayonLanes<'d>

pub fn new(domain: &'d Domain) -> Result<Self, RayonLanesError>

Admits domain and builds a lane executor over its pool.

Errors

Returns RayonLanesError::MissingPool for a domain without a pool, RayonLanesError::ForeignPool when called from a different Rayon pool, and RayonLanesError::DomainBusy when the domain is already admitted.

Trait Implementations

impl Lanes for RayonLanes<'_>

type Lane<'l> = ()

The execution resource lent to one lane callback.

type Error = Infallible

A lane entry, join, or cleanup failure.

fn lane_count(&self) -> usize

Returns the number of lanes the executor runs.

fn run<E: Send>( &mut self, lane: impl Fn(usize, &mut (), &LaneControl<'_>) -> Result<(), E> + Sync, ) -> Result<(), LanesError<E, Self::Error>>

Runs lane on every lane, joins all of them, then resumes a lane panic.

fn run_with_coordinator<C, E: Send>( &mut self, coordinator: impl FnOnce(&LaneControl<'_>) -> Result<C, E>, lane: impl Fn(usize, &mut (), &LaneControl<'_>) -> Result<(), E> + Sync, ) -> Result<C, LanesError<E, Self::Error>>

Runs coordinator on the calling thread concurrently with every lane.