並列タスク

配列の要素を並列に変更する

この例では、Rust向けのデータ並列処理ライブラリである rayon クレートを使用します。 rayon は、並列イテレーション可能な任意のデータ型に対して par_iter_mut メソッドを提供します。これは、並列に実行される可能性があるイテレータのようなチェーンです。

use rayon::prelude::*;

fn main() {
    let mut arr = [0, 7, 9, 11];
    arr.par_iter_mut().for_each(|p| *p -= 1);
    println!("{:?}", arr);
}

コレクションのいずれかまたはすべての要素が、指定された述語を満たすかどうかを並列にテストする

この例では、std::any と std::all に対応する並列版である rayon::any メソッドと rayon::all メソッドの使い方を示します。 rayon::any は、イテレータのいずれかの要素が述語を満たすかどうかを並列に確認し、1 つ見つかるとすぐに返ります。 rayon::all は、イテレータのすべての要素が述語を満たすかどうかを並列に確認し、条件に一致しない要素が見つかるとすぐに返ります。

use rayon::prelude::*;

fn main() {
    let mut vec = vec![2, 4, 6, 8];

    assert!(!vec.par_iter().any(|n| (*n % 2) != 0));
    assert!(vec.par_iter().all(|n| (*n % 2) == 0));
    assert!(!vec.par_iter().any(|n| *n > 8 ));
    assert!(vec.par_iter().all(|n| *n <= 8 ));

    vec.push(9);

    assert!(vec.par_iter().any(|n| (*n % 2) != 0));
    assert!(!vec.par_iter().all(|n| (*n % 2) == 0));
    assert!(vec.par_iter().any(|n| *n > 8 ));
    assert!(!vec.par_iter().all(|n| *n <= 8 )); 
}

与えられた述語を使って並列に項目を検索する

この例では、rayon::find_any と par_iter を使って、与えられたクロージャ内の述語を満たす要素をベクターから並列に検索します。

rayon::find_any のクロージャ引数で定義された述語を満たす要素が複数ある場合、rayon は最初の要素を返すとは限らず、見つかったもののうち最初のものを返します。

また、クロージャへの引数は参照への参照（&&x）であることにも注意してください。追加の詳細については std::find の説明を参照してください。

use rayon::prelude::*;

fn main() {
    let v = vec![6, 2, 1, 9, 3, 8, 11];

    let f1 = v.par_iter().find_any(|&&x| x == 9);
    let f2 = v.par_iter().find_any(|&&x| x % 2 == 0 && x > 6);
    let f3 = v.par_iter().find_any(|&&x| x > 8);

    assert_eq!(f1, Some(&9));
    assert_eq!(f2, Some(&8));
    assert!(f3 > Some(&8));
}

ベクターを並列にソートする

この例では、String のベクターを並列にソートします。

空の String のベクターを確保します。par_iter_mut().for_each はランダムな値を並列に設定します。列挙可能なデータ型をソートするには multiple options がありますが、par_sort_unstable は通常、stable sorting アルゴリズムより高速です。

use rand::RngExt;
use rayon::prelude::*;

fn main() {
    let mut vec = vec![0; 1_000_000];
    rand::rng().fill(&mut vec[..]);

    vec.par_sort_unstable();

    let first = vec.first().unwrap();
    let last = vec.last().unwrap();
    assert!(first <= last);
}

並列での Map-reduce

この例では、rayon::filter、rayon::map、rayon::reduce を使用して、年齢が 30 を超える Person オブジェクトの平均年齢を計算します。

rayon::filter は、指定された述語を満たす要素をコレクションから返します。rayon::map は各要素に対して操作を実行し、新しいイテレーションを作成します。rayon::reduce は、前回のリダクション結果と現在の要素を受け取って操作を実行します。また、rayon::sum の使用例も示しており、これはこの例では reduce 操作と同じ結果になります。

use rayon::prelude::*;

struct Person {
    age: u32,
}

fn main() {
    let v: Vec<Person> = vec![
        Person { age: 23 },
        Person { age: 19 },
        Person { age: 42 },
        Person { age: 17 },
        Person { age: 17 },
        Person { age: 31 },
        Person { age: 30 },
    ];

    let num_over_30 = v.par_iter().filter(|&x| x.age > 30).count() as f32;
    let sum_over_30 = v.par_iter()
        .map(|x| x.age)
        .filter(|&x| x > 30)
        .reduce(|| 0, |x, y| x + y);

    let alt_sum_30: u32 = v.par_iter()
        .map(|x| x.age)
        .filter(|&x| x > 30)
        .sum();

    let avg_over_30 = sum_over_30 as f32 / num_over_30;
    let alt_avg_over_30 = alt_sum_30 as f32/ num_over_30;

    assert!((avg_over_30 - alt_avg_over_30).abs() < std::f32::EPSILON);
    println!("The average age of people older than 30 is {}", avg_over_30);
}

並列に jpg サムネイルを生成する

この例では、現在のディレクトリ内にあるすべての .jpg ファイルのサムネイルを生成し、それらを thumbnails という新しいフォルダーに保存します。

glob::glob_with は現在のディレクトリ内の jpeg ファイルを見つけます。rayon は DynamicImage::resize を呼び出す par_iter を使用して、画像のサイズを並列に変更します。

use anyhow::Result;
use std::path::Path;
use std::fs::create_dir_all;

use glob::{glob_with, MatchOptions};
use image::imageops::FilterType;
use rayon::prelude::*;

fn main() -> Result<()> {
    let options: MatchOptions = Default::default();
    let files: Vec<_> = glob_with("*.jpg", options)?
        .filter_map(|x| x.ok())
        .collect();

    if files.len() == 0 {
        anyhow::bail!("No .jpg files found in current directory");
    }

    let thumb_dir = "thumbnails";
    create_dir_all(thumb_dir)?;

    println!("Saving {} thumbnails into '{}'...", files.len(), thumb_dir);

    let image_failures: Vec<_> = files
        .par_iter()
        .map(|path| {
            make_thumbnail(path, thumb_dir, 300)
                .map_err(|e| anyhow::anyhow!("Failed to process {}: {}", path.display(), e))
        })
        .filter_map(|x| x.err())
        .collect();

    image_failures.iter().for_each(|x| println!("{}", x));

    println!("{} thumbnails saved successfully", files.len() - image_failures.len());
    Ok(())
}

fn make_thumbnail<PA, PB>(original: PA, thumb_dir: PB, longest_edge: u32) -> Result<()>
where
    PA: AsRef<Path>,
    PB: AsRef<Path>,
{
    let img = image::open(original.as_ref())?;
    let file_path = thumb_dir.as_ref().join(original);

    Ok(img.resize(longest_edge, longest_edge, FilterType::Nearest)
        .save(file_path)?)
}

Keyboard shortcuts