Use typed-arena

Author: t4ccer

Cargo.lock

@@ -16,13 +16,13 @@ categories = ["mathematics", "science"]
 [dependencies]
 ahash = "0.8.3"
 auto_ops = "0.3.0"
-elsa = { version = "1.9.0", features = ["indexmap"] }
 itertools = "0.10.5"
 nom = "7.1.3"
 num-rational = { version = "0.4.1", default-features = false, features = ["std"]}
 # Later versions introduce binary blob: https://github.com/serde-rs/serde/issues/2538
 serde = { version = "<=1.0.171", optional = true}
 serde_repr = { version = "0.1.12", optional = true}
+typed-arena = "2.0.2"
 
 [dev-dependencies]
 quickcheck = { version = "1.0", default-features = false }

Cargo.toml

@@ -1378,7 +1378,7 @@ fn parse_games() {
     test_game_parse!("{1/2|2}", "1");
 }
 
-#[cfg(test)]
+#[cfg(all(test, not(miri)))]
 mod tests {
     use super::*;
     use quickcheck::{Arbitrary, Gen, QuickCheck};

src/short/partizan/canonical_form.rs

@@ -719,6 +719,7 @@ fn finds_canonical_form_of_num_nim_sum() {
 }
 
 #[test]
+#[cfg(not(miri))]
 fn finds_temperature_of_four_by_four_grid() {
     use crate::numeric::rational::Rational;
 

src/short/partizan/games/domineering.rs

@@ -70,7 +70,7 @@ pub trait PartizanGame: Sized + Clone + Hash + Send + Sync + Eq {
         transposition_table: &'a TranspositionTable<'a, Self>,
     ) -> CanonicalForm {
         if let Some(id) = transposition_table.grids_get(self) {
-            return id;
+            return id.clone();
         }
 
         if let Some(cf) = self.canonical_form_special_cases() {
@@ -79,26 +79,25 @@ pub trait PartizanGame: Sized + Clone + Hash + Send + Sync + Eq {
 
         let mut result = CanonicalForm::new_integer(0);
         for position in self.decompositions() {
-            let sub_result = transposition_table.grids_get(&position).unwrap_or_else(|| {
-                let moves = Moves {
-                    left: position
-                        .left_moves()
-                        .iter()
-                        .map(|o| o.canonical_form(transposition_table))
-                        .collect(),
-                    right: position
-                        .right_moves()
-                        .iter()
-                        .map(|o| o.canonical_form(transposition_table))
-                        .collect(),
-                };
-
-                let canonical_form = CanonicalForm::new_from_moves(moves);
-                transposition_table.grids_insert(position, canonical_form.clone());
-                canonical_form
-            });
-
-            result = sub_result + result;
+            match transposition_table.grids_get(&position) {
+                Some(cached_sub_result) => result += cached_sub_result,
+                None => {
+                    let moves = Moves {
+                        left: position
+                            .left_moves()
+                            .iter()
+                            .map(|o| o.canonical_form(transposition_table))
+                            .collect(),
+                        right: position
+                            .right_moves()
+                            .iter()
+                            .map(|o| o.canonical_form(transposition_table))
+                            .collect(),
+                    };
+                    let sub_result = CanonicalForm::new_from_moves(moves);
+                    result += sub_result;
+                }
+            }
         }
 
         transposition_table.grids_insert(self.clone(), result.clone());

src/short/partizan/partizan_game.rs

@@ -1,27 +1,25 @@
 //! Thread safe transposition table for game values
 
-use elsa::FrozenIndexSet;
-
-// TODO: Move to short positional game module
 use crate::{rw_hash_map::RwHashMap, short::partizan::canonical_form::CanonicalForm};
 use std::{hash::Hash, sync::Mutex};
+use typed_arena::Arena;
 
 /// Transaction table (cache) of game positions and canonical forms.
 pub struct TranspositionTable<'a, G> {
-    known_games: Mutex<FrozenIndexSet<Box<CanonicalForm>>>,
+    known_games: Mutex<Arena<CanonicalForm>>,
     grids: RwHashMap<G, &'a CanonicalForm, ahash::RandomState>,
 }
 
 #[cfg_attr(feature = "cargo-clippy", allow(clippy::new_without_default))]
 impl<'a, G> TranspositionTable<'a, G>
 where
-    G: Eq + Hash + Clone + Sync + Send,
+    G: Eq + Hash + Sync + Send,
 {
     /// Create new empty transposition table.
     #[inline]
     pub fn new() -> Self {
         Self {
-            known_games: Mutex::new(FrozenIndexSet::new()),
+            known_games: Mutex::new(Arena::new()),
             grids: RwHashMap::with_hasher(ahash::RandomState::new()),
         }
     }
@@ -30,16 +28,17 @@ where
 
     /// Lookup a position
     #[inline]
-    pub fn grids_get(&self, grid: &G) -> Option<CanonicalForm> {
-        self.grids.get(grid).cloned()
+    pub fn grids_get(&'a self, grid: &G) -> Option<&'a CanonicalForm> {
+        self.grids.get(grid)
     }
 
     /// Save position and its game value
     #[cfg_attr(feature = "cargo-clippy", allow(clippy::missing_panics_doc))]
     #[inline]
     pub fn grids_insert(&'a self, grid: G, game: CanonicalForm) {
-        let inserted: *const CanonicalForm =
-            self.known_games.lock().unwrap().insert(Box::new(game));
+        let arena = self.known_games.lock().unwrap();
+        let inserted = arena.alloc(game) as *const CanonicalForm;
+        drop(arena);
         self.grids.insert(grid, unsafe { &*inserted });
     }
 

src/short/partizan/transposition_table.rs

@@ -8,6 +8,7 @@ use std::hint::black_box;
 static ALLOC: dhat::Alloc = dhat::Alloc;
 
 #[test]
+#[cfg(not(miri))]
 fn bench_domineering() {
     let profiler = dhat::Profiler::builder().build();