From 563bb2813f90839d70a418a15b39eabd73215ae2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Mockers?= <francois.mockers@vleue.com>
Date: Sun, 29 Mar 2026 13:46:52 +0200
Subject: [PATCH 1/3] don't copy assets if they're already thre

---
 src/metrics/large_scenes.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/metrics/large_scenes.rs b/src/metrics/large_scenes.rs
index aae4a9266..6d4eb9ea6 100644
--- a/src/metrics/large_scenes.rs
+++ b/src/metrics/large_scenes.rs
@@ -42,7 +42,9 @@ impl Metrics for LargeScene {
         if fs_extra::dir::copy(
             format!("/assets/{scene}"),
             format!("examples/large_scenes/{scene}/assets"),
-            &fs_extra::dir::CopyOptions::new().copy_inside(true),
+            &fs_extra::dir::CopyOptions::new()
+                .copy_inside(true)
+                .skip_exist(true),
         )
         .is_err()
         {

From bfcbf5723ccf6bce9a471dfa4ae986cdca0a6445 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Mockers?= <francois.mockers@vleue.com>
Date: Sun, 29 Mar 2026 13:47:10 +0200
Subject: [PATCH 2/3] configure linker for compression

---
 src/metrics/large_scenes.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/metrics/large_scenes.rs b/src/metrics/large_scenes.rs
index 6d4eb9ea6..2eda1ea0c 100644
--- a/src/metrics/large_scenes.rs
+++ b/src/metrics/large_scenes.rs
@@ -52,6 +52,12 @@ impl Metrics for LargeScene {
         }
 
         let sh = Shell::new().unwrap();
+        if self
+            .features
+            .contains(&"mipmap_generator/compress".to_string())
+        {
+            sh.set_var("RUSTFLAGS", "-C linker=clang");
+        }
         let mut features = self.features.clone();
         features.push("bevy/bevy_ci_testing".to_string());
         let features = features
@@ -105,6 +111,12 @@ impl Metrics for LargeScene {
             .unwrap();
         let sh = Shell::new().unwrap();
         sh.set_var("CI_TESTING_CONFIG", config);
+        if self
+            .features
+            .contains(&"mipmap_generator/compress".to_string())
+        {
+            sh.set_var("RUSTFLAGS", "-C linker=clang");
+        }
 
         let parameters = self
             .parameters

From f0f9520b864dc075a5b72496b91e2dce1ce076a9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fran=C3=A7ois=20Mockers?= <francois.mockers@vleue.com>
Date: Sun, 29 Mar 2026 14:01:30 +0200
Subject: [PATCH 3/3] don't panic on missing data

---
 src/metrics/large_scenes.rs | 200 +++++++++++++++++++-----------------
 src/metrics/stress_tests.rs | 200 +++++++++++++++++++-----------------
 2 files changed, 208 insertions(+), 192 deletions(-)

diff --git a/src/metrics/large_scenes.rs b/src/metrics/large_scenes.rs
index 2eda1ea0c..95e7167bf 100644
--- a/src/metrics/large_scenes.rs
+++ b/src/metrics/large_scenes.rs
@@ -179,74 +179,80 @@ impl Metrics for LargeScene {
         let gpu_memory = gpu_usage.iter().map(|v| v.mem as f32).collect::<Vec<_>>();
         let gpu_usage = gpu_usage.iter().map(|v| v.sm as f32).collect::<Vec<_>>();
 
-        results.insert(
-            format!("{key}.cpu_usage.mean"),
-            (statistical::mean(&cpu_usage) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.cpu_usage.median"),
-            (statistical::median(&cpu_usage) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.cpu_usage.min"),
-            cpu_usage.iter().map(|d| (d * 1000.0) as u64).min().unwrap(),
-        );
-        results.insert(
-            format!("{key}.cpu_usage.max"),
-            cpu_usage.iter().map(|d| (d * 1000.0) as u64).max().unwrap(),
-        );
-        results.insert(
-            format!("{key}.cpu_usage.std_dev"),
-            (statistical::standard_deviation(&cpu_usage, None) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_usage.mean"),
-            (statistical::mean(&gpu_usage) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_usage.median"),
-            (statistical::median(&gpu_usage) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_usage.min"),
-            gpu_usage.iter().map(|d| (d * 1000.0) as u64).min().unwrap(),
-        );
-        results.insert(
-            format!("{key}.gpu_usage.max"),
-            gpu_usage.iter().map(|d| (d * 1000.0) as u64).max().unwrap(),
-        );
-        results.insert(
-            format!("{key}.gpu_usage.std_dev"),
-            (statistical::standard_deviation(&gpu_usage, None) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_memory.mean"),
-            (statistical::mean(&gpu_memory) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_memory.median"),
-            (statistical::median(&gpu_memory) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_memory.min"),
-            gpu_memory
-                .iter()
-                .map(|d| (d * 1000.0) as u64)
-                .min()
-                .unwrap(),
-        );
-        results.insert(
-            format!("{key}.gpu_memory.max"),
-            gpu_memory
-                .iter()
-                .map(|d| (d * 1000.0) as u64)
-                .max()
-                .unwrap(),
-        );
-        results.insert(
-            format!("{key}.gpu_memory.std_dev"),
-            (statistical::standard_deviation(&gpu_memory, None) * 1000.0) as u64,
-        );
+        if cpu_usage.len() > 3 {
+            results.insert(
+                format!("{key}.cpu_usage.mean"),
+                (statistical::mean(&cpu_usage) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.cpu_usage.median"),
+                (statistical::median(&cpu_usage) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.cpu_usage.min"),
+                cpu_usage.iter().map(|d| (d * 1000.0) as u64).min().unwrap(),
+            );
+            results.insert(
+                format!("{key}.cpu_usage.max"),
+                cpu_usage.iter().map(|d| (d * 1000.0) as u64).max().unwrap(),
+            );
+            results.insert(
+                format!("{key}.cpu_usage.std_dev"),
+                (statistical::standard_deviation(&cpu_usage, None) * 1000.0) as u64,
+            );
+        }
+        if gpu_usage.len() > 3 {
+            results.insert(
+                format!("{key}.gpu_usage.mean"),
+                (statistical::mean(&gpu_usage) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.gpu_usage.median"),
+                (statistical::median(&gpu_usage) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.gpu_usage.min"),
+                gpu_usage.iter().map(|d| (d * 1000.0) as u64).min().unwrap(),
+            );
+            results.insert(
+                format!("{key}.gpu_usage.max"),
+                gpu_usage.iter().map(|d| (d * 1000.0) as u64).max().unwrap(),
+            );
+            results.insert(
+                format!("{key}.gpu_usage.std_dev"),
+                (statistical::standard_deviation(&gpu_usage, None) * 1000.0) as u64,
+            );
+        }
+        if gpu_memory.len() > 3 {
+            results.insert(
+                format!("{key}.gpu_memory.mean"),
+                (statistical::mean(&gpu_memory) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.gpu_memory.median"),
+                (statistical::median(&gpu_memory) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.gpu_memory.min"),
+                gpu_memory
+                    .iter()
+                    .map(|d| (d * 1000.0) as u64)
+                    .min()
+                    .unwrap(),
+            );
+            results.insert(
+                format!("{key}.gpu_memory.max"),
+                gpu_memory
+                    .iter()
+                    .map(|d| (d * 1000.0) as u64)
+                    .max()
+                    .unwrap(),
+            );
+            results.insert(
+                format!("{key}.gpu_memory.std_dev"),
+                (statistical::standard_deviation(&gpu_memory, None) * 1000.0) as u64,
+            );
+        }
         results.insert(format!("{key}.duration"), elapsed.as_millis() as u64);
         results.insert(format!("{key}.frames"), self.nb_frames as u64);
 
@@ -272,34 +278,36 @@ impl Metrics for LargeScene {
                 .flat_map(|record| record.get(1).unwrap().parse::<f32>())
                 .collect::<Vec<_>>();
 
-            results.insert(
-                format!("{key}.frame_time.mean"),
-                (statistical::mean(&frame_times) * 1000.0) as u64,
-            );
-            results.insert(
-                format!("{key}.frame_time.median"),
-                (statistical::median(&frame_times) * 1000.0) as u64,
-            );
-            results.insert(
-                format!("{key}.frame_time.min"),
-                frame_times
-                    .iter()
-                    .map(|d| (d * 1000.0) as u64)
-                    .min()
-                    .unwrap(),
-            );
-            results.insert(
-                format!("{key}.frame_time.max"),
-                frame_times
-                    .iter()
-                    .map(|d| (d * 1000.0) as u64)
-                    .max()
-                    .unwrap(),
-            );
-            results.insert(
-                format!("{key}.frame_time.std_dev"),
-                (statistical::standard_deviation(&frame_times, None) * 1000.0) as u64,
-            );
+            if !frame_times.len() > 3 {
+                results.insert(
+                    format!("{key}.frame_time.mean"),
+                    (statistical::mean(&frame_times) * 1000.0) as u64,
+                );
+                results.insert(
+                    format!("{key}.frame_time.median"),
+                    (statistical::median(&frame_times) * 1000.0) as u64,
+                );
+                results.insert(
+                    format!("{key}.frame_time.min"),
+                    frame_times
+                        .iter()
+                        .map(|d| (d * 1000.0) as u64)
+                        .min()
+                        .unwrap(),
+                );
+                results.insert(
+                    format!("{key}.frame_time.max"),
+                    frame_times
+                        .iter()
+                        .map(|d| (d * 1000.0) as u64)
+                        .max()
+                        .unwrap(),
+                );
+                results.insert(
+                    format!("{key}.frame_time.std_dev"),
+                    (statistical::standard_deviation(&frame_times, None) * 1000.0) as u64,
+                );
+            }
         }
 
         results
diff --git a/src/metrics/stress_tests.rs b/src/metrics/stress_tests.rs
index 0e760e8eb..43473ad49 100644
--- a/src/metrics/stress_tests.rs
+++ b/src/metrics/stress_tests.rs
@@ -197,74 +197,80 @@ impl Metrics for StressTest {
                 (statistical::standard_deviation(&fpss, None) * 1000.0) as u64,
             );
         }
-        results.insert(
-            format!("{key}.cpu_usage.mean"),
-            (statistical::mean(&cpu_usage) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.cpu_usage.median"),
-            (statistical::median(&cpu_usage) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.cpu_usage.min"),
-            cpu_usage.iter().map(|d| (d * 1000.0) as u64).min().unwrap(),
-        );
-        results.insert(
-            format!("{key}.cpu_usage.max"),
-            cpu_usage.iter().map(|d| (d * 1000.0) as u64).max().unwrap(),
-        );
-        results.insert(
-            format!("{key}.cpu_usage.std_dev"),
-            (statistical::standard_deviation(&cpu_usage, None) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_usage.mean"),
-            (statistical::mean(&gpu_usage) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_usage.median"),
-            (statistical::median(&gpu_usage) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_usage.min"),
-            gpu_usage.iter().map(|d| (d * 1000.0) as u64).min().unwrap(),
-        );
-        results.insert(
-            format!("{key}.gpu_usage.max"),
-            gpu_usage.iter().map(|d| (d * 1000.0) as u64).max().unwrap(),
-        );
-        results.insert(
-            format!("{key}.gpu_usage.std_dev"),
-            (statistical::standard_deviation(&gpu_usage, None) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_memory.mean"),
-            (statistical::mean(&gpu_memory) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_memory.median"),
-            (statistical::median(&gpu_memory) * 1000.0) as u64,
-        );
-        results.insert(
-            format!("{key}.gpu_memory.min"),
-            gpu_memory
-                .iter()
-                .map(|d| (d * 1000.0) as u64)
-                .min()
-                .unwrap(),
-        );
-        results.insert(
-            format!("{key}.gpu_memory.max"),
-            gpu_memory
-                .iter()
-                .map(|d| (d * 1000.0) as u64)
-                .max()
-                .unwrap(),
-        );
-        results.insert(
-            format!("{key}.gpu_memory.std_dev"),
-            (statistical::standard_deviation(&gpu_memory, None) * 1000.0) as u64,
-        );
+        if cpu_usage.len() > 3 {
+            results.insert(
+                format!("{key}.cpu_usage.mean"),
+                (statistical::mean(&cpu_usage) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.cpu_usage.median"),
+                (statistical::median(&cpu_usage) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.cpu_usage.min"),
+                cpu_usage.iter().map(|d| (d * 1000.0) as u64).min().unwrap(),
+            );
+            results.insert(
+                format!("{key}.cpu_usage.max"),
+                cpu_usage.iter().map(|d| (d * 1000.0) as u64).max().unwrap(),
+            );
+            results.insert(
+                format!("{key}.cpu_usage.std_dev"),
+                (statistical::standard_deviation(&cpu_usage, None) * 1000.0) as u64,
+            );
+        }
+        if gpu_usage.len() > 3 {
+            results.insert(
+                format!("{key}.gpu_usage.mean"),
+                (statistical::mean(&gpu_usage) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.gpu_usage.median"),
+                (statistical::median(&gpu_usage) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.gpu_usage.min"),
+                gpu_usage.iter().map(|d| (d * 1000.0) as u64).min().unwrap(),
+            );
+            results.insert(
+                format!("{key}.gpu_usage.max"),
+                gpu_usage.iter().map(|d| (d * 1000.0) as u64).max().unwrap(),
+            );
+            results.insert(
+                format!("{key}.gpu_usage.std_dev"),
+                (statistical::standard_deviation(&gpu_usage, None) * 1000.0) as u64,
+            );
+        }
+        if gpu_memory.len() > 3 {
+            results.insert(
+                format!("{key}.gpu_memory.mean"),
+                (statistical::mean(&gpu_memory) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.gpu_memory.median"),
+                (statistical::median(&gpu_memory) * 1000.0) as u64,
+            );
+            results.insert(
+                format!("{key}.gpu_memory.min"),
+                gpu_memory
+                    .iter()
+                    .map(|d| (d * 1000.0) as u64)
+                    .min()
+                    .unwrap(),
+            );
+            results.insert(
+                format!("{key}.gpu_memory.max"),
+                gpu_memory
+                    .iter()
+                    .map(|d| (d * 1000.0) as u64)
+                    .max()
+                    .unwrap(),
+            );
+            results.insert(
+                format!("{key}.gpu_memory.std_dev"),
+                (statistical::standard_deviation(&gpu_memory, None) * 1000.0) as u64,
+            );
+        }
         results.insert(format!("{key}.duration"), elapsed.as_millis() as u64);
         results.insert(format!("{key}.frames"), self.nb_frames as u64);
 
@@ -290,34 +296,36 @@ impl Metrics for StressTest {
                 .flat_map(|record| record.get(1).unwrap().parse::<f32>())
                 .collect::<Vec<_>>();
 
-            results.insert(
-                format!("{key}.frame_time.mean"),
-                (statistical::mean(&frame_times) * 1000.0) as u64,
-            );
-            results.insert(
-                format!("{key}.frame_time.median"),
-                (statistical::median(&frame_times) * 1000.0) as u64,
-            );
-            results.insert(
-                format!("{key}.frame_time.min"),
-                frame_times
-                    .iter()
-                    .map(|d| (d * 1000.0) as u64)
-                    .min()
-                    .unwrap(),
-            );
-            results.insert(
-                format!("{key}.frame_time.max"),
-                frame_times
-                    .iter()
-                    .map(|d| (d * 1000.0) as u64)
-                    .max()
-                    .unwrap(),
-            );
-            results.insert(
-                format!("{key}.frame_time.std_dev"),
-                (statistical::standard_deviation(&frame_times, None) * 1000.0) as u64,
-            );
+            if !frame_times.len() > 3 {
+                results.insert(
+                    format!("{key}.frame_time.mean"),
+                    (statistical::mean(&frame_times) * 1000.0) as u64,
+                );
+                results.insert(
+                    format!("{key}.frame_time.median"),
+                    (statistical::median(&frame_times) * 1000.0) as u64,
+                );
+                results.insert(
+                    format!("{key}.frame_time.min"),
+                    frame_times
+                        .iter()
+                        .map(|d| (d * 1000.0) as u64)
+                        .min()
+                        .unwrap(),
+                );
+                results.insert(
+                    format!("{key}.frame_time.max"),
+                    frame_times
+                        .iter()
+                        .map(|d| (d * 1000.0) as u64)
+                        .max()
+                        .unwrap(),
+                );
+                results.insert(
+                    format!("{key}.frame_time.std_dev"),
+                    (statistical::standard_deviation(&frame_times, None) * 1000.0) as u64,
+                );
+            }
         }
 
         results