Improve benchmarks to also test for updating many elements at once

packages/tui/benches/update.rs

@@ -7,9 +7,9 @@ criterion_main!(mbenches);
 
 /// This benchmarks the cache performance of the TUI for small edits by changing one box at a time.
 fn tui_update(c: &mut Criterion) {
+    {
         let mut group = c.benchmark_group("Update boxes");
 
-    // We can also use loops to define multiple benchmarks, even over multiple dimensions.
         for size in 1..=20usize {
             let parameter_string = format!("{}", (size).pow(2));
             group.bench_with_input(
@@ -17,11 +17,44 @@ fn tui_update(c: &mut Criterion) {
                 &size,
                 |b, size| {
                     b.iter(|| {
-                    dioxus_tui::launch_cfg_with_props(app, *size, Config::default().with_headless())
+                        dioxus_tui::launch_cfg_with_props(
+                            app,
+                            GridProps {
+                                size: *size,
+                                update_count: 1,
+                            },
+                            Config::default().with_headless(),
+                        )
                     })
                 },
             );
         }
+    }
+
+    {
+        let mut group = c.benchmark_group("Update many boxes");
+
+        for update_count in 1..=20usize {
+            let update_count = update_count * 20;
+            let parameter_string = update_count.to_string();
+            group.bench_with_input(
+                BenchmarkId::new("update count", parameter_string),
+                &update_count,
+                |b, update_count| {
+                    b.iter(|| {
+                        dioxus_tui::launch_cfg_with_props(
+                            app,
+                            GridProps {
+                                size: 20,
+                                update_count: *update_count,
+                            },
+                            Config::default().with_headless(),
+                        )
+                    })
+                },
+            );
+        }
+    }
 }
 
 #[derive(Props, PartialEq)]
@@ -58,6 +91,7 @@ fn Box(cx: Scope<BoxProps>) -> Element {
 #[derive(Props, PartialEq)]
 struct GridProps {
     size: usize,
+    update_count: usize,
 }
 #[allow(non_snake_case)]
 fn Grid(cx: Scope<GridProps>) -> Element {
@@ -66,9 +100,10 @@ fn Grid(cx: Scope<GridProps>) -> Element {
     let counts = use_ref(cx, || vec![0; size * size]);
 
     let ctx: TuiContext = cx.consume_context().unwrap();
-    if *count.get() + 1 >= (size * size) {
+    if *count.get() + cx.props.update_count >= (size * size) {
         ctx.quit();
     } else {
+        for _ in 0..cx.props.update_count {
             counts.with_mut(|c| {
                 let i = *count.current();
                 c[i] += 1;
@@ -79,6 +114,7 @@ fn Grid(cx: Scope<GridProps>) -> Element {
                 *i %= size * size;
             });
         }
+    }
 
     render! {
         div{
@@ -115,13 +151,14 @@ fn Grid(cx: Scope<GridProps>) -> Element {
     }
 }
 
-fn app(cx: Scope<usize>) -> Element {
+fn app(cx: Scope<GridProps>) -> Element {
     cx.render(rsx! {
         div{
             width: "100%",
             height: "100%",
             Grid{
-                size: *cx.props,
+                size: cx.props.size,
+                update_count: cx.props.update_count,
             }
         }
     })