chore: bench concat large minified source

benches/bench.rs

@@ -195,6 +195,45 @@ fn benchmark_replace_large_minified_source(b: &mut Bencher) {
   });
 }
 
+fn benchmark_concat_large_minified_source(b: &mut Bencher) {
+  let sms_minify = SourceMapSource::new(SourceMapSourceOptions {
+    value: HELLOWORLD_MIN_JS,
+    name: "helloworld.min.js",
+    source_map: SourceMap::from_json(HELLOWORLD_MIN_JS_MAP).unwrap(),
+    original_source: Some(HELLOWORLD_JS.to_string()),
+    inner_source_map: Some(SourceMap::from_json(HELLOWORLD_JS_MAP).unwrap()),
+    remove_original_source: false,
+  });
+
+  let sms_rollup = SourceMapSource::new(SourceMapSourceOptions {
+    value: BUNDLE_JS,
+    name: "bundle.js",
+    source_map: SourceMap::from_json(BUNDLE_JS_MAP).unwrap(),
+    original_source: None,
+    inner_source_map: None,
+    remove_original_source: false,
+  });
+
+  let antd_minify = SourceMapSource::new(SourceMapSourceOptions {
+    value: ANTD_MIN_JS,
+    name: "antd.min.js",
+    source_map: SourceMap::from_json(ANTD_MIN_JS_MAP).unwrap(),
+    original_source: None,
+    inner_source_map: None,
+    remove_original_source: false,
+  });
+
+  let concat = ConcatSource::new([antd_minify, sms_minify, sms_rollup]);
+
+  b.iter(|| {
+    concat
+      .map(&MapOptions::default())
+      .unwrap()
+      .to_json()
+      .unwrap();
+  })
+}
+
 fn bench_rspack_sources(criterion: &mut Criterion) {
   let mut group = criterion.benchmark_group("rspack_sources");
   group.bench_function(
@@ -213,6 +252,10 @@ fn bench_rspack_sources(criterion: &mut Criterion) {
     "replace_large_minified_source",
     benchmark_replace_large_minified_source,
   );
+  group.bench_function(
+    "concat_large_minified_source",
+    benchmark_concat_large_minified_source,
+  );
   group.finish();
 }
 

src/helpers.rs

@@ -996,10 +996,10 @@ pub fn stream_chunks_of_combined_source_map(
   let source_mapping: RefCell<HashMap<ArcStr, u32>> =
     RefCell::new(HashMap::default());
   let mut name_mapping: HashMap<ArcStr, u32> = HashMap::default();
-  let source_index_mapping: RefCell<HashMap<i64, i64>> =
-    RefCell::new(HashMap::default());
-  let name_index_mapping: RefCell<HashMap<i64, i64>> =
-    RefCell::new(HashMap::default());
+  let source_index_mapping: RefCell<Vec<i64>> =
+    RefCell::new(Vec::with_capacity(source_map.sources().len()));
+  let name_index_mapping: RefCell<Vec<i64>> =
+    RefCell::new(Vec::with_capacity(source_map.names().len()));
   let name_index_value_mapping: RefCell<HashMap<i64, ArcStr>> =
     RefCell::new(HashMap::default());
   let inner_source_index: RefCell<i64> = RefCell::new(-2);
@@ -1223,8 +1223,10 @@ pub fn stream_chunks_of_combined_source_map(
                   });
                 if name.as_ref() == original_name {
                   let mut name_index_mapping = name_index_mapping.borrow_mut();
-                  final_name_index =
-                    name_index_mapping.get(&name_index).copied().unwrap_or(-2);
+                  final_name_index = name_index_mapping
+                    .get(name_index as usize)
+                    .copied()
+                    .unwrap_or(-2);
                   if final_name_index == -2 {
                     if let Some(name) =
                       name_index_value_mapping.get(&name_index)
@@ -1240,7 +1242,8 @@ pub fn stream_chunks_of_combined_source_map(
                     } else {
                       final_name_index = -1;
                     }
-                    name_index_mapping.insert(name_index, final_name_index);
+                    name_index_mapping
+                      .insert(name_index as usize, final_name_index);
                   }
                 }
               }
@@ -1276,7 +1279,7 @@ pub fn stream_chunks_of_combined_source_map(
           return;
         } else {
           let mut source_index_mapping = source_index_mapping.borrow_mut();
-          if source_index_mapping.get(&source_index) == Some(&-2) {
+          if source_index_mapping.get(source_index as usize) == Some(&-2) {
             let mut source_mapping = source_mapping.borrow_mut();
             let mut global_index =
               source_mapping.get(inner_source_name).copied();
@@ -1291,14 +1294,14 @@ pub fn stream_chunks_of_combined_source_map(
               global_index = Some(len);
             }
             source_index_mapping
-              .insert(source_index, global_index.unwrap() as i64);
+              .insert(source_index as usize, global_index.unwrap() as i64);
           }
         }
       }
 
