Enum Parallelism 

#[non_exhaustive]
pub enum Parallelism {
    #[non_exhaustive]
    Dynamic {
        batchsize: NonZeroUsize,
        ntasks: NonZeroUsize,
    },
    #[non_exhaustive]
    Sequential {
        batchsize: NonZeroUsize,
    },
    #[non_exhaustive]
    Fixed {
        batchsize: Option<NonZeroUsize>,
        ntasks: NonZeroUsize,
    },
}

Control the parallel partitioning strategy for build and build_tracked.

Many aspects of this enum are #[non_exhaustive] to allow for future extension. Users should use the associated constructors instead to create instances.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

#[non_exhaustive]

Dynamic

Use dynamic load balancing to partition the work into batches of at most batchsize. When the batchsize is 1, the implementation guarantees sequential execution.

The batches assigned to each task can be assumed to be monotonically increasing.

See: Parallelism::dynamic.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

batchsize: NonZeroUsize

ntasks: NonZeroUsize

#[non_exhaustive]

Sequential

Run the build with just a single task. Input data is still batched.

See: Parallelism::sequential.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

batchsize: NonZeroUsize

#[non_exhaustive]

Fixed

Create a fixed parallelism strategy with ntasks executors. This strategy partitions the problem space into roughly ntasks balanced contiguous chunks.

If batchsize is Some, than each chunk will be further subdivided into at most batchsize sized subchunks which are then provided to Build::build.

If batchsize is None, then the entire task partition is supplied in a single call to Build::build.

See: Parallelism::fixed.

Fields

Non-exhaustive enum variants could have additional fields added in future. Therefore, non-exhaustive enum variants cannot be constructed in external crates and cannot be matched against.

batchsize: Option<NonZeroUsize>

ntasks: NonZeroUsize

Implementations

impl Parallelism

pub fn dynamic(batchsize: NonZeroUsize, ntasks: NonZeroUsize) -> Self

Create a dynamic parallelism strategy with the specified batchsize and ntasks.

Returns Self::Dynamic.

pub fn fixed(batchsize: Option<NonZeroUsize>, ntasks: NonZeroUsize) -> Self

Create a fixed parallelism strategy with ntasks executors and possible sub-partitioning into the specified batchsize.

Returns Self::Fixed.

pub fn sequential(batchsize: NonZeroUsize) -> Self

Create a sequential parallelism strategy with the specified batchsize.

Returns Self::Sequential.

Trait Implementations

impl Clone for Parallelism

fn clone(&self) -> Parallelism

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Parallelism

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Parallelism

fn eq(&self, other: &Parallelism) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Parallelism

impl StructuralPartialEq for Parallelism