FxHasher in compute_chunk_group_info

Author: mischnic

turbopack/crates/turbopack-core/src/module_graph/chunk_group_info.rs

@@ -1,13 +1,14 @@
 use std::{
     collections::{hash_map::Entry, BinaryHeap, HashMap, HashSet},
-    hash::Hash,
+    hash::{BuildHasherDefault, Hash},
     ops::{Deref, DerefMut},
 };
 
 use anyhow::Result;
 use either::Either;
 use petgraph::graph::{DiGraph, EdgeIndex, NodeIndex};
 use roaring::RoaringBitmap;
+use rustc_hash::FxHasher;
 use serde::{Deserialize, Serialize};
 use tracing::Instrument;
 use turbo_rcstr::RcStr;
@@ -75,8 +76,10 @@ impl Hash for RoaringBitmapWrapper {
     }
 }
 
+type FxHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;
+
 #[turbo_tasks::value(transparent)]
-pub struct ChunkGroupInfo(HashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper>);
+pub struct ChunkGroupInfo(FxHashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper>);
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 enum ChunkGroup {
@@ -164,18 +167,21 @@ pub async fn compute_chunk_group_info(graph: &ModuleGraph) -> Result<Vc<ChunkGro
     let span = span_outer.clone();
     async move {
         let mut next_chunk_group_id = 0u32;
-        let mut chunk_groups_to_id: HashMap<ChunkGroup, ChunkGroupId> = HashMap::new();
-        let mut chunk_groups_from_id: HashMap<ChunkGroupId, ChunkGroup> = HashMap::new();
+        let mut chunk_groups_to_id: FxHashMap<ChunkGroup, ChunkGroupId> =
+            HashMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        let mut chunk_groups_from_id: FxHashMap<ChunkGroupId, ChunkGroup> =
+            HashMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
 
-        let mut module_chunk_groups: HashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper> =
-            HashMap::new();
+        let mut module_chunk_groups: FxHashMap<ResolvedVc<Box<dyn Module>>, RoaringBitmapWrapper> =
+            HashMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
 
         let graphs = graph.graphs.iter().try_join().await?;
         let module_count = graphs.iter().map(|g| g.graph.node_count()).sum::<usize>();
         span.record("module_count", module_count);
 
         // First, compute the depth for each module in the graph
-        let mut module_depth: HashMap<ResolvedVc<Box<dyn Module>>, usize> = HashMap::new();
+        let mut module_depth: FxHashMap<ResolvedVc<Box<dyn Module>>, usize> =
+            HashMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
         // use all entries from all graphs
         let entries = graphs
             .iter()
@@ -202,7 +208,7 @@ pub async fn compute_chunk_group_info(graph: &ModuleGraph) -> Result<Vc<ChunkGro
         let mut visitor =
             |parent_info: Option<(&'_ SingleModuleGraphModuleNode, &'_ ChunkingType)>,
              node: &'_ SingleModuleGraphModuleNode,
-             module_chunk_groups: &mut HashMap<
+             module_chunk_groups: &mut FxHashMap<
                 ResolvedVc<Box<dyn Module>>,
                 RoaringBitmapWrapper,
             >|
@@ -316,7 +322,7 @@ pub async fn compute_chunk_group_info(graph: &ModuleGraph) -> Result<Vc<ChunkGro
         let mut visit_count = 0usize;
 
         {
-            let mut queue_set = HashSet::new();
+            let mut queue_set = HashSet::with_hasher(BuildHasherDefault::<FxHasher>::default());
             let mut queue = BinaryHeap::with_capacity(entries.len());
             for e in entries {
                 queue.push(NodeWithPriority {