+      let source_index_mapping = source_index_mapping.borrow();
       let final_source_index = source_index_mapping
-        .borrow()
-        .get(&source_index)
+        .get(source_index as usize)
         .copied()
         .unwrap_or(-1);
       if final_source_index < 0 {
@@ -1314,8 +1317,10 @@ pub fn stream_chunks_of_combined_source_map(
       } else {
         // Pass through the chunk with mapping
         let mut name_index_mapping = name_index_mapping.borrow_mut();
-        let mut final_name_index =
-          name_index_mapping.get(&name_index).copied().unwrap_or(-1);
+        let mut final_name_index = name_index_mapping
+          .get(name_index as usize)
+          .copied()
+          .unwrap_or(-1);
         if final_name_index == -2 {
           let name_index_value_mapping = name_index_value_mapping.borrow();
           let name = name_index_value_mapping.get(&name_index).unwrap();
@@ -1327,7 +1332,7 @@ pub fn stream_chunks_of_combined_source_map(
             global_index = Some(len);
           }
           final_name_index = global_index.unwrap() as i64;
-          name_index_mapping.insert(name_index, final_name_index);
+          name_index_mapping.insert(name_index as usize, final_name_index);
         }
         on_chunk(
           chunk,
@@ -1356,7 +1361,7 @@ pub fn stream_chunks_of_combined_source_map(
         } else {
           *inner_source = source_content.clone();
         }
-        source_index_mapping.borrow_mut().insert(i, -2);
+        source_index_mapping.borrow_mut().insert(i as usize, -2);
         stream_chunks_of_source_map(
           &source_content.unwrap(),
           inner_source_map,
@@ -1446,12 +1451,12 @@ pub fn stream_chunks_of_combined_source_map(
         }
         source_index_mapping
           .borrow_mut()
-          .insert(i, global_index.unwrap() as i64);
+          .insert(i as usize, global_index.unwrap() as i64);
       }
     },
     &mut |i, name| {
       let i = i as i64;
-      name_index_mapping.borrow_mut().insert(i, -2);
+      name_index_mapping.borrow_mut().insert(i as usize, -2);
       name_index_value_mapping.borrow_mut().insert(i, name.into());
     },
     options,

src/replace_source.rs

@@ -1,6 +1,7 @@
 use std::{
   borrow::Cow,
   cell::RefCell,
+  collections::hash_map::Entry,
   hash::{Hash, Hasher},
   sync::{
     atomic::{AtomicBool, Ordering},
@@ -407,14 +408,16 @@ impl<T: Source> StreamChunks for ReplaceSource<T> {
             repl.name.as_ref().filter(|_| mapping.original.is_some())
           {
             let mut name_mapping = name_mapping.borrow_mut();
-            let mut global_index = name_mapping.get(name).copied();
-            if global_index.is_none() {
-              let len = name_mapping.len() as u32;
-              name_mapping.insert(name.to_owned(), len);
-              on_name.borrow_mut()(len, name);
-              global_index = Some(len);
-            }
-            replacement_name_index = global_index;
+            let len = name_mapping.len() as u32;
+            let global_index = match name_mapping.entry(name.to_string()) {
+              Entry::Occupied(entry) => *entry.get(),
+              Entry::Vacant(entry) => {
+                entry.insert(len);
+                on_name.borrow_mut()(len, name);
+                len
+              }
+            };
+            replacement_name_index = Some(global_index);
           }
           for (m, content_line) in lines.iter().enumerate() {
             on_chunk(
@@ -578,16 +581,18 @@ impl<T: Source> StreamChunks for ReplaceSource<T> {
       },
       &mut |name_index, name| {
         let mut name_mapping = name_mapping.borrow_mut();
-        let mut global_index = name_mapping.get(name).copied();
-        if global_index.is_none() {
-          let len = name_mapping.len() as u32;
-          name_mapping.insert(name.to_owned(), len);
-          on_name.borrow_mut()(len, name);
-          global_index = Some(len);
-        }
+        let len = name_mapping.len() as u32;
+        let global_index = match name_mapping.entry(name.to_string()) {
+          Entry::Occupied(entry) => *entry.get(),
+          Entry::Vacant(entry) => {
+            entry.insert(len);
+            on_name.borrow_mut()(len, name);
+            len
+          }
+        };
         name_index_mapping
           .borrow_mut()
-          .insert(name_index as usize, global_index.unwrap());
+          .insert(name_index as usize, global_index);
       },
     );