Trait dpc_pariter::IteratorExt

pub trait IteratorExt {
    fn parallel_map<F, O>(self, f: F) -> ParallelMap<Self, O>
    where
        Self: 'static + Iterator,
        F: 'static + Send + Clone + FnMut(Self::Item) -> O,
        O: 'static + Send,
        Self::Item: 'static,
        Self::Item: Send,
    { ... }
    fn parallel_map_custom<F, O, OF>(self, of: OF, f: F) -> ParallelMap<Self, O>
    where
        Self: 'static + Iterator,
        F: 'static + Send + Clone + FnMut(Self::Item) -> O,
        O: 'static + Send,
        OF: FnOnce(ParallelMapBuilder<Self>) -> ParallelMapBuilder<Self>,
        Self::Item: 'static,
        Self::Item: Send,
    { ... }
    fn parallel_map_scoped<'env, F, O>(
        self, 
        scope: &'scope Scope<'env>, 
        f: F
    ) -> ParallelMap<Self, O>
    where
        Self: 'env + Iterator,
        F: 'env + Send + Clone + FnMut(Self::Item) -> O,
        O: 'env + Send,
        Self::Item: 'env,
        Self::Item: Send,
    { ... }
    fn parallel_map_scoped_custom<'env, F, O, OF>(
        self, 
        scope: &'scope Scope<'env>, 
        of: OF, 
        f: F
    ) -> ParallelMap<Self, O>
    where
        Self: 'env + Iterator,
        F: 'env + Send + Clone + FnMut(Self::Item) -> O,
        O: 'env + Send,
        OF: FnOnce(ParallelMapBuilder<Self>) -> ParallelMapBuilder<Self>,
        Self::Item: 'env,
        Self::Item: Send,
    { ... }
    fn parallel_filter<F>(self, f: F) -> ParallelFilter<Self>
    where
        Self: 'static + Iterator,
        F: 'static + Send + Clone + FnMut(&Self::Item) -> bool,
        Self::Item: 'static,
        Self::Item: Send,
    { ... }
    fn parallel_filter_custom<F, OF>(self, of: OF, f: F) -> ParallelFilter<Self>
    where
        Self: 'static + Iterator,
        F: 'static + Send + Clone + FnMut(&Self::Item) -> bool,
        OF: FnOnce(ParallelFilterBuilder<Self>) -> ParallelFilterBuilder<Self>,
        Self::Item: 'static,
        Self::Item: Send,
    { ... }
    fn parallel_filter_scoped<'env, F>(
        self, 
        scope: &'scope Scope<'env>, 
        f: F
    ) -> ParallelFilter<Self>
    where
        Self: 'env + Iterator,
        F: 'env + Send + Clone + FnMut(&Self::Item) -> bool,
        Self::Item: 'env,
        Self::Item: Send,
    { ... }
    fn parallel_filter_scoped_custom<'env, F, OF>(
        self, 
        scope: &'scope Scope<'env>, 
        of: OF, 
        f: F
    ) -> ParallelFilter<Self>
    where
        Self: 'env + Iterator,
        F: 'env + Send + Clone + FnMut(&Self::Item) -> bool,
        OF: FnOnce(ParallelFilterBuilder<Self>) -> ParallelFilterBuilder<Self>,
        Self::Item: 'env,
        Self::Item: Send,
    { ... }
    fn readahead(self) -> Readahead<Self>
    where
        Self: 'static + Iterator + Send,
        Self::Item: 'static,
        Self::Item: Send,
    { ... }
    fn readahead_custom<OF>(self, of: OF) -> Readahead<Self>
    where
        Self: Iterator + 'static + Send,
        OF: FnOnce(ReadaheadBuilder<Self>) -> ReadaheadBuilder<Self>,
        Self::Item: 'static,
        Self::Item: Send,
    { ... }
    fn readahead_scoped<'env, 'scope>(
        self, 
        scope: &'scope Scope<'env>
    ) -> Readahead<Self>
    where
        Self: Send + 'scope + 'env + Iterator,
        Self::Item: 'env,
        Self::Item: 'scope,
        Self::Item: Send,
        Self::Item: Send,
    { ... }
    fn readahead_scoped_custom<'env, 'scope, OF>(
        self, 
        scope: &'scope Scope<'env>, 
        of: OF
    ) -> Readahead<Self>
    where
        Self: Send + 'scope + 'env + Iterator,
        OF: FnOnce(ReadaheadBuilder<Self>) -> ReadaheadBuilder<Self>,
        Self::Item: 'env,
        Self::Item: 'scope,
        Self::Item: Send,
        Self::Item: Send,
    { ... }
    fn profile_egress<P>(self, profiler: P) -> ProfileEgress<Self, P>
    where
        P: Profiler,
        Self: Iterator,
    { ... }
    fn profile_ingress<P>(self, profiler: P) -> ProfileIngress<Self, P>
    where
        P: Profiler,
        Self: Iterator,
    { ... }
    fn readahead_profiled<TxP, RxP>(
        self, 
        tx_profiler: TxP, 
        rx_profiler: RxP
    ) -> ProfileIngress<Readahead<ProfileEgress<Self, TxP>>, RxP>
    where
        TxP: Profiler + 'static + Send,
        RxP: Profiler,
        Self: Iterator + 'static + Send,
        Self::Item: 'static,
        Self::Item: Send,
    { ... }
    fn readahead_scoped_profiled<'env, 'scope, TxP, RxP>(
        self, 
        scope: &'scope Scope<'env>, 
        tx_profiler: TxP, 
        rx_profiler: RxP
    ) -> ProfileIngress<Readahead<ProfileEgress<Self, TxP>>, RxP>
    where
        TxP: Profiler + 'static + Send,
        RxP: Profiler,
        Self: Send + 'scope + 'env + Iterator,
        Self::Item: 'env,
        Self::Item: 'scope,
        Self::Item: Send,
        Self::Item: Send,
    { ... }
}

