chore: swap hash function for rustc hasher

halo2_proofs/Cargo.toml

@@ -61,6 +61,7 @@ rand_chacha = "0.3"
 maybe-rayon = { version = "0.1.1"}
 lazy_static = { version = "1", optional = true }
 env_logger = "0.10.0"
+rustc-hash = "2.0.0"
 
 # GPU Icicle integration
 icicle = { git = "https://github.com/ingonyama-zk/icicle.git", branch = "rust/large-bucket-factor-msm", optional = true }

halo2_proofs/benches/commit_zk.rs

@@ -8,7 +8,8 @@ use maybe_rayon::current_num_threads;
 use rand_chacha::rand_core::RngCore;
 use rand_chacha::ChaCha20Rng;
 use rand_core::SeedableRng;
-use std::{collections::HashMap, iter};
+use rustc_hash::FxHashMap as HashMap;
+use std::iter;
 
 fn rand_poly_serial(mut rng: ChaCha20Rng, domain: usize) -> Vec<Scalar> {
     // Sample a random polynomial of degree n - 1

halo2_proofs/src/circuit/floor_planner/single_pass.rs

@@ -1,5 +1,5 @@
+use rustc_hash::FxHashMap as HashMap;
 use std::cmp;
-use std::collections::HashMap;
 use std::fmt;
 use std::marker::PhantomData;
 

halo2_proofs/src/circuit/floor_planner/v1/strategy.rs

@@ -1,8 +1,6 @@
-use std::{
-    cmp,
-    collections::{BTreeSet, HashMap},
-    ops::Range,
-};
+use std::{cmp, collections::BTreeSet, ops::Range};
+
+use rustc_hash::FxHashMap as HashMap;
 
 use super::{RegionColumn, RegionShape};
 use crate::{circuit::RegionStart, plonk::Any};

halo2_proofs/src/circuit/layouter.rs

@@ -1,7 +1,7 @@
 //! Implementations of common circuit layouters.
 
+use rustc_hash::FxHashSet as HashSet;
 use std::cmp;
-use std::collections::HashSet;
 use std::fmt;
 
 use ff::Field;

halo2_proofs/src/circuit/table_layouter.rs

@@ -1,9 +1,8 @@
 //! Implementations of common table layouters.
 
-use std::{
-    collections::HashMap,
-    fmt::{self, Debug},
-};
+use std::fmt::{self, Debug};
+
+use rustc_hash::FxHashMap as HashMap;
 
 use ff::Field;
 

halo2_proofs/src/dev.rs

@@ -1,7 +1,7 @@
 //! Tools for developing circuits.
 
-use std::collections::HashMap;
-use std::collections::HashSet;
+use rustc_hash::FxHashMap as HashMap;
+use rustc_hash::FxHashSet as HashSet;
 use std::iter;
 use std::ops::{Add, Mul, Neg, Range};
 

halo2_proofs/src/dev/cost.rs

@@ -1,13 +1,14 @@
 //! Developer tools for investigating the cost of a circuit.
 
 use std::{
-    cmp,
-    collections::{HashMap, HashSet},
-    iter,
+    cmp, iter,
     marker::PhantomData,
     ops::{Add, Mul},
 };
 
+use rustc_hash::FxHashMap as HashMap;
+use rustc_hash::FxHashSet as HashSet;
+
 use ff::{Field, PrimeField};
 use group::prime::PrimeGroup;
 
@@ -288,7 +289,7 @@ impl<G: PrimeGroup, ConcreteCircuit: Circuit<G::Scalar>> CircuitCost<G, Concrete
         assert!((1 << k) >= cs.minimum_rows());
 
         // Figure out how many point sets we have due to queried cells.
-        let mut column_queries: HashMap<Column<Any>, HashSet<i32>> = HashMap::new();
+        let mut column_queries: HashMap<Column<Any>, HashSet<i32>> = HashMap::default();
         for (c, r) in iter::empty()
             .chain(
                 cs.advice_queries
@@ -306,7 +307,7 @@ impl<G: PrimeGroup, ConcreteCircuit: Circuit<G::Scalar>> CircuitCost<G, Concrete
         {
             column_queries.entry(c).or_default().insert(r.0);
         }
-        let mut point_sets: HashSet<Vec<i32>> = HashSet::new();
+        let mut point_sets: HashSet<Vec<i32>> = HashSet::default();
         for (_, r) in column_queries {
             // Sort the query sets so we merge duplicates.
             let mut query_set: Vec<_> = r.into_iter().collect();

halo2_proofs/src/dev/cost_model.rs

@@ -1,7 +1,7 @@
 //! The cost estimator takes high-level parameters for a circuit design, and estimates the
 //! verification cost, as well as resulting proof size.
 
-use std::collections::HashSet;
+use rustc_hash::FxHashSet as HashSet;
 use std::{iter, num::ParseIntError, str::FromStr};
 
 use crate::plonk::Circuit;

halo2_proofs/src/dev/failure.rs

@@ -1,8 +1,10 @@
-use std::collections::{BTreeMap, HashSet};
+use std::collections::BTreeMap;
 use std::fmt::{self, Debug};
 
 use group::ff::Field;
 
+use rustc_hash::FxHashSet as HashSet;
+
 use super::metadata::{DebugColumn, DebugVirtualCell};
 use super::MockProver;
 use super::{

halo2_proofs/src/dev/graph/layout.rs

@@ -3,7 +3,7 @@ use plotters::{
     coord::Shift,
     prelude::{DrawingArea, DrawingAreaErrorKind, DrawingBackend},
 };
-use std::collections::HashSet;
+use rustc_hash::FxHashSet as HashSet;
 use std::ops::Range;
 
 use crate::{

halo2_proofs/src/dev/metadata.rs

@@ -2,10 +2,9 @@
 
 use super::metadata::Column as ColumnMetadata;
 use crate::plonk::{self, Any};
-use std::{
-    collections::HashMap,
-    fmt::{self, Debug},
-};
+use std::fmt::{self, Debug};
+
+use rustc_hash::FxHashMap as HashMap;
 /// Metadata about a column within a circuit.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Column {

halo2_proofs/src/plonk/circuit.rs

@@ -9,14 +9,16 @@ use core::cmp::max;
 use core::ops::{Add, Mul};
 use ff::Field;
 use sealed::SealedPhase;
-use std::collections::{BTreeMap, HashMap};
+use std::collections::BTreeMap;
 use std::fmt::Debug;
 use std::iter::{Product, Sum};
 use std::{
     convert::TryFrom,
     ops::{Neg, Sub},
 };
 
+use rustc_hash::FxHashMap as HashMap;
+
 #[cfg(not(feature = "mv-lookup"))]
 use super::lookup;
 #[cfg(feature = "mv-lookup")]
@@ -1701,7 +1703,7 @@ impl<F: Field> Default for ConstraintSystem<F> {
             lookups_map: BTreeMap::default(),
             lookups: Vec::new(),
             shuffles: Vec::new(),
-            general_column_annotations: HashMap::new(),
+            general_column_annotations: HashMap::default(),
             constants: vec![],
             minimum_degree: None,
         }

halo2_proofs/src/plonk/permutation/keygen.rs

@@ -14,7 +14,10 @@ use crate::{
 use maybe_rayon::prelude::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator};
 
 #[cfg(feature = "thread-safe-region")]
-use std::collections::{BTreeSet, HashMap};
+use std::collections::BTreeSet;
+
+#[cfg(feature = "thread-safe-region")]
+use rustc_hash::FxHashMap as HashMap;
 
 #[cfg(not(feature = "thread-safe-region"))]
 /// Struct that accumulates all the necessary data in order to construct the permutation argument.

halo2_proofs/src/plonk/prover.rs

@@ -1,9 +1,12 @@
 use ff::{Field, FromUniformBytes, WithSmallOrderMulGroup};
 use group::Curve;
 use rand_core::RngCore;
-use std::collections::{BTreeSet, HashSet};
+use rustc_hash::FxBuildHasher;
+use rustc_hash::FxHashMap as HashMap;
+use rustc_hash::FxHashSet as HashSet;
+use std::collections::BTreeSet;
+use std::iter;
 use std::ops::RangeTo;
-use std::{collections::HashMap, iter};
 
 use super::{
     circuit::{
@@ -311,7 +314,9 @@ where
             };
             instances.len()
         ];
-        let mut challenges = HashMap::<usize, Scheme::Scalar>::with_capacity(meta.num_challenges);
+        let s = FxBuildHasher::default();
+        let mut challenges =
+            HashMap::<usize, Scheme::Scalar>::with_capacity_and_hasher(meta.num_challenges, s);
 
         let unusable_rows_start = params.n() as usize - (meta.blinding_factors() + 1);
         for current_phase in pk.vk.cs.phases() {

halo2_proofs/src/plonk/vanishing/prover.rs

@@ -1,9 +1,9 @@
-use std::{collections::HashMap, iter};
-
 use ff::Field;
 use group::Curve;
 use rand_chacha::ChaCha20Rng;
 use rand_core::{RngCore, SeedableRng};
+use rustc_hash::FxHashMap as HashMap;
+use std::iter;
 
 use super::Argument;
 use crate::{