parallel_sum.rs en Rust

Repartir una suma grande entre hilos y comparar contra la respuesta en serie.

use std::thread;
use std::time::Instant;

fn serial_sum(values: &[u64]) -> u64 {
    values.iter().sum()
}

fn threaded_sum(values: &[u64], workers: usize) -> u64 {
    let chunk = values.len().div_ceil(workers);
    let mut totals = vec![0u64; workers];

    thread::scope(|scope| {
        for (slot, part) in totals.iter_mut().zip(values.chunks(chunk)) {
            scope.spawn(move || {
                *slot = part.iter().sum();
            });
        }
    });

    totals.iter().sum()
}

fn main() {
    let values: Vec<u64> = (1..=2_000_000).collect();

    let started = Instant::now();
    let one = serial_sum(&values);
    let serial_time = started.elapsed();

    let started = Instant::now();
    let many = threaded_sum(&values, 4);
    let threaded_time = started.elapsed();

    assert_eq!(one, many);
    println!("total {one}");
    println!("serial   {:?}", serial_time);
    println!("threaded {:?}", threaded_time);

    let ratio = serial_time.as_secs_f64() / threaded_time.as_secs_f64();
    println!("speedup {:.2}x", ratio);
}

Cómo funciona

1. Los datos se parten en trozos y cada trozo va a su propio hilo.
2. Los hilos con scope prestan el slice en vez de clonarlo.
3. El cronómetro muestra qué compraron los hilos extra.

Palabras clave y builtins usados aquí

• Vec
• fn
• for
• in
• let
• move
• mut
• u64
• use
• usize

El intento, en números

Líneas

41

Caracteres a escribir

922

Tokens

283

Ritmo de tres estrellas

110 tpm

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

Escribe este fragmento

Paso 1 de 1 en Bis; paso 15 de 15 en Concurrencia y async.

← Anterior