morphorm 0.8.0

A UI layout engine
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
143
144
145
146
147
148
149
150
151

use morphorm::*;
use morphorm_ecs::*;

use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};

// Helper function for building a tree of nodes.
fn build_tree(world: &mut World, parent: Option<Entity>, children_per_node: usize, depth: usize) -> Entity {
    let node = world.add(parent);
    if parent.is_none() {
        world.set_width(node, Units::Pixels(1000.0));
        world.set_height(node, Units::Pixels(1000.0));
    } else {
        world.set_all_stretch(node);
    }

    let depth = depth.saturating_sub(1);

    if depth > 0 {
        for _ in 0..children_per_node {
            build_tree(world, Some(node), children_per_node, depth);
        }

        return node;
    }

    Entity(0)
}

// FIXME: There's almost certainly a formula for this geometric series.
fn compute_node_count(children_per_node: usize, depth: usize, node_count: &mut usize) -> usize {
    *node_count += 1;
    let depth = depth.saturating_sub(1);
    if depth > 0 {
        for _ in 0..children_per_node {
            compute_node_count(children_per_node, depth, node_count);
        }
    }

    *node_count
}

fn morphorm_benchmarks(c: &mut Criterion) {
    let mut group = c.benchmark_group("Shallow Tree");
    group.sample_size(10);

    let children_per_node = 10;

    // 3 - 111, 4 - 1,111, 5 - 11,111, 6 - 111,111 7 - 1,111,111
    for depth in [4, 5, 6, 7].iter() {
        let benchmark_id = BenchmarkId::new(
            format!(
                "Wide Shallow Bench. {children_per_node} children per node, depth: {depth}. Total nodes: {}.",
                compute_node_count(children_per_node, *depth, &mut 0)
            ),
            depth,
        );
        group.bench_with_input(benchmark_id, depth, |b, &depth| {
            b.iter_batched(
                || {
                    let mut world = World::default();
                    let root = build_tree(&mut world, None, children_per_node, depth);
                    (world, root)
                },
                |(mut world, root)| root.layout(&mut world.cache, &world.tree, &world.store, &mut ()),
                criterion::BatchSize::SmallInput,
            )
        });
    }

    group.finish();

    let mut group = c.benchmark_group("Deep Tree");
    group.sample_size(10);

    let children_per_node = 2;

    // 10 - 1023, 12 - 8191, 16 - 131,071, 19 - 1,048,575
    for depth in [10, 13, 17, 20].iter() {
        let benchmark_id = BenchmarkId::new(
            format!(
                "Narrow Deep Bench. {children_per_node} children per node, depth: {depth}. Total nodes: {}.",
                compute_node_count(children_per_node, *depth, &mut 0)
            ),
            depth,
        );
        group.bench_with_input(benchmark_id, depth, |b, &depth| {
            b.iter_batched(
                || {
                    let mut world = World::default();
                    let root = build_tree(&mut world, None, children_per_node, depth);
                    (world, root)
                },
                |(mut world, root)| root.layout(&mut world.cache, &world.tree, &world.store, &mut ()),
                criterion::BatchSize::SmallInput,
            )
        });
    }

    group.finish();

    let mut group = c.benchmark_group("Super Deep Tree");
    group.sample_size(10);

    let children_per_node = 1;

    let depth = 1000usize;
    let benchmark_id = BenchmarkId::new(
        format!(
            "Super Deep Bench. {children_per_node} child per node, depth: {depth}. Total nodes: {}.",
            compute_node_count(children_per_node, depth, &mut 0)
        ),
        depth,
    );
    group.bench_with_input(benchmark_id, &depth, |b, &depth| {
        b.iter_batched(
            || {
                let mut world = World::default();
                let root = build_tree(&mut world, None, children_per_node, depth);
                (world, root)
            },
            |(mut world, root)| root.layout(&mut world.cache, &world.tree, &world.store, &mut ()),
            criterion::BatchSize::SmallInput,
        )
    });

    group.finish();

    let mut group = c.benchmark_group("Steady State Tree");
    group.sample_size(20);

    let children_per_node = 10;
    let depth = 6usize;
    let mut world = World::default();
    let root = build_tree(&mut world, None, children_per_node, depth);

    let benchmark_label = format!(
        "Steady state bench. {children_per_node} children per node, depth: {depth}. Total nodes: {}.",
        compute_node_count(children_per_node, depth, &mut 0)
    );

    group.bench_function(benchmark_label, |b| {
        b.iter(|| {
            root.layout(&mut world.cache, &world.tree, &world.store, &mut ());
        })
    });

    group.finish();
}

criterion_group!(benches, morphorm_benchmarks);
criterion_main!(benches);