rebis-dev: Make AtomTable fully safe and prepare for garbage collection

benches/run_iai.rs

@@ -5,7 +5,7 @@ mod setup;
 mod iai {
     use iai_callgrind::{library_benchmark, library_benchmark_group, main};
 
-    use scryer_prolog::QueryResolution;
+    use scryer_prolog::machine::parsed_results::QueryResolution;
 
     use super::setup;
 

benches/setup.rs

@@ -1,7 +1,10 @@
 use std::{collections::BTreeMap, fs, path::Path};
 
 use maplit::btreemap;
-use scryer_prolog::{Machine, QueryResolution, Value};
+use scryer_prolog::machine::{
+    parsed_results::{QueryResolution, Value},
+    Machine,
+};
 
 pub fn prolog_benches() -> BTreeMap<&'static str, PrologBenchmark> {
     [
@@ -85,7 +88,7 @@ mod test {
     #[test]
     fn validate_benchmarks() {
         use super::prolog_benches;
-        use scryer_prolog::{QueryMatch, QueryResolution};
+        use scryer_prolog::machine::parsed_results::{QueryMatch, QueryResolution};
         use std::{fmt::Write, fs};
 
         struct BenchResult {

build/static_string_indexing.rs

@@ -84,6 +84,18 @@ impl<'ast> Visit<'ast> for StaticStrVisitor {
     }
 }
 
+const INLINED_ATOM_MAX_LEN: usize = 6;
+
+fn static_string_index(string: &str, index: usize) -> u64 {
+    if 0 < string.len() && string.len() <= INLINED_ATOM_MAX_LEN {
+        let mut string_buf: [u8; 8] = [0u8; 8];
+        string_buf[.. string.len()].copy_from_slice(string.as_bytes());
+        (u64::from_le_bytes(string_buf) << 1) | 1
+    } else {
+        (index << 1) as u64
+    }
+}
+
 pub fn index_static_strings(instruction_rs_path: &std::path::Path) -> TokenStream {
     use quote::*;
 
@@ -149,11 +161,26 @@ pub fn index_static_strings(instruction_rs_path: &std::path::Path) -> TokenStrea
         visitor.visit_file(&syntax)
     }
 
-    let indices = (0..visitor.static_strs.len()).map(|i| (i << 3) as u64);
-    let indices_iter = indices.clone();
+    let mut static_str_keys = vec![];
+    let mut static_strs = vec![];
+    let mut static_str_indices = vec![];
+
+    let indices: Vec<u64> = visitor.static_strs.iter().map(|string| {
+        let index = static_string_index(string, static_strs.len());
+
+        static_str_keys.push(string);
+
+        if index & 1 == 1 {
+            index
+        } else {
+            static_str_indices.push(index);
+            static_strs.push(string);
+            index
+        }
+    }).collect();
 
-    let static_strs_len = visitor.static_strs.len();
-    let static_strs: &Vec<_> = &visitor.static_strs.into_iter().collect();
+    let static_strs_len = static_strs.len(); // visitor.static_strs.len();
+    //let static_strs: &Vec<_> = &visitor.static_strs.into_iter().collect();
 
     quote! {
         static STRINGS: [&str; #static_strs_len] = [
@@ -163,11 +190,11 @@ pub fn index_static_strings(instruction_rs_path: &std::path::Path) -> TokenStrea
         ];
 
         macro_rules! atom {
-            #((#static_strs) => { Atom { index: #indices_iter } };)*
+            #((#static_str_keys) => { Atom { index: #indices } };)*
         }
 
         pub static STATIC_ATOMS_MAP: phf::Map<&'static str, Atom> = phf::phf_map! {
-            #(#static_strs => { Atom { index: #indices } },)*
+            #(#static_strs => { Atom { index: #static_str_indices } },)*
         };
     }
 }

src/allocator.rs

@@ -2,10 +2,9 @@ use crate::parser::ast::*;
 
 use crate::forms::*;
 use crate::instructions::*;
+use crate::machine::heap::Heap;
 use crate::targets::*;
 
-use std::cell::Cell;
-
 pub(crate) trait Allocator {
     fn new() -> Self;
 
@@ -14,42 +13,40 @@ pub(crate) trait Allocator {
         lvl: Level,
         context: GenContext,
         code: &mut CodeDeque,
-    );
+    ) -> RegType;
 
     fn mark_non_var<'a, Target: CompilationTarget<'a>>(
         &mut self,
         lvl: Level,
+        heap_loc: usize,
         context: GenContext,
-        cell: &'a Cell<RegType>,
         code: &mut CodeDeque,
-    );
+    ) -> RegType;
 
     #[allow(clippy::too_many_arguments)]
     fn mark_reserved_var<'a, Target: CompilationTarget<'a>>(
         &mut self,
         var_num: usize,
         lvl: Level,
-        cell: &Cell<VarReg>,
-        term_loc: GenContext,
+        context: GenContext,
         code: &mut CodeDeque,
         r: RegType,
         is_new_var: bool,
-    );
+    ) -> RegType;
 
     fn mark_cut_var(&mut self, var_num: usize, chunk_num: usize) -> RegType;
 
     fn mark_var<'a, Target: CompilationTarget<'a>>(
         &mut self,
         var_num: usize,
         lvl: Level,
-        cell: &Cell<VarReg>,
         context: GenContext,
         code: &mut CodeDeque,
-    );
+    ) -> RegType;
 
     fn reset(&mut self);
     fn reset_arg(&mut self, arg_num: usize);