Extension trait for std::iter::Iterator bringing parallel operations

TODO

• parallel_for_each
• parallel_flat_map
• possibly others

PRs welcome

Provided methods

fn parallel_map<F, O>(self, f: F) -> ParallelMap<Self, O> where
    Self: 'static + Iterator,
    F: 'static + Send + Clone + FnMut(Self::Item) -> O,
    O: 'static + Send,
    Self::Item: 'static,
    Self::Item: Send, 

Run map function in parallel on multiple threads

Results will be returned in order.

No items will be pulled until first time ParallelMap is pulled for elements with ParallelMap::next. In that respect, ParallelMap behaves like every other iterator and is lazy.

fn parallel_map_custom<F, O, OF>(self, of: OF, f: F) -> ParallelMap<Self, O> where
    Self: 'static + Iterator,
    F: 'static + Send + Clone + FnMut(Self::Item) -> O,
    O: 'static + Send,
    OF: FnOnce(ParallelMapBuilder<Self>) -> ParallelMapBuilder<Self>,
    Self::Item: 'static,
    Self::Item: Send, 

See IteratorExt::parallel_map

fn parallel_map_scoped<'env, F, O>(
    self,
    scope: &'scope Scope<'env>,
    f: F
) -> ParallelMap<Self, O> where
    Self: 'env + Iterator,
    F: 'env + Send + Clone + FnMut(Self::Item) -> O,
    O: 'env + Send,
    Self::Item: 'env,
    Self::Item: Send, 

A version of [parallel_map] supporting iterating over borrowed values.

See IteratorExt::parallel_map

fn parallel_map_scoped_custom<'env, F, O, OF>(
    self,
    scope: &'scope Scope<'env>,
    of: OF,
    f: F
) -> ParallelMap<Self, O> where
    Self: 'env + Iterator,
    F: 'env + Send + Clone + FnMut(Self::Item) -> O,
    O: 'env + Send,
    OF: FnOnce(ParallelMapBuilder<Self>) -> ParallelMapBuilder<Self>,
    Self::Item: 'env,
    Self::Item: Send, 

See IteratorExt::parallel_map_scoped

fn parallel_filter<F>(self, f: F) -> ParallelFilter<Self> where
    Self: 'static + Iterator,
    F: 'static + Send + Clone + FnMut(&Self::Item) -> bool,
    Self::Item: 'static,
    Self::Item: Send, 

Run filter function in parallel on multiple threads

A wrapper around IteratorExt::parallel_map really, so it has similiar properties.

fn parallel_filter_custom<F, OF>(self, of: OF, f: F) -> ParallelFilter<Self> where
    Self: 'static + Iterator,
    F: 'static + Send + Clone + FnMut(&Self::Item) -> bool,
    OF: FnOnce(ParallelFilterBuilder<Self>) -> ParallelFilterBuilder<Self>,
    Self::Item: 'static,
    Self::Item: Send, 

See IteratorExt::parallel_filter

