perf: switch to ahash, indexmap-allocator-api

Author: Alonely0

Cargo.lock

@@ -30,9 +30,9 @@ smallvec = { version = "1.15.1", features = ["union", "const_generics", "const_n
 bumpalo = { version = "3.20.2", features = ["boxed", "collections", "std", "allocator-api2"] }
 hashbrown = "0.17.0"
 allocator-api2 = "0.4.0"
+ahash = "0.8.12"
 
 [dependencies]
-# lexer.workspace = true # FIXME(parser complete): bypass through parser
 interpreter.workspace = true
 parser.workspace = true
 color-eyre.workspace = true
@@ -49,6 +49,12 @@ clap = { version = "4.6.1", features = ["derive"] }
 ctor = "1.0"
 uutests = "0.8"
 
+[patch.crates-io]
+# I'm not particularly happy about this, but it's crucial for performance, and
+# I have audited the two commits. It's pinned to that hash to avoid possible
+# supply-chain attacks. Hopefully upstream maintainers will change their mind.
+indexmap-allocator-api = { git = 'https://github.com/Hans-Halverson/indexmap-allocator-api.git', rev = "36852f985c01fb9f58f2d9e510655ca1dbb1f4d0" }
+
 [profile.release]
 lto = true
 panic = "abort"

Cargo.toml

@@ -14,7 +14,8 @@ parser.workspace = true
 bumpalo.workspace = true
 allocator-api2.workspace = true
 hashbrown.workspace = true
-indexmap = "2.14.0"
+ahash.workspace = true
+indexmap-allocator-api = "2.7.1"
 
 [lints]
 workspace = true

interpreter/Cargo.toml

@@ -20,7 +20,7 @@ use crate::{
 pub struct Code<'arena> {
     pub arena: &'arena Bump,
     pub bc: Bytecode<'arena>,
-    pub consts: Consts,
+    pub consts: Consts<'arena>,
     pub symbols: SymbolTable<'arena>,
     free_regs: Vec<'arena, Reg>,
     pub reg_pointer: u16,
@@ -240,7 +240,7 @@ pub fn test_interpreter(stmnt: &Body<'_>) -> String {
     let mut c = Code {
         arena: &bump,
         bc: Bytecode::new_in(&bump),
-        consts: Consts::new(),
+        consts: Consts::new_in(&bump),
         symbols: SymbolTable::new_in(&bump),
         reg_pointer: 0,
         free_regs: Vec::new_in(&bump),

interpreter/src/ir/lower.rs

@@ -1,8 +1,9 @@
 use std::fmt::{self, Display};
 
+use ahash::RandomState;
 use bumpalo::{Bump, collections::Vec};
-use hashbrown::{DefaultHashBuilder, HashMap};
-use indexmap::{IndexMap, IndexSet};
+use hashbrown::HashMap;
+use indexmap_allocator_api::{IndexMap, IndexSet};
 use parser::Identifier;
 
 use crate::ir::{
@@ -28,7 +29,7 @@ pub struct Interpreter<'a> {
     program_counter: usize,
     registers: Registers<'a>,
     symbols: SymbolTable<'a>,
-    consts: Consts,
+    consts: Consts<'a>,
     compat: ExecMode,
 }
 
@@ -37,14 +38,14 @@ pub struct Registers<'a>(Vec<'a, Value>);
 
 #[derive(Debug)]
 pub struct SymbolTable<'a> {
-    user: IndexMap<Identifier<'a>, Value>,
+    user: IndexMap<Identifier<'a>, Value, RandomState, &'a Bump>,
     // separate table for cheap invalidation. It's an arena _visibly shrugs_.
-    records: HashMap<usize, Value, DefaultHashBuilder, &'a Bump>,
+    records: HashMap<usize, Value, RandomState, &'a Bump>,
     // etc
 }
 
 #[derive(Debug)]
-pub struct Consts(pub IndexSet<Value>);
+pub struct Consts<'a>(pub IndexSet<Value, RandomState, &'a Bump>);
 
 impl<'a> Interpreter<'a> {
     pub fn new(compat: ExecMode, code: Code<'a>) -> Self {
@@ -63,8 +64,8 @@ impl<'a> Interpreter<'a> {
 impl<'a> SymbolTable<'a> {
     pub fn new_in(arena: &'a Bump) -> Self {
         Self {
-            user: IndexMap::new(),
-            records: HashMap::new_in(arena),
+            user: IndexMap::new_in(arena),
+            records: HashMap::with_hasher_in(RandomState::new(), arena),
         }
     }
     fn lookup_user_var(&self, var: NonLocal) -> &Value {
@@ -88,9 +89,9 @@ impl<'a> SymbolTable<'a> {
     }
 }
 
-impl Consts {
-    pub fn new() -> Self {
-        Self(IndexSet::with_capacity(4))
+impl<'a> Consts<'a> {
+    pub fn new_in(arena: &'a Bump) -> Self {
+        Self(IndexSet::with_capacity_in(4, arena))
     }
 }
 
@@ -195,7 +196,7 @@ impl Display for SymbolTable<'_> {
     }
 }
 
-impl Display for Consts {
+impl Display for Consts<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Consts:")?;
         fmt_list(f, self.0.iter(), |f, i, e| write!(f, "mem[{i}] = {e:?}"))

interpreter/src/vm.rs

@@ -14,6 +14,7 @@ smallvec.workspace = true
 bumpalo.workspace = true
 hashbrown.workspace = true
 allocator-api2.workspace = true
+ahash.workspace = true
 ariadne = "0.6.0"
 
 [lints]

parser/Cargo.toml

@@ -5,9 +5,10 @@
 
 use std::fmt::Debug;
 
+use ahash::RandomState;
 use bumpalo::{Bump, boxed::Box, collections::Vec};
 use either::Either;
-use hashbrown::{DefaultHashBuilder, HashMap};
+use hashbrown::HashMap;
 use lexer::{Slice, Span, Token};
 
 use crate::{ParsingError, Result, lex::TokenExt};
@@ -21,7 +22,7 @@ pub struct Ast<'a> {
     pub end_file: Vec<'a, Body<'a>>,
     pub rules: Vec<'a, Rule<'a>>,
     pub concurrent: Vec<'a, Rule<'a>>,
-    pub functions: HashMap<Identifier<'a>, Function<'a>, DefaultHashBuilder, &'a Bump>,
+    pub functions: HashMap<Identifier<'a>, Function<'a>, RandomState, &'a Bump>,
 }
 
 #[derive(Debug)]

parser/src/ast.rs

@@ -16,6 +16,7 @@ mod tests;
 
 use std::{fmt::Debug, mem::replace};
 
+use ahash::RandomState;
 use bumpalo::{Bump, boxed::Box, collections::Vec, vec};
 use either::Either::{Left, Right};
 use hashbrown::HashMap;
@@ -685,7 +686,7 @@ impl<'a> Ast<'a> {
             end_file: Vec::new_in(arena),
             rules: Vec::new_in(arena),
             concurrent: Vec::new_in(arena),
-            functions: HashMap::new_in(arena),
+            functions: HashMap::with_hasher_in(RandomState::new(), arena),
         }
     }
 }