schemurai 3.0.0 → 3.0.2

data/ext/schemurai_native/src/tracking.rs

@@ -1,5 +1,6 @@
-//! Evaluated locations stay in native buffers, scoped to one instance location.
-//! Keys remain borrowed VALUEs; no Ruby objects or instance trees are allocated.
+//! Ordinary locations use native buffers; runtime locations retain opaque Ruby
+//! buffers without borrowing their sets. This module never allocates Ruby objects
+//! or decodes instance trees.
 use super::*;
 use std::collections::HashSet;
 use std::hash::Hash;
@@ -24,6 +25,47 @@ impl Hash for JsonKey {
 }
 pub(super) type KeySet = HashSet<JsonKey, BuildHasherDefault<BucketHasher>>;
 
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct RuntimeLocations {
+    pub(crate) buffer: Value,
+    pub(crate) properties: Value,
+    pub(crate) items: Value,
+}
+impl RuntimeLocations {
+    pub(crate) fn mark(&self) {
+        for value in [self.buffer, self.properties, self.items] {
+            unsafe {
+                sn_pin(value);
+            }
+        }
+    }
+}
+
+// An owned export snapshot can be traversed by C across Ruby allocations.
+pub struct PropertyLocations {
+    pub(crate) set: Option<Value>,
+    pub(crate) keys: Vec<Value>,
+}
+impl PropertyLocations {
+    pub(crate) fn new(engine: &Engine, tracked: &Tracked) -> Self {
+        Self {
+            set: tracked.properties_set(),
+            keys: tracked.native_properties(engine),
+        }
+    }
+    pub(crate) fn mark(&self) {
+        for &value in self.set.iter().chain(&self.keys) {
+            unsafe {
+                sn_pin(value);
+            }
+        }
+    }
+    pub(crate) fn memory_usage(&self) -> usize {
+        self.keys.capacity() * std::mem::size_of::<Value>()
+    }
+}
+
 // Store only nonempty words. The common single-word case needs no allocation,
 // even when its property IDs are near the end of a large compiled engine.
 #[derive(Clone, Default)]
