tawasuyu

tawasuyu/taffy

A high performance rust-powered UI layout library

Rust 499HTML 245JavaScript 8Markdown 71218 Definiciones

Run setup for every iteration of the benchmark

166279fe39abee8bf36635e69add14023b0a8749 · por Nico Burns · (hace 3 años) · padre 59c2af6eb · ver el árbol en este commit

Delta semántico · 1

benches/big_tree.rs

1 archivos · +173 −58

diff --git a/benches/big_tree.rs b/benches/big_tree.rs
index d40266ded..47b51876e 100644
--- a/benches/big_tree.rs
+++ b/benches/big_tree.rs
@@ -89,39 +89,75 @@ fn taffy_benchmarks(c: &mut Criterion) {
     group.sample_size(10);
 
     group.bench_function("10 nodes", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_yoga_deep_hierarchy(&mut taffy, 10, 10);
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+        b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_yoga_deep_hierarchy(&mut taffy, 10, 10);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
     });
 
     group.bench_function("100 nodes", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_yoga_deep_hierarchy(&mut taffy, 100, 10);
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+        b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_yoga_deep_hierarchy(&mut taffy, 100, 10);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
     });
 
     group.bench_function("1_000 nodes", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_yoga_deep_hierarchy(&mut taffy, 1_000, 10);
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+        b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_yoga_deep_hierarchy(&mut taffy, 1_000, 10);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
     });
 
     group.bench_function("10_000 nodes", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_yoga_deep_hierarchy(&mut taffy, 10_000, 10);
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+       b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_yoga_deep_hierarchy(&mut taffy, 10_000, 10);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
     });
 
     group.bench_function("100_000 nodes", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_yoga_deep_hierarchy(&mut taffy, 100_000, 10);
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+        b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_yoga_deep_hierarchy(&mut taffy, 100_000, 10);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::LargeInput,
+        )
     });
 
     // group.bench_function("1_000_000 nodes", |b| {
-    //     let mut taffy = Taffy::new();
-    //     let root = build_yoga_deep_hierarchy(&mut taffy, 1_000_000, 10);
-    //     b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+    //     b.iter_batched(
+    //         || {
+    //             let mut taffy = Taffy::new();
+    //             let root = build_yoga_deep_hierarchy(&mut taffy, 1_000_000, 10);
+    //             (taffy, root)
+    //         },
+    //         |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+    //         criterion::BatchSize::LargeInput,
+    //     )
     // });
     drop(group);
 
@@ -130,45 +166,75 @@ fn taffy_benchmarks(c: &mut Criterion) {
     group.sample_size(10);
 
     group.bench_function("10 nodes (2-level hierarchy)", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_flat_hierarchy(&mut taffy, 10);
-
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+        b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_flat_hierarchy(&mut taffy, 10);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
     });
 
     group.bench_function("100 nodes (2-level hierarchy)", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_flat_hierarchy(&mut taffy, 100);
-
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+         b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_flat_hierarchy(&mut taffy, 100);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
     });
 
     group.bench_function("1_000 nodes (2-level hierarchy)", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_flat_hierarchy(&mut taffy, 1_000);
-
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+         b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_flat_hierarchy(&mut taffy, 1_000);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
     });
 
     group.bench_function("10_000 nodes (2-level hierarchy)", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_flat_hierarchy(&mut taffy, 10_000);
-
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+       b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_flat_hierarchy(&mut taffy, 10_000);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::LargeInput,
+        )
     });
 
     group.bench_function("100_000 nodes (2-level hierarchy)", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_flat_hierarchy(&mut taffy, 100_000);
-
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+        b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_flat_hierarchy(&mut taffy, 100_000);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::LargeInput,
+        )
     });
 
     group.bench_function("100_000 nodes (7-level hierarchy)", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_deep_hierarchy(&mut taffy, 100_000, 7);
-
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+        b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_deep_hierarchy(&mut taffy, 100_000, 7);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::LargeInput,
+        )
     });
 
     drop(group);
@@ -178,32 +244,81 @@ fn taffy_benchmarks(c: &mut Criterion) {
     group.sample_size(10);
 
     group.bench_function("4000 nodes (12-level hierarchy)", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_deep_hierarchy(&mut taffy, 4000, 2);
-
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+        b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_deep_hierarchy(&mut taffy, 4000, 2);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
     });
 
     group.bench_function("10_000 nodes (14-level hierarchy)", |b| {
-        let mut taffy = Taffy::new();
-        let root = build_deep_hierarchy(&mut taffy, 10_000, 2);
-
-        b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+        b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_deep_hierarchy(&mut taffy, 10_000, 2);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
     });
 
     // group.bench_function("100_000 nodes (17-level hierarchy)", |b| {
-    //     let mut taffy = Taffy::new();
-    //     let root = build_deep_hierarchy(&mut taffy, 100_000, 2);
-
-    //     b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+    //     b.iter_batched(
+    //         || {
+    //             let mut taffy = Taffy::new();
+    //             let root = build_deep_hierarchy(&mut taffy, 100_000, 2);
+    //             (taffy, root)
+    //         },
+    //         |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+    //         criterion::BatchSize::LargeInput,
+    //     )
     // });
 
     // group.bench_function("1_000_000 nodes (20-level hierarchy)", |b| {
-    //     let mut taffy = Taffy::new();
-    //     let root = build_deep_hierarchy(&mut taffy, 1_000_000, 2);
-
-    //     b.iter(|| taffy.compute_layout(root, Size::undefined()).unwrap())
+    //      b.iter_batched(
+    //         || {
+    //             let mut taffy = Taffy::new();
+    //             let root = build_deep_hierarchy(&mut taffy, 1_000_000, 2);
+    //             (taffy, root)
+    //         },
+    //         |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+    //         criterion::BatchSize::LargeInput,
+    //     )
     // });
+
+    drop(group);
+
+    let mut group = c.benchmark_group("super deep trees");
+    group.sample_size(10);
+
+    group.bench_function("100 nodes (100-level hierarchy)", |b| {
+         b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_deep_hierarchy(&mut taffy, 100, 1);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
+    });
+
+    group.bench_function("1_000 nodes (1000-level hierarchy)", |b| {
+         b.iter_batched(
+            || {
+                let mut taffy = Taffy::new();
+                let root = build_deep_hierarchy(&mut taffy, 1_000, 1);
+                (taffy, root)
+            },
+            |(mut taffy, root)| taffy.compute_layout(root, Size::undefined()).unwrap(),
+            criterion::BatchSize::SmallInput,
+        )
+    });
 }
 
 criterion_group!(benches, taffy_benchmarks);