schemurai 2.2.3 → 3.0.0

data/ext/schemurai_native/src/scope.rs

@@ -0,0 +1,420 @@
+//! Resource/anchor lookup is compiled once. Evaluation only follows native
+//! tables and stack frames, including when speculative branches collect annotations.
+use super::*;
+use tracking::JsonKey;
+#[derive(Clone, Copy, Default)]
+pub(super) struct Metadata {
+    pub resource: Value,
+    pub enters_scope: bool,
+    pub recursive_anchor: bool,
+    pub dynamic_anchor: Option<Value>,
+    pub primary_binding: Option<usize>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn requires_guard_histories_for_cycles_reached_through_dynamic_overrides() {
+        let reference = |target, kind| Op::Ref(Reference { target, kind });
+        let mut engine = Engine {
+            nodes: vec![
+                vec![Op::Boolean(true)],
+                vec![reference(0, ReferenceKind::Dynamic(0))],
+                vec![reference(1, ReferenceKind::Static)],
+                vec![reference(1, ReferenceKind::Static)],
+                vec![reference(1, ReferenceKind::Static)],
+            ],
+            anchor_tables: vec![vec![(100, 0), (101, 1)]],
+            ..Engine::default()
+        };
+        engine.compile_memoization();
+        assert!(engine.memoizable[1]);
+        assert!(engine.memo_guarded[1]);
+        engine.nodes.pop();
+        engine.compile_memoization();
+        assert!(!engine.memoizable[1]);
+        assert!(engine.memo_guard_sources[1]);
+        engine.nodes.push(vec![reference(1, ReferenceKind::Static)]);
+        engine.nodes[0] = vec![Op::Unsupported];
+        engine.compile_memoization();
+        assert!(!engine.memoizable[1]);
+    }
+
+    #[test]
+    fn removes_scope_keys_only_for_proven_invariant_dynamic_targets() {
+        let reference = |target, kind| Op::Ref(Reference { target, kind });
+        let mut engine = Engine {
+            nodes: vec![
+                vec![Op::Boolean(true)],
+                vec![reference(0, ReferenceKind::Dynamic(0))],
+                vec![reference(0, ReferenceKind::Dynamic(0))],
+                vec![Op::All(vec![1, 2])],
+                vec![reference(3, ReferenceKind::Static)],
+                vec![reference(3, ReferenceKind::Static)],
+                vec![reference(0, ReferenceKind::Dynamic(1))],
+                vec![reference(0, ReferenceKind::Dynamic(2))],
+                vec![reference(0, ReferenceKind::Dynamic(3))],
+                vec![reference(0, ReferenceKind::Recursive)],
+            ],
+            anchor_tables: vec![
+                vec![(100, 0), (101, 0)],
+                vec![(100, 0), (101, 3)],
+                vec![(100, 3)],
+                vec![],
+            ],
+            ..Engine::default()
+        };
+        engine.compile_memoization();
+        assert!(engine.memoizable[3]);
+        assert!(engine.memo_contextual[3]);
+        engine.simplify_dynamic_references();
+        engine.compile_memoization();
+        assert!(engine.memoizable[3]);
+        assert!(!engine.memo_contextual[3]);
+        for node in [1, 2] {
+            let Op::Ref(reference) = engine.nodes[node][0] else {
+                panic!()
+            };
+            assert_eq!(reference.static_target(), Some(0));
+        }
+        // Changing bindings, fallback mismatches, absent bindings and
+        // recursive references retain context-sensitive resolution.
+        for node in [6, 7, 8, 9] {
+            let Op::Ref(reference) = engine.nodes[node][0] else {
+                panic!()
+            };
+            assert_eq!(reference.static_target(), None);
+        }
+    }
+}
+#[derive(Clone, Copy, Debug)]
+enum ReferenceKind {
+    Static,
+    Recursive,
+    Dynamic(usize),
+}
+#[derive(Clone, Copy, Debug)]
+pub(super) struct Reference {
+    target: usize,
+    kind: ReferenceKind,
+}
+#[derive(Clone, Copy, Default)]
+pub(super) struct Context<'a> {
+    pub active: Option<&'a RefFrame<'a>>,
+    pub scope: Option<&'a ScopeFrame<'a>>,
+}
+pub(super) struct ScopeFrame<'a> {
+    pub resource: Value,
+    pub parent: Option<&'a ScopeFrame<'a>>,
+    pub primary_binding: Option<usize>,
+}
+impl Reference {
+    pub(super) fn dynamic_target(self) -> Option<(usize, usize)> {
+        match self.kind {
+            ReferenceKind::Dynamic(name) => Some((name, self.target)),
+            _ => None,
+        }
+    }
+    pub(super) fn recursive_target(self) -> Option<usize> {
+        matches!(self.kind, ReferenceKind::Recursive).then_some(self.target)
+    }
+    pub(super) fn static_target(self) -> Option<usize> {
+        matches!(self.kind, ReferenceKind::Static).then_some(self.target)
+    }
+}
+impl Engine {
+    pub(super) fn simplify_dynamic_references(&mut self) {
+        // Anchor binding has reached its fixed point, including resources
+        // compiled while discovering overrides. A name whose every binding
+        // equals the fallback target cannot change under any native scope.
+        // Preserve the source opcode for diagnostic paths, while allowing
+        // ordinary acyclic static-target memoization for the shared graph.
+        let invariant: Vec<_> = self
+            .anchor_tables
+            .iter()
+            .map(|bindings| {
+                let &(_, target) = bindings.first()?;
+                bindings
+                    .iter()
+                    .all(|&(_, candidate)| candidate == target)
+                    .then_some(target)
+            })
+            .collect();
+        for ops in &mut self.nodes {
+            for op in ops {
+                if let Op::Ref(reference) = op
+                    && let ReferenceKind::Dynamic(name) = reference.kind
+                    && invariant[name] == Some(reference.target)
+                {
+                    reference.kind = ReferenceKind::Static;
+                }
+            }
+        }
+    }
+
+    pub(super) fn compile_scope(
+        &mut self,
+        program: Value,
+        index: usize,
+        flags: i64,
+    ) -> Result<(), Value> {
+        let node = self.field(program, b"node\0")?;
+        let resource = self.field(node, b"resource\0")?;
+        let recursive = self.field(program, b"recursive_anchor?\0")?;
+        let dynamic = self.field(program, b"dynamic_anchor\0")?;
+        self.metadata[index] = Metadata {
+            resource,
+            enters_scope: flags & i64::from(TRACKS_DYNAMIC_SCOPE) != 0,
+            recursive_anchor: unsafe { sn_true(recursive) } != 0,
+            primary_binding: None,
+            dynamic_anchor: (unsafe { sn_same(dynamic, sn_nil()) } == 0).then_some(dynamic),
+        };
+        if !self.resources.contains_key(&resource) {
+            // Reserve the resource before compiling its root: roots can reach
+            // the current child through a recursive or dynamic reference.
+            self.resources.insert(resource, usize::MAX);
+            let mut root = 0;
+            if unsafe { sn_resource_program(self.compiler, resource, &mut root) } != 0 {
+                return Err(root);
+            }
+            self.retain(root);
+            let root = self.compile(root)?;
+            self.resources.insert(resource, root);
+        }
+        Ok(())
+    }
+    pub(super) fn compile_reference(
+        &mut self,
+        operand: Value,
+        opcode: i32,
+        target: usize,
+    ) -> Result<Op, Value> {
+        let fragment = self.field(operand, b"fragment\0")?;
+        let kind = if opcode == OP_RECURSIVE_REF
+            && unsafe { sn_same(fragment, sn_nil()) } == 0
+            && unsafe { sn_string_bytes(fragment) } == 0
+            && self.metadata[target].recursive_anchor
+        {
+            ReferenceKind::Recursive
+        } else if opcode == OP_DYNAMIC_REF {
+            let anchor = self.metadata[target].dynamic_anchor;
+            match anchor {
+                Some(anchor)
+                    if unsafe { sn_same(fragment, sn_nil()) } == 0
+                        && unsafe { sn_string_bytes(fragment) } != 0
+                        && unsafe { *sn_string_data(fragment) } != b'/'
+                        && unsafe { sn_string_equal(fragment, anchor) } != 0 =>
+                {
+                    let name = JsonKey::new(fragment);
+                    let index = if let Some(&index) = self.anchor_ids.get(&name) {
+                        index
+                    } else {
+                        let index = self.anchor_names.len();
+                        self.anchor_names.push(name);
+                        self.anchor_ids.insert(name, index);
+                        index
+                    };
+                    ReferenceKind::Dynamic(index)
+                }
+                _ => ReferenceKind::Static,
+            }
+        } else {
+            ReferenceKind::Static
+        };
+        Ok(Op::Ref(Reference { target, kind }))
+    }
+    pub(super) fn bind_dynamic_anchors(&mut self) -> Result<(), Value> {
+        // Names append during compilation. A resolved prefix per resource
+        // records negative lookups without retaining their Cartesian product.
+        // Snapshot only pending rows; compiling a binding can add resources
+        // and names, which the next pass must resolve too.
+        let mut resolved = HashMap::new();
+        loop {
+            let names = self.anchor_names.len();
+            if names > 1 {
+                return self.bind_indexed_dynamic_anchors();
+            }
+            let pending: Vec<_> = self
+                .resources
+                .keys()
+                .filter_map(|&resource| {
+                    let first = resolved.get(&resource).copied().unwrap_or(0);
+                    (first < names).then_some((resource, first..names))
+                })
+                .collect();
+            if pending.is_empty() {
+                self.finish_dynamic_bindings();
+                return Ok(());
+            }
+            for (resource, names) in pending {
+                let end = names.end;
+                for name in names {
+                    let mut target = 0;
+                    if unsafe {
+                        sn_anchor_program(
+                            self.compiler,
+                            resource,
+                            self.anchor_names[name].0,
+                            &mut target,
+                        )
+                    } != 0
+                    {
+                        return Err(target);
+                    }
+                    if unsafe { sn_same(target, sn_nil()) } == 0 {
+                        self.retain(target);
+                        let target = self.compile(target)?;
+                        self.dynamic_bindings.insert((resource, name), target);
+                    }
+                }
+                resolved.insert(resource, end);
+            }
+        }
+    }
+    fn finish_dynamic_bindings(&mut self) {
+        self.anchor_tables = vec![vec![]; self.anchor_names.len()];
+        for (&(resource, name), &target) in &self.dynamic_bindings {
+            self.anchor_tables[name].push((resource, target));
+        }
+        if self.anchor_names.len() == 1 {
+            for metadata in &mut self.metadata {
+                // Use the existing resource/name index instead of an
+                // O(binding count) scan for every compiled node.
+                metadata.primary_binding =
+                    self.dynamic_bindings.get(&(metadata.resource, 0)).copied();
+            }
+        }
+        // Compiler-only name indexes cannot be reused at runtime. Drop
+        // their allocations and temporary GC roots after the fixed point.
+        drop(std::mem::take(&mut self.anchor_ids));
+        drop(std::mem::take(
+            &mut unsafe { &mut *self.roots }.binding_names,
+        ));
+    }
+
+    fn bind_indexed_dynamic_anchors(&mut self) -> Result<(), Value> {
+        // Join registered names with resources that actually bind them. Resource
+        // tables append names, including when external indexing augments an
+        // existing resource. An indexed prefix admits only newly added names.
+        let mut available: HashMap<JsonKey, Vec<Value>, BuildHasherDefault<BucketHasher>> =
+            HashMap::default();
+        let mut resolved_names = 0;
+        let mut indexed = HashMap::new();
+        loop {
+            let mut pending = vec![];
+            for &resource in self.resources.keys() {
+                let first = indexed.get(&resource).copied().unwrap_or(0);
+                if unsafe { sn_anchor_count(resource) } == first {
+                    continue;
+                }
+                let mut names = 0;
+                if unsafe { sn_anchor_names(self.compiler, resource, &mut names) } != 0 {
+                    return Err(names);
+                }
+                // Copy handles before any Ruby callback. The snapshot Array
+                // is never borrowed across allocation, and temporary roots
+                // pin its names while the reverse index remains live.
+                let count = unsafe { sn_len(names) };
+                for i in first..count {
+                    let name = unsafe { sn_entry(names, i) };
+                    unsafe { &mut *self.roots }.binding_names.push(name);
+                    let name = JsonKey::new(name);
+                    available.entry(name).or_default().push(resource);
+                    if let Some(&id) = self.anchor_ids.get(&name)
+                        && id < resolved_names
+                    {
+                        pending.push((resource, id));
+                    }
+                }
+                indexed.insert(resource, count);
+            }
+            let names = self.anchor_names.len();
+            for id in resolved_names..names {
+                if let Some(resources) = available.get(&self.anchor_names[id]) {
+                    pending.extend(resources.iter().map(|&resource| (resource, id)));
+                }
+            }
+            resolved_names = names;
+            if pending.is_empty() {
+                self.finish_dynamic_bindings();
+                return Ok(());
+            }
+            for (resource, name) in pending {
+                // Switching from single-name discovery can revisit a positive
+                // pair already compiled. It must not invoke compilation twice.
+                if self.dynamic_bindings.contains_key(&(resource, name)) {
+                    continue;
+                }
+                let mut target = 0;
+                if unsafe {
+                    sn_anchor_program(
+                        self.compiler,
+                        resource,
+                        self.anchor_names[name].0,
+                        &mut target,
+                    )
+                } != 0
+                {
+                    return Err(target);
+                }
+                if unsafe { sn_same(target, sn_nil()) } == 0 {
+                    self.retain(target);
+                    let target = self.compile(target)?;
+                    self.dynamic_bindings.insert((resource, name), target);
+                }
+            }
+        }
+    }
+    pub(super) fn enter_scope<'a>(
+        &self,
+        node: usize,
+        active: Context<'a>,
+        frame: &'a ScopeFrame<'a>,
+    ) -> Context<'a> {
+        if self.metadata[node].enters_scope
+            && active
+                .scope
+                .is_none_or(|scope| scope.resource != frame.resource)
+        {
+            Context {
+                scope: Some(frame),
+                ..active
+            }
+        } else {
+            active
+        }
+    }
+    pub(super) fn reference_target(&self, reference: Reference, context: Context<'_>) -> usize {
+        if matches!(reference.kind, ReferenceKind::Dynamic(0)) && self.anchor_tables.len() == 1 {
+            return context
+                .scope
+                .and_then(|frame| frame.primary_binding)
+                .unwrap_or(reference.target);
+        }
+        let mut target = reference.target;
+        let mut current = context.scope;
+        // Linked frames walk inner to outer. Keep replacing a match so the
+        // outermost matching resource wins, just as the VM's scope.each does.
+        while let Some(frame) = current {
+            match reference.kind {
+                ReferenceKind::Static => break,
+                ReferenceKind::Recursive => {
+                    if let Some(&root) = self.resources.get(&frame.resource)
+                        && self.metadata[root].recursive_anchor
+                    {
+                        target = root;
+                    }
+                }
+                ReferenceKind::Dynamic(name) => {
+                    if let Some(binding) = self.dynamic_bindings.get(&(frame.resource, name)) {
+                        target = *binding;
+                    }
+                }
+            }
+            current = frame.parent;
+        }
+        target
+    }
+}