fn parallel_filter_scoped<'env, F>(
    self,
    scope: &'scope Scope<'env>,
    f: F
) -> ParallelFilter<Self> where
    Self: 'env + Iterator,
    F: 'env + Send + Clone + FnMut(&Self::Item) -> bool,
    Self::Item: 'env,
    Self::Item: Send, 

See IteratorExt::parallel_filter

fn parallel_filter_scoped_custom<'env, F, OF>(
    self,
    scope: &'scope Scope<'env>,
    of: OF,
    f: F
) -> ParallelFilter<Self> where
    Self: 'env + Iterator,
    F: 'env + Send + Clone + FnMut(&Self::Item) -> bool,
    OF: FnOnce(ParallelFilterBuilder<Self>) -> ParallelFilterBuilder<Self>,
    Self::Item: 'env,
    Self::Item: Send, 

See IteratorExt::parallel_filter

fn readahead(self) -> Readahead<Self> where
    Self: 'static + Iterator + Send,
    Self::Item: 'static,
    Self::Item: Send, 

Run the current iterator in another thread and return elements through a buffered channel.

buffer_size defines the size of the output channel connecting current and the inner thread. It’s a common mistake to use large channel sizes needlessly in hopes of achieving higher performance. The only benefit large buffer size value provides is smooting out the variance of the inner iterator returning items. The cost - wasting memory. In normal circumstances 0 is recommended (the default).

fn readahead_custom<OF>(self, of: OF) -> Readahead<Self> where
    Self: Iterator + 'static + Send,
    OF: FnOnce(ReadaheadBuilder<Self>) -> ReadaheadBuilder<Self>,
    Self::Item: 'static,
    Self::Item: Send, 

fn readahead_scoped<'env, 'scope>(
    self,
    scope: &'scope Scope<'env>
) -> Readahead<Self> where
    Self: Send + 'scope + 'env + Iterator,
    Self::Item: 'env,
    Self::Item: 'scope,
    Self::Item: Send,
    Self::Item: Send, 

Scoped version of IteratorExt::readahead

Use when you want to process in parallel items that contain borrowed references.

See scope.

fn readahead_scoped_custom<'env, 'scope, OF>(
    self,
    scope: &'scope Scope<'env>,
    of: OF
) -> Readahead<Self> where
    Self: Send + 'scope + 'env + Iterator,
    OF: FnOnce(ReadaheadBuilder<Self>) -> ReadaheadBuilder<Self>,
    Self::Item: 'env,
    Self::Item: 'scope,
    Self::Item: Send,
    Self::Item: Send, 

fn profile_egress<P>(self, profiler: P) -> ProfileEgress<Self, P> where
    P: Profiler,
    Self: Iterator, 

Profile the time it takes downstream iterator step to consume the returned items.

See ProfileEgress and profile::Profiler.

fn profile_ingress<P>(self, profiler: P) -> ProfileIngress<Self, P> where
    P: Profiler,
    Self: Iterator, 

Profile the time it takes upstream iterator step to produce the returned items.

See ProfileIngress and profile::Profiler.

fn readahead_profiled<TxP, RxP>(
    self,
    tx_profiler: TxP,
    rx_profiler: RxP
) -> ProfileIngress<Readahead<ProfileEgress<Self, TxP>>, RxP> where
    TxP: Profiler + 'static + Send,
    RxP: Profiler,
    Self: Iterator + 'static + Send,
    Self::Item: 'static,
    Self::Item: Send, 

Profiled version of IteratorExt::readahead

Literally .profile_egress(tx_profiler).readahead(n).profile_ingress(rx_profiler)

See Profiler for more info.

fn readahead_scoped_profiled<'env, 'scope, TxP, RxP>(
    self,
    scope: &'scope Scope<'env>,
    tx_profiler: TxP,
    rx_profiler: RxP
) -> ProfileIngress<Readahead<ProfileEgress<Self, TxP>>, RxP> where
    TxP: Profiler + 'static + Send,
    RxP: Profiler,
    Self: Send + 'scope + 'env + Iterator,
    Self::Item: 'env,
    Self::Item: 'scope,
    Self::Item: Send,
    Self::Item: Send, 

Profiled version of IteratorExt::readahead_scoped

Literally .profile_egress(tx_profiler).readahead_scoped(scope, n).profile_ingress(rx_profiler)

See Profiler for more info.

Implementors

impl<I> IteratorExt for I where
    I: Iterator,