-    fn reset_at_head(&mut self, args: &[Term]);
+    fn reset_at_head(&mut self, heap: &mut Heap, head_loc: usize);
     fn reset_contents(&mut self);
 
     fn advance_arg(&mut self);

src/arena.rs

@@ -74,10 +74,7 @@ impl RawBlockTraits for F64Table {
         F64_TABLE_INIT_SIZE
     }
 
-    #[inline]
-    fn align() -> usize {
-        F64_TABLE_ALIGN
-    }
+    const ALIGN: usize = F64_TABLE_ALIGN;
 }
 
 #[derive(Debug)]
@@ -98,8 +95,8 @@ pub fn lookup_float(
 
     RcuRef::try_map(f64table.block.read(), |raw_block| unsafe {
         raw_block
-            .base
-            .add(offset.0)
+            .get(offset.0)
+            .unwrap()
             .cast_mut()
             .cast::<UnsafeCell<OrderedFloat<f64>>>()
             .as_ref()
@@ -154,7 +151,7 @@ impl F64Table {
 
         ptr::write(ptr as *mut OrderedFloat<f64>, OrderedFloat(value));
 
-        let float = F64Offset(ptr as usize - block_epoch.base as usize);
+        let float = F64Offset(block_epoch.offset_of_unchecked(ptr));
 
         // atometable would have to update the index table at this point
 
@@ -496,7 +493,11 @@ impl F64Ptr {
 
     #[inline(always)]
     pub fn as_offset(&self) -> F64Offset {
-        F64Offset(self.0.get() as usize - RcuRef::get_root(&self.0).base as usize)
+        F64Offset(
+            RcuRef::get_root(&self.0)
+                .offset_of(self.0.get().cast_const().cast::<u8>())
+                .unwrap(),
+        )
     }
 }
 
@@ -897,7 +898,7 @@ mod tests {
     use crate::arena::*;
     use crate::atom_table::*;
     use crate::machine::mock_wam::*;
-    use crate::machine::partial_string::*;
+    use crate::types::*;
 
     use crate::parser::dashu::{Integer, Rational};
     use ordered_float::OrderedFloat;
@@ -980,7 +981,7 @@ mod tests {
 
         assert!(!big_int_ptr.as_ptr().is_null());
 
-        let cell = HeapCellValue::from(Literal::Integer(big_int_ptr));
+        let cell = HeapCellValue::from(big_int_ptr);
         assert_eq!(cell.get_tag(), HeapCellValueTag::Cons);
 
         let untyped_arena_ptr = match cell.to_untyped_arena_ptr() {
@@ -1086,31 +1087,6 @@ mod tests {
             _ => { unreachable!() }
         );
 
-        // complete string
-
-        let pstr_var_cell =
-            put_partial_string(&mut wam.machine_st.heap, "ronan", &wam.machine_st.atom_tbl);
-        let pstr_cell = wam.machine_st.heap[pstr_var_cell.get_value() as usize];
-
-        assert_eq!(pstr_cell.get_tag(), HeapCellValueTag::PStr);
-
-        match pstr_cell.to_pstr() {
-            Some(pstr) => {
-                assert_eq!(&*pstr.as_str_from(0), "ronan");
-            }
-            None => {
-                unreachable!();
-            }
-        }
-
-        read_heap_cell!(pstr_cell,
-            (HeapCellValueTag::PStr, pstr_atom) => {
-                let pstr = PartialString::from(pstr_atom);
-                assert_eq!(&*pstr.as_str_from(0), "ronan");
-            }
-            _ => { unreachable!() }
-        );
-
         // fixnum
 
         let fixnum_cell = fixnum_as_cell!(Fixnum::build_with(3));
@@ -1188,8 +1164,8 @@ mod tests {
         let char_cell = char_as_cell!(c);
 
         read_heap_cell!(char_cell,
-            (HeapCellValueTag::Char, c) => {
-                assert_eq!(c, 'c');
+            (HeapCellValueTag::Atom, (c, _arity)) => {
+                assert_eq!(&*c.as_str(), "c");
             }
             _ => { unreachable!() }
         );
@@ -1198,8 +1174,8 @@ mod tests {
         let cyrillic_char_cell = char_as_cell!(c);
 
         read_heap_cell!(cyrillic_char_cell,
-            (HeapCellValueTag::Char, c) => {
-                assert_eq!(c, 'Ћ');
+            (HeapCellValueTag::Atom, (c, _arity)) => {
+                assert_eq!(&*c.as_str(), "Ћ");
             }
             _ => { unreachable!() }
         );