data/ext/schemurai_native/src/structural.rs

@@ -0,0 +1,86 @@
+//! One comparison/hash owns its cache. Ruby values cannot mutate or move
+//! during these GVL-held traversals, which never call back into Ruby.
+use std::collections::{HashMap, VecDeque};
+use std::hash::Hash;
+
+const MAX_ENTRIES: usize = 4096;
+
+pub(super) struct Cache<K, T> {
+    start_depth: usize,
+    shallow_width: usize,
+    results: HashMap<K, T>,
+    order: VecDeque<K>,
+}
+impl<K, T> Cache<K, T> {
+    // A batch can share wide containers below distinct element roots. Keep
+    // small shallow trees cheap; four expanded levels are still a constant
+    // bound before depth-based reuse handles thin shared graphs.
+    pub(super) fn batch(depth: usize) -> Self {
+        let mut cache = Self::new(depth);
+        cache.shallow_width = 16;
+        cache
+    }
+    pub(super) fn new(depth: usize) -> Self {
+        Self {
+            start_depth: depth.saturating_add(4),
+            shallow_width: usize::MAX,
+            results: HashMap::new(),
+            order: VecDeque::new(),
+        }
+    }
+    // Shallow ordinary records/trees avoid table bookkeeping. At most four
+    // levels are expanded before reuse begins, independently of graph depth.
+    pub(super) fn eligible(&self, depth: usize) -> bool {
+        depth >= self.start_depth
+    }
+    pub(super) fn eligible_container(&self, depth: usize, width: usize) -> bool {
+        self.eligible(depth) || width >= self.shallow_width
+    }
+}
+impl<K: Copy + Eq + Hash, T: Copy> Cache<K, T> {
+    pub(super) fn get(&self, key: K) -> Option<T> {
+        self.results.get(&key).copied()
+    }
+    pub(super) fn record(&mut self, key: K, result: T) {
+        if self.results.contains_key(&key) {
+            return;
+        }
+        if self.results.len() == MAX_ENTRIES {
+            self.results.remove(&self.order.pop_front().unwrap());
+        }
+        self.results.insert(key, result);
+        self.order.push_back(key);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn batches_admit_wide_containers_without_charging_small_shallow_trees() {
+        let cache = Cache::<usize, usize>::batch(7);
+        assert!(!cache.eligible_container(7, 2));
+        assert!(!cache.eligible_container(10, 15));
+        assert!(cache.eligible_container(8, 16));
+        assert!(cache.eligible_container(11, 0));
+        assert!(!Cache::<usize, usize>::new(7).eligible_container(8, 1024));
+    }
+
+    #[test]
+    fn separates_depth_and_admits_later_shared_values() {
+        let mut cache = Cache::new(0);
+        for value in 0..MAX_ENTRIES * 3 {
+            cache.record((value, 0), Some(value));
+            cache.record((value, 0), None);
+        }
+        assert_eq!(cache.results.len(), MAX_ENTRIES);
+        assert_eq!(cache.order.len(), MAX_ENTRIES);
+        assert_eq!(cache.get((0, 0)), None);
+        assert_eq!(
+            cache.get((MAX_ENTRIES * 3 - 1, 0)),
+            Some(Some(MAX_ENTRIES * 3 - 1))
+        );
+        assert_eq!(cache.get((MAX_ENTRIES * 3 - 1, 1)), None);
+    }
+}