orx-parallel 3.4.0

High performance, configurable and expressive parallel computation library.
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

use alloc::vec::Vec;
use orx_concurrent_bag::ConcurrentBag;
use std::println;

pub struct SharedStateWithDiagnostics<S> {
    inner: S,
    task_counts: ConcurrentBag<(usize, Vec<usize>)>, // (thread_idx, chunk sizes)
}

impl<S> SharedStateWithDiagnostics<S> {
    pub fn new(inner: S) -> Self {
        let tasks = ConcurrentBag::new();
        Self {
            inner,
            task_counts: tasks,
        }
    }

    #[inline(always)]
    pub fn inner(&self) -> &S {
        &self.inner
    }

    pub fn add_task_counts_of_thread(&self, thread_idx: usize, chunk_sizes: Vec<usize>) {
        self.task_counts.push((thread_idx, chunk_sizes));
    }

    pub fn display(self) {
        let mut task_counts = self.task_counts.into_inner().to_vec();
        task_counts.sort_by_key(|x| x.0);

        println!("\n# Parallel Executor Diagnostics");
        println!("\n- Number of threads used = {}", task_counts.len());

        println!("\n- [Thread idx]: num_calls, num_tasks, avg_chunk_size, first_chunk_sizes");

        for (thread_idx, task_counts) in task_counts {
            let total: usize = task_counts.iter().sum();
            let num_calls = task_counts.len();
            let avg_chunk_size = match num_calls {
                0 => 0,
                n => total / n,
            };
            let first_chunks: Vec<_> = task_counts.iter().copied().take(10).collect();

            println!(
                "  - [{thread_idx}]: {num_calls}, {total}, {avg_chunk_size}, {first_chunks:?}",
            );
        }
    }
}