Contar en paralelo en Rust

Fusionar mapas por hilo gana a pelear por un solo lock compartido.

use rayon::prelude::*;
use std::collections::HashMap;

fn main() {
    let words: Vec<&str> = "the quick brown fox the lazy dog the end"
        .split_whitespace()
        .collect();

    let counts = words
        .par_iter()
        .copied()
        .fold(HashMap::new, |mut acc: HashMap<&str, u32>, word| {
            *acc.entry(word).or_insert(0) += 1;
            acc
        })
        .reduce(HashMap::new, |mut a, b| {
            for (word, n) in b {
                *a.entry(word).or_insert(0) += n;
            }
            a
        });

    let mut pairs: Vec<(&&str, &u32)> = counts.iter().collect();
    pairs.sort_by(|a, b| b.1.cmp(a.1).then(a.0.cmp(b.0)));
    println!("{:?}", &pairs[..3]);
}

Cómo funciona

1. fold arma un mapa por hilo sin contención.
2. reduce fusiona los mapas parciales al final.
3. Un único Mutex<HashMap> serializaría toda la corrida.

Palabras clave y builtins usados aquí

• Vec
• fn
• for
• in
• let
• mut
• str
• u32
• use

El intento, en números

Líneas

26

Caracteres a escribir

555

Tokens

212

Ritmo de tres estrellas

110 tpm

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

Escribe este fragmento

Paso 2 de 2 en Reducciones; paso 5 de 9 en Paralelismo de datos con rayon.

← Anterior Siguiente →