Chunks en paralelo en Rust

Si el trabajo por elemento es barato, agrúpalo: una tarea por chunk gana a una por elemento.

use rayon::prelude::*;

fn main() {
    let values: Vec<f64> = (1..=10_000).map(|n| n as f64).collect();

    let sums: Vec<f64> = values
        .par_chunks(1_000)
        .map(|chunk| chunk.iter().sum())
        .collect();
    println!("{} chunk sums, first {:.0}", sums.len(), sums[0]);

    let mut scaled = values.clone();
    scaled.par_chunks_mut(500).for_each(|chunk| {
        for v in chunk {
            *v *= 2.0;
        }
    });
    println!("{:.0} {:.0}", scaled[0], scaled[9_999]);
}

Cómo funciona

par_chunks le entrega a cada hilo un slice, no un elemento.
El tamaño del chunk controla la granularidad del trabajo.
par_chunks_mut escribe en el slice en el lugar.

Palabras clave y builtins usados aquí

Vec
as
f64
fn
for
in
let
mut
use

El intento, en números

Líneas: 19
Caracteres a escribir: 421
Tokens: 150
Ritmo de tres estrellas: 110 tpm

Al ritmo de tres estrellas de 110 tokens por minuto, este intento toma unos 82 segundos.

Escribe este fragmento

Paso 2 de 3 en Repartir trabajo; paso 7 de 9 en Paralelismo de datos con rayon.

← Anterior Siguiente →