@@ -138,13 +180,36 @@ impl PropertyBits {
 pub(super) struct Tracked {
     pub status: Verdict,
     properties: KeySet,
+    runtime: Option<RuntimeLocations>,
     known_properties: PropertyBits,
     items: Vec<u64>,
 }
 impl Tracked {
+    pub(super) fn memory_usage(&self) -> usize {
+        self.properties.capacity() * std::mem::size_of::<JsonKey>()
+            + self.items.capacity() * std::mem::size_of::<u64>()
+            + match &self.known_properties.words {
+                PropertyWords::Empty | PropertyWords::Single(..) => 0,
+                PropertyWords::Dense(_, words) => words.capacity() * std::mem::size_of::<u64>(),
+                PropertyWords::Many(words) => {
+                    words.capacity() * std::mem::size_of::<(usize, u64)>()
+                }
+            }
+    }
+    pub(super) fn mark(&self) {
+        if let Some(runtime) = self.runtime {
+            runtime.mark();
+        }
+        for key in &self.properties {
+            unsafe {
+                sn_pin(key.0);
+            }
+        }
+    }
     // Bound retained annotation slots independently of the number of results.
     pub(super) fn memo_slots(&self) -> usize {
-        self.properties.capacity()
+        self.runtime.map_or(0, |_| 3)
+            + self.properties.capacity()
             + self.items.capacity()
             + match &self.known_properties.words {
                 PropertyWords::Empty | PropertyWords::Single(..) => 0,
@@ -156,6 +221,7 @@ impl Tracked {
         Self {
             status,
             properties: KeySet::default(),
+            runtime: None,
             known_properties: PropertyBits::default(),
             items: vec![],
         }
@@ -179,7 +245,13 @@ impl Tracked {
         self.known_properties.contains(index)
     }
     pub(super) fn property_count(&self) -> usize {
-        self.properties.len() + self.known_properties.count
+        // Runtime sets can be reset or changed by retained blocks. Returning
+        // zero disables native count-based scan elision; Ruby reads live sets.
+        if self.runtime.is_some() {
+            0
+        } else {
+            self.properties.len() + self.known_properties.count
+        }
     }
     pub(super) fn item_count(&self) -> usize {
         self.items
@@ -188,6 +260,7 @@ impl Tracked {
             .sum()
     }
     pub(super) fn merge(&mut self, other: Self) -> Verdict {
+        debug_assert!(self.runtime.is_none() && other.runtime.is_none());
         if other.status != Valid {
             return other.status;
         }
@@ -200,17 +273,86 @@ impl Tracked {
         merge_bits(&mut self.items, other.items);
         Valid
     }
-    pub(super) fn merge_diagnostics(&mut self, other: Self) -> Result<(), Verdict> {
+    pub(super) fn merge_diagnostics(
+        &mut self,
+        execution: &Execution<'_>,
+        other: Self,
+    ) -> Result<(), Verdict> {
         if other.status == Unsupported {
             return Err(Unsupported);
         }
         if self.status != Valid || other.status != Valid {
             *self = Self::new(Invalid);
         } else {
-            self.merge(other);
+            if self.merge_runtime(execution, other) == Unsupported {
+                return Err(Unsupported);
+            }
         }
         Ok(())
     }
+    pub(super) fn has_runtime_properties(&self) -> bool {
+        self.runtime.is_some()
+    }
+    pub(super) fn runtime_locations(&self) -> Option<RuntimeLocations> {
+        self.runtime
+    }
+    pub(super) fn properties_set(&self) -> Option<Value> {
+        self.runtime.map(|runtime| runtime.properties)
+    }
+    pub(super) fn items_set(&self) -> Option<Value> {
+        self.runtime.map(|runtime| runtime.items)
+    }
+    pub(super) fn set_runtime(&mut self, runtime: RuntimeLocations) {
+        debug_assert!(
+            self.properties.is_empty() && self.known_properties.count == 0 && self.items.is_empty()
+        );
+        self.runtime = Some(runtime);
+    }
+    pub(super) fn native_items(&self) -> Vec<usize> {
+        let mut result = vec![];
+        for (word, &bits) in self.items.iter().enumerate() {
+            let mut bits = bits;
+            while bits != 0 {
+                let bit = bits.trailing_zeros() as usize;
+                result.push(word * 64 + bit);
+                bits &= bits - 1;
+            }
+        }
+        result
+    }
+    pub(super) fn native_properties(&self, engine: &Engine) -> Vec<Value> {
+        let mut known: Vec<_> = engine
+            .property_ids
+            .iter()
+            .filter(|(_, index)| self.contains_known_property(**index))
+            .map(|(key, &index)| (index, key.0))
+            .collect();
+        known.sort_unstable_by_key(|&(index, _)| index);
+        known
+            .into_iter()
+            .map(|(_, key)| key)
+            .chain(self.properties.iter().map(|key| key.0))
+            .collect()
+    }
+    pub(super) fn merge_runtime(&mut self, execution: &Execution<'_>, other: Self) -> Verdict {
+        if other.status != Valid {
+            return other.status;
+        }
+        if !self.has_runtime_properties() && !other.has_runtime_properties() {
+            return self.merge(other);
+        }
+        let Ok(runtime) = execution
+            .caches
+            .merge_properties(execution.engine, self, &other)
+        else {
+            return Unsupported;
+        };
+        self.properties.clear();
+        self.known_properties = PropertyBits::default();
+        self.items.clear();
+        self.runtime = Some(runtime);
+        Valid
+    }
     pub(super) fn property(&mut self, engine: &Engine, value: Value) {
         let key = JsonKey::new(value);
         if let Some(&index) = engine.property_ids.get(&key) {
@@ -243,6 +385,31 @@ fn merge_bits(target: &mut Vec<u64>, source: Vec<u64>) {
     }
 }
 impl Execution<'_> {
+    // contains needs the trial outcome, not the child's exported annotations.
+    pub(super) fn trial_status(
+        &self,
+        node: usize,
+        value: Value,
+        depth: usize,
+        active: scope::Context<'_>,
+    ) -> Verdict {
+        if self.should_continue_report(depth) {
+            return self.eval_tracked(node, value, depth, active).status;
+        }
+        if depth > MAX_EVALUATION_DEPTH || !self.budget.checkpoint() {
+            return Unsupported;
+        }
+        let kind_state = InstanceKind::new(TYPE_UNCHECKED);
+        let kind = self.diagnostic_kind(node, value, &kind_state);
+        if self.unsupported_kind(node, kind) {
+            return Unsupported;
+        }
+        self.trial_scalar(node, value, depth, kind)
+            .unwrap_or_else(|| {
+                self.eval_tracked_kind(node, value, depth, active, &kind_state)
+                    .status
+            })
+    }
     pub(super) fn eval_tracked(
         &self,
         node: usize,
@@ -250,18 +417,23 @@ impl Execution<'_> {
         depth: usize,
         active: scope::Context<'_>,
     ) -> Tracked {
+        if self.should_continue_report(depth) {
+            return self.collect_trial(
+                node,
+                value,
+                depth,
+                active,
+                &InstanceKind::new(TYPE_UNCHECKED),
+            );
+        }
         if depth > MAX_EVALUATION_DEPTH {
             return Tracked::new(Unsupported);
         }
         if !self.budget.checkpoint() {
             return Tracked::new(Unsupported);
         }
-        let kind = if value & self.fixnum_flag != 0 {
-            TYPE_INTEGRAL_NUMBER
-        } else {
-            unsafe { sn_kind(value) }
-        };
-        self.eval_tracked_kind(node, value, depth, active, kind)
+        let kind = InstanceKind::new(TYPE_UNCHECKED);
+        self.eval_tracked_kind(node, value, depth, active, &kind)
     }
     // Applicator branches evaluate the same borrowed instance under the GVL.
     // No Ruby callback can mutate it, so its guarded kind can be reused while
@@ -272,11 +444,21 @@ impl Execution<'_> {
         value: Value,
         depth: usize,
         active: scope::Context<'_>,
-        kind: i32,
+        kind_state: &InstanceKind,
     ) -> Tracked {
+        if self.should_continue_report(depth) {
+            return self.collect_trial(node, value, depth, active, kind_state);
+        }
+        let kind = self.diagnostic_kind(node, value, kind_state);
         if !self.budget.checkpoint() {
             return Tracked::new(Unsupported);
         }
+        if depth <= MAX_EVALUATION_DEPTH
+            && !self.unsupported_kind(node, kind)
+            && let Some(status) = self.trial_scalar(node, value, depth, kind)
+        {
+            return Tracked::new(status);
+        }
         let Some(key) = self
             .memo
             .key(self, node, value, depth, active, &self.budget)
@@ -284,7 +466,7 @@ impl Execution<'_> {
             if self.budget.hit.get().0 != 0 {
                 return Tracked::new(Unsupported);
             }
-            return self.eval_tracked_uncached(node, value, depth, active, kind);
+            return self.eval_tracked_uncached(node, value, depth, active, kind_state);
         };
         if self.budget.hit.get().0 != 0 || !self.budget.checkpoint() {
             return Tracked::new(Unsupported);
@@ -292,7 +474,7 @@ impl Execution<'_> {
         if let Some(result) = self.memo.tracked(key) {
             return result;
         }
-        let result = self.eval_tracked_uncached(node, value, depth, active, kind);
+        let result = self.eval_tracked_uncached(node, value, depth, active, kind_state);
         self.memo.record_tracked(key, &result);
         result
     }
@@ -302,143 +484,11 @@ impl Execution<'_> {
         value: Value,
         depth: usize,
         active: scope::Context<'_>,
-        kind: i32,
+        kind_state: &InstanceKind,
     ) -> Tracked {
-        let frame = scope::ScopeFrame {
-            resource: self.metadata[node].resource,
-            parent: active.scope,
-            primary_binding: active
-                .scope
-                .and_then(|frame| frame.primary_binding)
-                .or(self.metadata[node].primary_binding),
-        };
-        let active = self.enter_scope(node, active, &frame);
-        if depth > MAX_EVALUATION_DEPTH {
-            return Tracked::new(Unsupported);
-        }
-        if kind == TYPE_UNSUPPORTED {
-            return Tracked::new(Unsupported);
-        }
-        let mut evaluation = Tracked::new(Valid);
-        for op in &self.nodes[node] {
-            if !self.budget.checkpoint() {
-                return Tracked::new(Unsupported);
-            }
-            let result = match op {
-                Op::Ref(target) => {
-                    if RefFrame::contains(active.active, node, value) {
-                        Valid
-                    } else {
-                        let frame = RefFrame {
-                            source: node,
-                            value,
-                            parent: active.active,
-                        };
-                        evaluation.merge(self.eval_tracked_kind(
-                            self.reference_target(*target, active),
-                            value,
-                            depth + 1,
-                            scope::Context {
-                                active: Some(&frame),
-                                ..active
-                            },
-                            kind,
-                        ))
-                    }
-                }
-                Op::All(nodes) => {
-                    let mut result = Valid;
-                    for &child in nodes {
-                        if !self.budget.checkpoint() {
-                            return Tracked::new(Unsupported);
-                        }
-                        result = evaluation.merge(self.eval_tracked_kind(
-                            child,
-                            value,
-                            depth + 1,
-                            active,
-                            kind,
-                        ));
-                        if result != Valid {
-                            break;
-                        }
-                    }
-                    result
-                }
-                Op::Any(nodes) | Op::One(nodes) => {
-                    let branch_kind = if matches!(op, Op::Any(_)) {
-                        evaluation::BranchKind::Any
-                    } else {
-                        evaluation::BranchKind::One
-                    };
-                    match evaluation::scan_branches(
-                        nodes,
-                        evaluation::BranchPolicy::Complete,
-                        |child| self.eval_tracked_kind(child, value, depth + 1, active, kind),
-                    ) {
-                        Err(status) => status,
-                        Ok(result) if !branch_kind.accepts(result.matches) => Invalid,
-                        Ok(result) => evaluation.merge(result.coverage),
-                    }
-                }
-                Op::Not(child) => match self.eval(*child, value, depth + 1, active) {
-                    Valid => Invalid,
-                    Invalid => Valid,
-                    Unsupported => Unsupported,
-                },
-                Op::Conditional(condition, yes, no) => {
-                    let condition =
-                        self.eval_tracked_kind(*condition, value, depth + 1, active, kind);
-                    let status = condition.status;
-                    if status == Unsupported {
-                        Unsupported
-                    } else {
-                        let branch = if status == Valid {
-                            evaluation.merge(condition);
-                            yes
-                        } else {
-                            no
-                        };
-                        if let Some(child) = branch {
-                            evaluation.merge(self.eval_tracked_kind(
-                                *child,
-                                value,
-                                depth + 1,
-                                active,
-                                kind,
-                            ))
-                        } else {
-                            Valid
-                        }
-                    }
-                }
-                Op::Array(required, rules) => {
-                    if *required != 0 && kind != TYPE_ARRAY {
-                        Invalid
-                    } else if kind != TYPE_ARRAY {
-                        Valid
-                    } else {
-                        self.array_tracked(rules, value, depth + 1, active, &mut evaluation)
-                    }
-                }
-                Op::Object(required, rules) => {
-                    if *required != 0 && kind != TYPE_OBJECT {
-                        Invalid
-                    } else if kind != TYPE_OBJECT {
-                        Valid
-                    } else {
-                        self.object_tracked(rules, value, depth + 1, active, &mut evaluation)
-                    }
-                }
-                _ => self.leaf(op, kind, value, depth),
-            };
-            if result != Valid {
-                return Tracked::new(result);
-            }
-        }
-        evaluation
+        self.collect_trial(node, value, depth, active, kind_state)
     }
-    fn array_tracked(
+    pub(super) fn array_tracked(
         &self,
         r: &Array,
         value: Value,
@@ -454,7 +504,7 @@ impl Execution<'_> {
             return Invalid;
         }
         if r.unique {
-            let result = unique(value, depth, self.fixnum_flag, &self.budget);
+            let result = self.unique_values(value, depth);
             if result != Valid {
                 return result;
             }
@@ -491,7 +541,8 @@ impl Execution<'_> {
         if let Some(child) = r.contains {
             let count = match evaluation::scan_contains(
                 len,
-                |index| self.eval(child, unsafe { sn_entry(value, index) }, depth, active),
+                evaluation::ContainsPolicy::AllMatches,
+                |index| self.trial_status(child, unsafe { sn_entry(value, index) }, depth, active),
                 |index| evaluation.item(index),
             ) {
                 Ok(count) => count,
@@ -521,7 +572,7 @@ impl Execution<'_> {
         }
         Valid
     }
-    fn object_tracked(
+    pub(super) fn object_tracked(
         &self,
         r: &Object,
         value: Value,
@@ -536,33 +587,48 @@ impl Execution<'_> {
         if bounds(len, r.min, r.max) == Invalid {
             return Invalid;
         }
-        let status = r.check_required(value, self.undefined, &self.budget);
+        let status = r.check_required(self.caches, value, self.undefined, &self.budget);
         if status != Valid {
             return status;
         }
-        let found = match r.visit_properties(
-            value,
-            len,
-            self.undefined,
-            &self.budget,
-            |index, child, item| {
-                let result = self.record_value(child, item, depth, active);
-                if result == Valid {
-                    evaluation.known_property(r.property_indices[index]);
-                }
-                result
-            },
-        ) {
-            Ok(found) => found,
-            Err(status) => return status,
+        let ordered = self.caches.runtime_order();
+        let found = if ordered {
+            0
+        } else {
+            match r.visit_properties(
+                value,
+                len,
+                self.undefined,
+                &self.budget,
+                |index, child, item| {
+                    let result = self.record_value(child, item, depth, active);
+                    if result == Valid {
+                        evaluation.known_property(r.property_indices[index]);
+                    }
+                    result
+                },
+            ) {
+                Ok(found) => found,
+                Err(status) => return status,
+            }
         };
-        if r.names.is_some() || !r.patterns.is_empty() || (r.additional.is_some() && found < len) {
+        if ordered
+            || r.names.is_some()
+            || !r.patterns.is_empty()
+            || (r.additional.is_some() && found < len)
+        {
             let result = self.tracked_object_walk(r, value, depth, active, evaluation, false);
             if result != Valid {
                 return result;
             }
         }
-        let status = r.check_dependent_required(value, self.undefined, &self.budget);
+        if ordered && r.names.is_some() {
+            let status = self.object_names(r, value, depth, active);
+            if status != Valid {
+                return status;
+            }
+        }
+        let status = r.check_dependent_required(self.caches, value, self.undefined, &self.budget);
         if status != Valid {
             return status;
         }
@@ -571,7 +637,8 @@ impl Execution<'_> {
                 return Unsupported;
             }
             if !missing(value, key, self.undefined) {
-                let result = evaluation.merge(self.eval_tracked(child, value, depth, active));
+                let result =
+                    evaluation.merge_runtime(self, self.eval_tracked(child, value, depth, active));
                 if result != Valid {
                     return result;
                 }
@@ -642,15 +709,18 @@ unsafe extern "C" fn tracking_entry(context: *mut c_void, key: Value, value: Val
             }
             c.rules.unevaluated
         } else {
-            if let Some(child) = c.rules.names {
+            if !c.engine.caches.runtime_order()
+                && let Some(child) = c.rules.names
+            {
                 let result = c.engine.eval(child, key, c.depth, c.active);
                 if result != Valid {
                     return result as i32;
                 }
             }
-            let result = c.rules.visit_value_rules::<false>(
+            let result = c.rules.visit_value_rules(
                 c.engine.caches,
                 &c.engine.budget,
+                c.engine.caches.runtime_order(),
                 key,
                 Some(key_location),
                 |_, _, child| match c.engine.eval(child, value, c.depth, c.active) {