perf(bundler): Improve performance (#2394)

swc_ecma_utils: - Make `collect_decls` parallel. (with threshold of 128) swc_bundler: - Make inlining of synthesized variables parallel.
swc-project · Oct 11, 2021 · b5f8321 · b5f8321
1 parent 98cc79a
commit b5f8321
Show file tree

Hide file tree

Showing 6 changed files with 100 additions and 15 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/bundler/Cargo.toml b/bundler/Cargo.toml
@@ -30,6 +30,7 @@ dashmap = {version = "4.0.2", optional = true}
 indexmap = "1.6"
 is-macro = "0.1"
 once_cell = "1"
+parking_lot = "0.11"
 petgraph = "0.5"
 radix_fmt = "1"
 rayon = {version = "1", optional = true}

diff --git a/bundler/src/inline.rs b/bundler/src/inline.rs
@@ -1,4 +1,4 @@
-use crate::{id::Id, modules::Modules};
+use crate::{id::Id, modules::Modules, util::Readonly};
 use swc_common::{collections::AHashMap, SyntaxContext, DUMMY_SP};
 use swc_ecma_ast::*;
 use swc_ecma_visit::{
@@ -14,26 +14,37 @@ pub(crate) struct InlineData {
 pub(crate) fn inline(injected_ctxt: SyntaxContext, module: &mut Modules) {
     tracing::debug!("Inlining injected variables");
 
-    let mut v = Inliner {
-        injected_ctxt,
-        data: Default::default(),
-    };
+    let mut data = Default::default();
 
-    module.visit_with(&mut v);
-    module.visit_mut_with(&mut v);
+    {
+        let mut analyzer = Analyzer {
+            injected_ctxt,
+            data: &mut data,
+        };
+
+        module.visit_with(&mut analyzer);
+    }
+
+    let mut v = Inliner { data: data.into() };
+    module.par_visit_mut_with(&mut v);
     module.retain_mut(|_, s| match s {
         ModuleItem::Stmt(Stmt::Empty(..)) => false,
         _ => true,
     });
 }
 
 #[derive(Debug)]
+#[cfg_attr(feature = "concurrent", derive(Clone))]
 struct Inliner {
+    data: Readonly<InlineData>,
+}
+
+struct Analyzer<'a> {
     injected_ctxt: SyntaxContext,
-    data: InlineData,
+    data: &'a mut InlineData,
 }
 
-impl Inliner {
+impl Analyzer<'_> {
     fn store(&mut self, from: Id, to: Id) {
         if let Some(prev) = self.data.ids.insert(from.clone(), to.clone()) {
             unreachable!(
@@ -45,7 +56,7 @@ impl Inliner {
     }
 }
 
-impl Visit for Inliner {
+impl Visit for Analyzer<'_> {
     noop_visit_type!();
 
     /// Noop

diff --git a/bundler/src/modules/mod.rs b/bundler/src/modules/mod.rs
@@ -152,6 +152,44 @@ impl Modules {
             .push(item);
     }
 
+    #[cfg(not(feature = "concurrent"))]
+    pub(crate) fn par_visit_mut_with<V>(&mut self, v: &mut V)
+    where
+        V: VisitMut,
+    {
+        self.visit_mut_with(v)
+    }
+
+    #[cfg(feature = "concurrent")]
+    pub(crate) fn par_visit_mut_with<V>(&mut self, v: &mut V)
+    where
+        V: Clone + VisitMut + Send + Sync,
+    {
+        use rayon::prelude::*;
+
+        let pre = &mut self.prepended_stmts;
+        let modules = &mut self.modules;
+        let app = &mut self.appended_stmts;
+
+        rayon::scope(|s| {
+            s.spawn(|_| {
+                pre.par_iter_mut()
+                    .for_each(|(_, stmts)| stmts.visit_mut_with(&mut v.clone()));
+            });
+
+            s.spawn(|_| {
+                modules
+                    .par_iter_mut()
+                    .for_each(|(_, stmts)| stmts.visit_mut_with(&mut v.clone()));
+            });
+
+            s.spawn(|_| {
+                app.par_iter_mut()
+                    .for_each(|(_, stmts)| stmts.visit_mut_with(&mut v.clone()));
+            });
+        });
+    }
+
     pub fn visit_mut_with<V>(&mut self, v: &mut V)
     where
         V: VisitMut,

diff --git a/bundler/src/util.rs b/bundler/src/util.rs
@@ -8,6 +8,12 @@ use swc_ecma_visit::{noop_visit_mut_type, VisitMut};
 
 pub(crate) mod fast_graph;
 
+#[cfg(feature = "concurrent")]
+pub(crate) type Readonly<T> = std::sync::Arc<T>;
+
+#[cfg(not(feature = "concurrent"))]
+pub(crate) type Readonly<T> = T;
+
 const TRACK: bool = false;
 
 pub(crate) trait VarDeclaratorExt: Into<VarDeclarator> {

diff --git a/ecmascript/utils/src/lib.rs b/ecmascript/utils/src/lib.rs
@@ -2084,7 +2084,7 @@ impl VisitMut for IdentReplacer<'_> {
 
 pub struct BindingCollector<I>
 where
-    I: IdentLike + Eq + Hash,
+    I: IdentLike + Eq + Hash + Send + Sync,
 {
     only: Option<SyntaxContext>,
     bindings: AHashSet<I>,
@@ -2093,7 +2093,7 @@ where
 
 impl<I> BindingCollector<I>
 where
-    I: IdentLike + Eq + Hash,
+    I: IdentLike + Eq + Hash + Send + Sync,
 {
     fn add(&mut self, i: &Ident) {
         if let Some(only) = self.only {
@@ -2108,10 +2108,38 @@ where
 
 impl<I> Visit for BindingCollector<I>
 where
-    I: IdentLike + Eq + Hash,
+    I: IdentLike + Eq + Hash + Send + Sync,
 {
     noop_visit_type!();
 
+    fn visit_module_items(&mut self, nodes: &[ModuleItem], _: &dyn Node) {
+        #[cfg(feature = "concurrent")]
+        if nodes.len() > 128 {
+            use rayon::prelude::*;
+            let set = nodes
+                .par_iter()
+                .map(|node| {
+                    let mut v = BindingCollector {
+                        only: self.only,
+                        bindings: Default::default(),
+                        is_pat_decl: self.is_pat_decl,
+                    };
+                    node.visit_with(&Invalid { span: DUMMY_SP }, &mut v);
+                    v.bindings
+                })
+                .reduce(AHashSet::default, |mut a, b| {
+                    a.extend(b);
+                    a
+                });
+            self.bindings.extend(set);
+            return;
+        }
+
+        for node in nodes {
+            node.visit_children_with(self)
+        }
+    }
+
     fn visit_class_decl(&mut self, node: &ClassDecl, _: &dyn Node) {
         node.visit_children_with(self);
 
@@ -2182,7 +2210,7 @@ where
 /// Collects binding identifiers.
 pub fn collect_decls<I, N>(n: &N) -> AHashSet<I>
 where
-    I: IdentLike + Eq + Hash,
+    I: IdentLike + Eq + Hash + Send + Sync,
     N: VisitWith<BindingCollector<I>>,
 {
     let mut v = BindingCollector {
@@ -2198,7 +2226,7 @@ where
 /// identical to `ctxt`.
 pub fn collect_decls_with_ctxt<I, N>(n: &N, ctxt: SyntaxContext) -> AHashSet<I>
 where
-    I: IdentLike + Eq + Hash,
+    I: IdentLike + Eq + Hash + Send + Sync,
     N: VisitWith<BindingCollector<I>>,
 {
     let mut v = BindingCollector {