strided-basic 0.4.0

Shared typed strided CPU primitives and copy/reduction execution.
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

use super::*;
use std::panic::{catch_unwind, AssertUnwindSafe};

#[test]
fn ambient_scope_returns_result_without_changing_state() {
    let before = state();

    let value = with_execution_policy(ExecutionPolicy::AmbientRayon, || {
        let active = state();
        assert_eq!(active.policy, before.policy);
        assert_eq!(active.fanout_active, before.fanout_active);
        17usize
    });

    let after = state();
    assert_eq!(value, 17);
    assert_eq!(after.policy, before.policy);
    assert_eq!(after.fanout_active, before.fanout_active);
}

#[test]
fn explicit_scope_restores_state_after_return_and_panic() {
    let before = state();
    let two = NonZeroUsize::new(2).unwrap();

    let value = with_execution_policy(ExecutionPolicy::Rayon { max_threads: two }, || {
        assert_eq!(state().policy, ExecutionPolicy::Rayon { max_threads: two });
        23usize
    });
    assert_eq!(value, 23);
    assert_eq!(state().policy, before.policy);
    assert_eq!(state().fanout_active, before.fanout_active);

    let panic = catch_unwind(AssertUnwindSafe(|| {
        with_execution_policy(ExecutionPolicy::Sequential, || panic!("policy scope panic"));
    }));
    assert!(panic.is_err());
    assert_eq!(state().policy, before.policy);
    assert_eq!(state().fanout_active, before.fanout_active);
}

#[test]
fn nested_explicit_scopes_combine_conservatively() {
    let two = NonZeroUsize::new(2).unwrap();
    let four = NonZeroUsize::new(4).unwrap();

    with_execution_policy(ExecutionPolicy::Rayon { max_threads: four }, || {
        assert_eq!(state().policy, ExecutionPolicy::Rayon { max_threads: four });

        with_execution_policy(ExecutionPolicy::Rayon { max_threads: two }, || {
            assert_eq!(state().policy, ExecutionPolicy::Rayon { max_threads: two });
        });
        assert_eq!(state().policy, ExecutionPolicy::Rayon { max_threads: four });

        with_execution_policy(ExecutionPolicy::Sequential, || {
            assert_eq!(state().policy, ExecutionPolicy::Sequential);
        });
        assert_eq!(state().policy, ExecutionPolicy::Rayon { max_threads: four });
    });

    with_execution_policy(ExecutionPolicy::Sequential, || {
        with_execution_policy(ExecutionPolicy::Rayon { max_threads: four }, || {
            assert_eq!(state().policy, ExecutionPolicy::Sequential);
        });
    });
    assert_eq!(state().policy, ExecutionPolicy::AmbientRayon);
    assert!(!state().fanout_active);
}