simdnoise 3.1.6

SIMD accelerate noise library with runtime feature detection
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#[macro_use]
extern crate criterion;
extern crate simdeez;
extern crate simdnoise;
use criterion::Fun;
use criterion::*;
use simdnoise::*;
use std::time::Duration;

fn d4(c: &mut Criterion) {
    let setting = NoiseBuilder::fbm_4d(8, 8, 8, 8).wrap();

    c.bench(
        "fbm4d",
        Benchmark::new("scalar 4d", move |b| {
            b.iter(|| unsafe { scalar::get_4d_noise(&setting) })
        })
        .with_function("sse2 4d", move |b| {
            b.iter(|| unsafe { sse2::get_4d_noise(&setting) })
        })
        .with_function("sse41 4d", move |b| {
            b.iter(|| unsafe { sse41::get_4d_noise(&setting) })
        })
        .with_function("avx2 4d", move |b| {
            b.iter(|| unsafe { avx2::get_4d_noise(&setting) })
        })
        .sample_size(10)
        .warm_up_time(Duration::from_millis(1))
        .measurement_time(Duration::from_secs(5)),
    );
}
fn d3(c: &mut Criterion) {
    let setting = NoiseBuilder::fbm_3d(64, 64, 64).wrap();
    c.bench(
        "fbm3d",
        Benchmark::new("scalar 3d", move |b| {
            b.iter(|| unsafe { scalar::get_3d_noise(&setting) })
        })
        .with_function("sse2 3d", move |b| {
            b.iter(|| unsafe { sse2::get_3d_noise(&setting) })
        })
        .with_function("sse41 3d", move |b| {
            b.iter(|| unsafe { sse41::get_3d_noise(&setting) })
        })
        .with_function("avx2 3d", move |b| {
            b.iter(|| unsafe { avx2::get_3d_noise(&setting) })
        })
        .sample_size(10)
        .warm_up_time(Duration::from_millis(1))
        .measurement_time(Duration::from_secs(5)),
    );
}

fn d2(c: &mut Criterion) {
    let setting = NoiseBuilder::fbm_2d(3840, 2160).wrap();
    c.bench(
        "fbm2d",
        Benchmark::new("scalar 2d", move |b| {
            b.iter(|| unsafe { scalar::get_2d_noise(&setting) })
        })
        .with_function("sse2 2d", move |b| {
            b.iter(|| unsafe { sse2::get_2d_noise(&setting) })
        })
        .with_function("sse41 2d", move |b| {
            b.iter(|| unsafe { sse41::get_2d_noise(&setting) })
        })
        .with_function("avx2 2d", move |b| {
            b.iter(|| unsafe { avx2::get_2d_noise(&setting) })
        })
        .sample_size(10)
        .warm_up_time(Duration::from_millis(1))
        .measurement_time(Duration::from_secs(5)),
    );
}

fn d1(c: &mut Criterion) {
    let setting = NoiseBuilder::fbm_1d(1024).wrap();
    c.bench(
        "fbm1d",
        Benchmark::new("scalar 1d", move |b| {
            b.iter(|| unsafe { scalar::get_1d_noise(&setting) })
        })
        .with_function("sse2 1d", move |b| {
            b.iter(|| unsafe { sse2::get_1d_noise(&setting) })
        })
        .with_function("sse41 1d", move |b| {
            b.iter(|| unsafe { sse41::get_1d_noise(&setting) })
        })
        .with_function("avx2 1d", move |b| {
            b.iter(|| unsafe { avx2::get_1d_noise(&setting) })
        })
        .sample_size(10)
        .warm_up_time(Duration::from_millis(1))
        .measurement_time(Duration::from_secs(5)),
    );
}
fn d2_cell(c: &mut Criterion) {
    let setting = NoiseBuilder::cellular_2d(1024, 1024)
        .with_return_type(CellReturnType::CellValue)
        .wrap();
    c.bench(
        "cellular2d",
        Benchmark::new("scalar 2d", move |b| {
            b.iter(|| unsafe { scalar::get_2d_noise(&setting) })
        })
        .with_function("sse2 2d", move |b| {
            b.iter(|| unsafe { sse2::get_2d_noise(&setting) })
        })
        .with_function("sse41 2d", move |b| {
            b.iter(|| unsafe { sse41::get_2d_noise(&setting) })
        })
        .with_function("avx2 2d", move |b| {
            b.iter(|| unsafe { avx2::get_2d_noise(&setting) })
        })
        .sample_size(10)
        .warm_up_time(Duration::from_millis(1))
        .measurement_time(Duration::from_secs(5)),
    );
}
fn d3_cell(c: &mut Criterion) {
    let setting = NoiseBuilder::cellular_3d(128, 128, 128).wrap();
    c.bench(
        "cellular3d",
        Benchmark::new("scalar 3d", move |b| {
            b.iter(|| unsafe { scalar::get_3d_noise(&setting) })
        })
        .with_function("sse2 3d", move |b| {
            b.iter(|| unsafe { sse2::get_3d_noise(&setting) })
        })
        .with_function("sse41 3d", move |b| {
            b.iter(|| unsafe { sse41::get_3d_noise(&setting) })
        })
        .with_function("avx2 3d", move |b| {
            b.iter(|| unsafe { avx2::get_3d_noise(&setting) })
        })
        .sample_size(10)
        .warm_up_time(Duration::from_millis(1))
        .measurement_time(Duration::from_secs(5)),
    );
}
criterion_group!(benches, d4, d3, d2, d1, d2_cell, d3_cell);
criterion_main!(benches);