fidget 0.5.0

Infrastructure for complex closed-form implicit surfaces
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

use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
use fidget::{render::ThreadPool, shape::BoundShape};
use std::hint::black_box;

const PROSPERO: &str = include_str!("../../models/prospero.vm");

pub fn prospero_exemplary(c: &mut Criterion) {
    let (ctx, root) = fidget::Context::from_text(PROSPERO.as_bytes()).unwrap();
    let shape_vm =
        &BoundShape::try_from(fidget::vm::VmShape::new(&ctx, root).unwrap())
            .unwrap();

    let mut group = c.benchmark_group("prospero-exemplary");
    let cfg = &fidget::raster::pixel::RenderConfig::from_size(1024.into());
    group.bench_function("vm", move |b| {
        b.iter(|| {
            let tape = shape_vm.clone();
            black_box(cfg.run(tape))
        })
    });

    #[cfg(feature = "jit")]
    {
        let shape_jit = &BoundShape::try_from(
            fidget::jit::JitShape::new(&ctx, root).unwrap(),
        )
        .unwrap();
        group.bench_function("jit", move |b| {
            b.iter(|| {
                let tape = shape_jit.clone();
                black_box(cfg.run(tape))
            })
        });
    }
}

pub fn prospero_size_sweep(c: &mut Criterion) {
    let (ctx, root) = fidget::Context::from_text(PROSPERO.as_bytes()).unwrap();
    let shape_vm =
        &BoundShape::try_from(fidget::vm::VmShape::new(&ctx, root).unwrap())
            .unwrap();

    #[cfg(feature = "jit")]
    let shape_jit =
        &BoundShape::try_from(fidget::jit::JitShape::new(&ctx, root).unwrap())
            .unwrap();

    let mut group =
        c.benchmark_group("speed vs image size (prospero, 2d) (8 threads)");
    for size in [256, 512, 768, 1024, 1280, 1546, 1792, 2048] {
        let cfg = &fidget::raster::pixel::RenderConfig::from_size(size.into());
        group.bench_function(BenchmarkId::new("vm", size), move |b| {
            b.iter(|| {
                let tape = shape_vm.clone();
                black_box(cfg.run(tape))
            })
        });

        #[cfg(feature = "jit")]
        {
            let cfg =
                &fidget::raster::pixel::RenderConfig::from_size(size.into());
            group.bench_function(BenchmarkId::new("jit", size), move |b| {
                b.iter(|| {
                    let tape = shape_jit.clone();
                    black_box(cfg.run(tape))
                })
            });
        }
    }
}

pub fn prospero_thread_sweep(c: &mut Criterion) {
    let (ctx, root) = fidget::Context::from_text(PROSPERO.as_bytes()).unwrap();
    let shape_vm =
        &BoundShape::try_from(fidget::vm::VmShape::new(&ctx, root).unwrap())
            .unwrap();

    #[cfg(feature = "jit")]
    let shape_jit =
        &BoundShape::try_from(fidget::jit::JitShape::new(&ctx, root).unwrap())
            .unwrap();

    let mut group =
        c.benchmark_group("speed vs threads (prospero, 2d) (1024 x 1024)");
    let pools = [1, 2, 4, 8, 16].map(|i| {
        Some(ThreadPool::Custom(
            rayon::ThreadPoolBuilder::new()
                .num_threads(i)
                .build()
                .unwrap(),
        ))
    });
    for threads in [None, Some(ThreadPool::Global)].into_iter().chain(pools) {
        let threads = threads.as_ref();
        let name = match &threads {
            None => "-".to_string(),
            Some(ThreadPool::Custom(i)) => i.current_num_threads().to_string(),
            Some(ThreadPool::Global) => "N".to_string(),
        };
        let cfg = &fidget::raster::pixel::RenderConfig {
            threads,
            ..fidget::raster::pixel::RenderConfig::from_size(1024.into())
        };
        group.bench_function(BenchmarkId::new("vm", &name), move |b| {
            b.iter(|| {
                let tape = shape_vm.clone();
                black_box(cfg.run(tape))
            })
        });
        #[cfg(feature = "jit")]
        {
            let cfg = &fidget::raster::pixel::RenderConfig {
                threads,
                ..fidget::raster::pixel::RenderConfig::from_size(1024.into())
            };
            group.bench_function(BenchmarkId::new("jit", &name), move |b| {
                b.iter(|| {
                    let tape = shape_jit.clone();
                    black_box(cfg.run(tape))
                })
            });
        }
    }
}

criterion_group!(
    benches,
    prospero_size_sweep,
    prospero_thread_sweep,
    prospero_exemplary,
);
criterion_main!(benches);