fidget 0.4.3

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

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

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

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

    #[cfg(feature = "jit")]
    let shape_jit = &fidget::jit::JitShape::new(&ctx, root).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::ImageRenderConfig {
            image_size: fidget::render::ImageSize::from(size),
            tile_sizes: fidget::vm::VmFunction::tile_sizes_2d(),
            ..Default::default()
        };
        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::ImageRenderConfig {
                image_size: fidget::render::ImageSize::from(size),
                tile_sizes: fidget::jit::JitFunction::tile_sizes_2d(),
                ..Default::default()
            };
            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 = &fidget::vm::VmShape::new(&ctx, root).unwrap();

    #[cfg(feature = "jit")]
    let shape_jit = &fidget::jit::JitShape::new(&ctx, root).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::ImageRenderConfig {
            image_size: ImageSize::from(1024),
            tile_sizes: fidget::vm::VmFunction::tile_sizes_2d(),
            threads,
            ..Default::default()
        };
        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::ImageRenderConfig {
                image_size: ImageSize::from(1024),
                tile_sizes: fidget::jit::JitFunction::tile_sizes_2d(),
                threads,
                ..Default::default()
            };
            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);
criterion_main!(benches);