test(es/minifier): Add a benchmark for real-world inputs (#10204)

kdy1 · web-flow · commit 97f2180e8632 · 2025-03-15T17:24:28.000+09:00
**Description:**

I pinned the commit using the hash to make updating the inputs explicit.
diff --git a/.changeset/selfish-badgers-repair.md b/.changeset/selfish-badgers-repair.md
@@ -0,0 +1,6 @@
+---
+swc_core: patch
+swc_ecma_transforms_optimization: patch
+---
+
+test(es/minifier): Add a benchmark for real-world inputs
diff --git a/crates/swc_ecma_minifier/benches/full.rs b/crates/swc_ecma_minifier/benches/full.rs
@@ -2,20 +2,26 @@
 
 extern crate swc_malloc;
 
-use std::fs::read_to_string;
+use std::{
+    fs::read_to_string,
+    path::{Path, PathBuf},
+    process::Command,
+};
 
 use codspeed_criterion_compat::{black_box, criterion_group, criterion_main, Criterion};
-use swc_common::{errors::HANDLER, sync::Lrc, FileName, Mark, SourceMap};
-use swc_ecma_ast::Program;
+use swc_common::{sync::Lrc, FileName, Mark, SourceMap, GLOBALS};
 use swc_ecma_codegen::text_writer::JsWriter;
 use swc_ecma_minifier::{
     optimize,
     option::{ExtraOptions, MangleOptions, MinifyOptions},
 };
-use swc_ecma_parser::parse_file_as_module;
+use swc_ecma_parser::parse_file_as_program;
 use swc_ecma_transforms_base::{fixer::fixer, resolver};
+use swc_ecma_utils::parallel::{Parallel, ParallelExt};
+use testing::CARGO_TARGET_DIR;
+use walkdir::WalkDir;
 
-pub fn bench_files(c: &mut Criterion) {
+fn bench_libs(c: &mut Criterion) {
     let mut group = c.benchmark_group("es/minifier/libs");
     group.sample_size(10);
 
@@ -45,65 +51,151 @@ pub fn bench_files(c: &mut Criterion) {
     bench_file("vue");
 }
 
-criterion_group!(files, bench_files);
-criterion_main!(files);
+fn bench_real(c: &mut Criterion) {
+    let input_dir = CARGO_TARGET_DIR.join("swc-minifier-inputs");
 
-fn run(src: &str) {
-    testing::run_test2(false, |cm, handler| {
-        HANDLER.set(&handler, || {
-            let fm = cm.new_source_file(FileName::Anon.into(), src.into());
-
-            let unresolved_mark = Mark::new();
-            let top_level_mark = Mark::new();
-
-            let program = parse_file_as_module(
-                &fm,
-                Default::default(),
-                Default::default(),
-                None,
-                &mut Vec::new(),
-            )
-            .map_err(|err| {
-                err.into_diagnostic(&handler).emit();
-            })
-            .map(Program::Module)
-            .map(|module| module.apply(resolver(unresolved_mark, top_level_mark, false)))
+    git_clone(
+        "https://github.com/kdy1/swc-minifier-inputs.git",
+        "a967ebba1668d1f78e1b5077bdbdce6ad0bfcaee",
+        &input_dir,
+    );
+
+    let mut group = c.benchmark_group("es/minifier/real");
+    group.sample_size(10);
+
+    let files = expand_dirs(&input_dir);
+    let sources = files
+        .iter()
+        .map(|path| read_to_string(path).unwrap())
+        .collect::<Vec<_>>();
+
+    group.bench_function("es/minifier/real/sequential", |b| {
+        b.iter(|| {
+            // We benchmark full time, including time for creating cm, handler
+
+            for src in &sources {
+                run(src);
+            }
+        })
+    });
+
+    group.bench_function("es/minifier/real/parallel", |b| {
+        b.iter(|| {
+            // We benchmark full time, including time for creating cm, handler
+
+            GLOBALS.set(&Default::default(), || {
+                Worker::default().maybe_par(0, &*sources, |_, src| run(src));
+            });
+        })
+    });
+}
+
+#[derive(Default, Clone, Copy)]
+struct Worker {}
+
+impl Parallel for Worker {
+    fn create(&self) -> Self {
+        *self
+    }
+
+    fn merge(&mut self, _other: Self) {}
+}
+
+fn git_clone(url: &str, commit: &str, path: &Path) {
+    if !path.join(".git").exists() {
+        let status = Command::new("git")
+            .arg("clone")
+            .arg(url)
+            .arg(path)
+            .status()
             .unwrap();
 
-            let output = optimize(
-                program,
-                cm.clone(),
-                None,
-                None,
-                &MinifyOptions {
-                    rename: false,
-                    compress: Some(Default::default()),
-                    mangle: Some(MangleOptions {
-                        props: None,
-                        top_level: Some(true),
-                        keep_class_names: false,
-                        keep_fn_names: false,
-                        keep_private_props: false,
-                        ie8: false,
-                        ..Default::default()
-                    }),
-                    wrap: false,
-                    enclose: false,
-                },
-                &ExtraOptions {
-                    unresolved_mark,
-                    top_level_mark,
-                    mangle_name_cache: None,
-                },
-            );
-
-            let output = output.apply(fixer(None));
-
-            let code = print(cm, &[output], true);
-
-            black_box(code);
-            Ok(())
+        if !status.success() {
+            panic!("failed to clone `{}` to `{}`", url, path.display());
+        }
+    }
+
+    let status = Command::new("git")
+        .current_dir(path)
+        .args(["checkout", commit])
+        .status()
+        .unwrap();
+
+    if !status.success() {
+        panic!("failed to checkout `{}` in `{}`", commit, path.display());
+    }
+}
+
+/// Return the whole input files as abolute path.
+fn expand_dirs(dir: &Path) -> Vec<PathBuf> {
+    WalkDir::new(dir)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter_map(|entry| {
+            if entry.metadata().map(|v| v.is_file()).unwrap_or(false) {
+                Some(entry.into_path())
+            } else {
+                None
+            }
         })
+        .filter(|path| path.extension().map(|ext| ext == "js").unwrap_or(false))
+        .collect::<Vec<_>>()
+}
+
+fn run(src: &str) {
+    testing::run_test2(false, |cm, handler| {
+        let fm = cm.new_source_file(FileName::Anon.into(), src.into());
+
+        let unresolved_mark = Mark::new();
+        let top_level_mark = Mark::new();
+
+        let Ok(program) = parse_file_as_program(
+            &fm,
+            Default::default(),
+            Default::default(),
+            None,
+            &mut Vec::new(),
+        )
+        .map_err(|err| {
+            err.into_diagnostic(&handler).emit();
+        })
+        .map(|program| program.apply(resolver(unresolved_mark, top_level_mark, false))) else {
+            return Ok(());
+        };
+
+        let output = optimize(
+            program,
+            cm.clone(),
+            None,
+            None,
+            &MinifyOptions {
+                rename: false,
+                compress: Some(Default::default()),
+                mangle: Some(MangleOptions {
+                    props: None,
+                    top_level: Some(true),
+                    keep_class_names: false,
+                    keep_fn_names: false,
+                    keep_private_props: false,
+                    ie8: false,
+                    ..Default::default()
+                }),
+                wrap: false,
+                enclose: false,
+            },
+            &ExtraOptions {
+                unresolved_mark,
+                top_level_mark,
+                mangle_name_cache: None,
+            },
+        );
+
+        let output = output.apply(fixer(None));
+
+        let code = print(cm, &[output], true);
+
+        black_box(code);
+        Ok(())
     })
     .unwrap();
 }
@@ -126,3 +218,6 @@ fn print<N: swc_ecma_codegen::Node>(cm: Lrc<SourceMap>, nodes: &[N], minify: boo
 
     String::from_utf8(buf).unwrap()
 }
+
+criterion_group!(bench_all, bench_libs, bench_real);
+criterion_main!(bench_all);
diff --git a/crates/swc_ecma_minifier/tests/exec.rs b/crates/swc_ecma_minifier/tests/exec.rs
@@ -98,10 +98,6 @@ fn run(
     config: Option<&str>,
     mangle: Option<MangleOptions>,
 ) -> Option<Program> {
-    let _ = rayon::ThreadPoolBuilder::new()
-        .thread_name(|i| format!("rayon-{}", i + 1))
-        .build_global();
-
     let compress_config = config.map(|config| parse_compressor_config(cm.clone(), config).1);
 
     let fm = cm.new_source_file(FileName::Anon.into(), input.into());
diff --git a/crates/swc_ecma_transforms_optimization/src/simplify/dce/mod.rs b/crates/swc_ecma_transforms_optimization/src/simplify/dce/mod.rs
@@ -10,12 +10,10 @@ use swc_common::{
     Mark, SyntaxContext, DUMMY_SP,
 };
 use swc_ecma_ast::*;
-use swc_ecma_transforms_base::{
-    helpers::{Helpers, HELPERS},
-    perf::{cpu_count, ParVisitMut, Parallel},
-};
+use swc_ecma_transforms_base::perf::{cpu_count, Parallel};
 use swc_ecma_utils::{
-    collect_decls, find_pat_ids, ExprCtx, ExprExt, IsEmpty, ModuleItemLike, StmtLike, Value::Known,
+    collect_decls, find_pat_ids, parallel::ParallelExt, ExprCtx, ExprExt, IsEmpty, ModuleItemLike,
+    StmtLike, Value::Known,
 };
 use swc_ecma_visit::{
     noop_visit_mut_type, noop_visit_type, visit_mut_pass, Visit, VisitMut, VisitMutWith, VisitWith,
@@ -673,6 +671,13 @@ impl TreeShaker {
             self.changed = true;
         }
     }
+
+    fn visit_mut_par<N>(&mut self, threshold: usize, nodes: &mut [N])
+    where
+        N: Send + Sync + VisitMutWith<Self>,
+    {
+        self.maybe_par(threshold, nodes, |v, n| n.visit_mut_with(v));
+    }
 }
 
 impl VisitMut for TreeShaker {
@@ -918,9 +923,7 @@ impl VisitMut for TreeShaker {
         data.subtract_cycles();
         self.data = Arc::new(data);
 
-        HELPERS.set(&Helpers::new(true), || {
-            m.visit_mut_children_with(self);
-        })
+        m.visit_mut_children_with(self);
     }
 
     fn visit_mut_module_item(&mut self, n: &mut ModuleItem) {
@@ -981,9 +984,7 @@ impl VisitMut for TreeShaker {
         data.subtract_cycles();
         self.data = Arc::new(data);
 
-        HELPERS.set(&Helpers::new(true), || {
-            m.visit_mut_children_with(self);
-        })
+        m.visit_mut_children_with(self);
     }
 
     fn visit_mut_stmt(&mut self, s: &mut Stmt) {
