parallel_task 0.6.0

A fast data parallelism library for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use criterion::{criterion_group, criterion_main, Criterion, BatchSize};
use std::time::{Duration, Instant};
use rayon::prelude::*;
use parallel_task::prelude::*;
use rand::Rng;

#[derive(Debug, Clone)]
struct Job {    
    duration: Duration,
}

impl Job {
    fn run(&self) {
        let start = Instant::now();
        while start.elapsed() < self.duration {
            std::hint::spin_loop();
        }
    }
}

fn create_micro_jobs(count: usize) -> Vec<Job> {
    let mut rng = rand::rng();
    (0..count)
        .map(|_| {
            let p = rng.random_range(0..100);
            let micros = if p < 90 {
                rng.random_range(50..=500)
            } else  {
                rng.random_range(500..=1000)
            };
            Job {                
                duration: Duration::from_micros(micros),
            }
        })
        .collect()
}

fn bench_micro_jobs(c: &mut Criterion) {
    let job_count = 10_00;
    let base_jobs = create_micro_jobs(job_count);

    // -------------------
    // OWNED iterators
    // -------------------
    c.bench_function("Normal (owned)", |b| {
        b.iter_batched(
            || base_jobs.clone(), // setup (not timed)
            |jobs| {
                jobs.into_iter().for_each(|j| j.run());
            },
            BatchSize::SmallInput,
        );
    });

    c.bench_function("Rayon (owned)", |b| {
        b.iter_batched(
            || base_jobs.clone(),
            |jobs| {
                jobs.into_par_iter().for_each(|j| j.run());
            },
            BatchSize::SmallInput,
        );
    });

    c.bench_function("PT (owned)", |b| {
        b.iter_batched(
            || base_jobs.clone(),
            |jobs| {
                jobs.into_parallel_iter().for_each(|j| j.run());
            },
            BatchSize::SmallInput,
        );
    });

    // -------------------
    // BORROWED iterators
    // -------------------
    c.bench_function("Normal (&iter)", |b| {
        b.iter_batched_ref(
            || base_jobs.clone(),
            |jobs| {
                jobs.iter().for_each(|j| j.run());
            },
            BatchSize::SmallInput,
        );
    });

    c.bench_function("Rayon (&iter)", |b| {
        b.iter_batched_ref(
            || base_jobs.clone(),
            |jobs| {
                jobs.par_iter().for_each(|j| j.run());
            },
            BatchSize::SmallInput,
        );
    });

    c.bench_function("PT (&iter)", |b| {
        b.iter_batched_ref(
            || base_jobs.clone(),
            |jobs| {
                jobs.parallel_iter().for_each(|j| j.run());
            },
            BatchSize::SmallInput,
        );
    });
}

criterion_group!(benches, bench_micro_jobs);
criterion_main!(benches);