use orx_parallel::prelude::*;
use std::num::NonZeroUsize;

let _ = (0..42).par().sum(); // both settings at Auto

let _ = (0..42).par().num_threads(4).sum(); // at most 4 threads
let _ = (0..42).par().num_threads(1).sum(); // sequential
let _ = (0..42).par().num_threads(NumThreads::sequential()).sum(); // also sequential
let _ = (0..42).par().num_threads(0).sum(); // shorthand for NumThreads::Auto

let _ = (0..42).par().chunk_size(16).sum(); // chunks of exactly 16 elements
let c = NonZeroUsize::new(64).unwrap();
let _ = (0..42).par().chunk_size(ChunkSize::Min(c)).sum(); // min 64 elements
let _ = (0..42).par().chunk_size(0).sum(); // shorthand for ChunkSize::Auto

let _ = (0..42).par().num_threads(4).chunk_size(16).sum(); // set both params

控制这两个参数并能够轻松地、个别地配置每次计算，在各种方式上都很有用。请参见EasyConfiguration部分以获取示例。

顺序计算和并行计算的一般化

使用NumThreads::Max(1)执行并行计算相当于顺序计算，没有任何并行化开销。在这种意义上，Par是顺序计算和并行计算的一般化。

为了说明这一点，考虑以下函数，它接受一个计算定义作为Par。请注意，就像顺序迭代器一样，Par是惰性的。换句话说，它只是计算的定义。这样的computation与可以通过computation.params()访问的设置一起传递给execute方法。

然而，由于该方法拥有computation，它可以决定如何执行它。此实现将遵循给定的并行设置。除非是星期一，否则它将顺序运行。

use orx_parallel::prelude::*;
use chrono::{Datelike, Local, Weekday};
type Output = String;

fn execute<C: Par<Item = Output>>(computation: C) -> Vec<Output> {
    match Local::now().weekday() {
        Weekday::Mon => computation.num_threads(1).collect_vec(),
        _ => computation.collect_vec(),
    }
}

这个特性使我们免于两次定义相同的计算。我们经常需要编写如下代码，根据输入参数的需要顺序或并行运行。这是重复的、容易出错的且难以维护的。

use orx_parallel::prelude::*;
struct Input(String);
struct Output(usize);
fn compute(input: Input) -> Output {
    Output(input.0.len())
}
fn select(output: &Output) -> bool {
    output.0.is_power_of_two()
}

fn execute_conditionally(inputs: impl Iterator<Item = Input>, parallelize: bool) -> usize {
    match parallelize {
        true => inputs
            .into_iter()
            .par()
            .map(compute)
            .filter(select)
            .map(|x| x.0)
            .sum(),
        false => inputs
            .into_iter()
            .map(compute)
            .filter(select)
            .map(|x| x.0)
            .sum(),
    }
}

使用Par，我们可以有一个单一的版本，当顺序执行时不会产生任何开销。

fn execute_unified(inputs: impl Iterator<Item = Input>, parallelize: bool) -> usize {
    let num_threads = match parallelize {
        true => NumThreads::Auto,
        false => NumThreads::sequential(),
    };
    inputs
        .par()
        .num_threads(num_threads)
        .map(compute)
        .filter(select)
        .map(|x| x.0)
        .sum()
}

底层方法和性能

这个crate是ConcurrentIter的自然后续。您可能已经发现了示例中的并行映射、折叠和查找实现。特别是当与ConcurrentBag和ConcurrentOrderedBag等并发集合结合使用时，并行计算的实现非常直接。您可以在本节中和这个讨论中找到一些细节。

基准测试很棘手，尤其是在并行环境中。尽管如此，本存储库中定义的基准测试对Par来说非常有希望。其性能通常与rayon相当。在收集结果的情况下，它可以提供显著的改进，例如map |> filter |> collect或flat_map |> collect等。

与rayon的关系

请参阅RelationToRayon部分，以了解orx-parallel与rayon的相似之处和不同之处。

贡献

欢迎贡献！如果您发现错误、有问题或认为某些内容可以改进，请打开一个问题或创建一个PR。

v1的目标是允许Par涵盖实际用例，如果您有无法用其表达和计算的计算，请打开一个问题。

v2的目标是提供一个更动态和智能的并行执行器，请参见并加入相关的讨论这里。

许可

此库在MIT许可下发布。请参阅LICENSE以获取详细信息。