schemurai 3.0.0 → 3.0.2

data/ext/schemurai_native/src/enumeration.rs

@@ -7,13 +7,14 @@ const MAX_INDEX_BYTES: usize = 64 * 1024 * 1024;
 
 #[derive(Debug)]
 pub(super) struct Enumeration {
+    source: Value,
     values: Vec<Value>,
     index: Option<Index>,
     kinds: i32,
 }
 
 impl Enumeration {
-    pub(super) fn compile(values: Vec<Value>, fixnum_flag: Value) -> Self {
+    pub(super) fn compile(source: Value, values: Vec<Value>, fixnum_flag: Value) -> Self {
         let mut fingerprints = structural::Cache::batch(0);
         let budget = budget::Budget::default();
         let index = (values.len() > LINEAR_LIMIT)
@@ -31,12 +32,16 @@ impl Enumeration {
             0
         };
         Self {
+            source,
             values,
             index,
             kinds,
         }
     }
 
+    pub(super) fn runtime(&self, caches: &runtime::Caches, value: Value) -> Verdict {
+        caches.equality(self.source, value, RUNTIME_ENUM)
+    }
     pub(super) fn eval(
         &self,
         value: Value,

data/ext/schemurai_native/src/evaluation.rs

@@ -42,7 +42,6 @@ impl BranchPolicy {
 pub(super) trait BranchResult {
     fn valid() -> Self;
     fn status(&self) -> Verdict;
-    fn merge(&mut self, branch: Self);
 }
 impl BranchResult for Verdict {
     fn valid() -> Self {
@@ -51,7 +50,6 @@ impl BranchResult for Verdict {
     fn status(&self) -> Verdict {
         *self
     }
-    fn merge(&mut self, _: Self) {}
 }
 impl BranchResult for Tracked {
     fn valid() -> Self {
@@ -60,9 +58,6 @@ impl BranchResult for Tracked {
     fn status(&self) -> Verdict {
         self.status
     }
-    fn merge(&mut self, branch: Self) {
-        self.merge(branch);
-    }
 }
 
 pub(super) struct BranchMatches<R> {
@@ -72,33 +67,44 @@ pub(super) struct BranchMatches<R> {
 pub(super) fn scan_branches<R: BranchResult>(
     nodes: &[(usize, usize)],
     policy: BranchPolicy,
+    separate_calls: bool,
     mut evaluate: impl FnMut(usize) -> R,
+    mut merge: impl FnMut(&mut R, R) -> Result<(), Verdict>,
 ) -> Result<BranchMatches<R>, Verdict> {
     let mut result = BranchMatches {
         matches: 0,
         coverage: R::valid(),
     };
-    for &(node, multiplicity) in nodes {
-        let branch = evaluate(node);
-        match branch.status() {
-            Unsupported => return Err(Unsupported),
-            Invalid => {}
-            Valid => {
-                result.matches += multiplicity;
-                result.coverage.merge(branch);
+    'groups: for &(node, multiplicity) in nodes {
+        for _ in 0..if separate_calls { multiplicity } else { 1 } {
+            let branch = evaluate(node);
+            match branch.status() {
+                Unsupported => return Err(Unsupported),
+                Invalid => {}
+                Valid => {
+                    result.matches += if separate_calls { 1 } else { multiplicity };
+                    merge(&mut result.coverage, branch)?;
+                }
+            }
+            if policy.finished(result.matches) {
+                break 'groups;
             }
-        }
-        if policy.finished(result.matches) {
-            break;
         }
     }
     Ok(result)
 }
 
-// Diagnostic counts and annotations need every match. Keep the same complete
-// traversal for ordinary validity so unsupported later items retain fallback.
+#[derive(Clone, Copy)]
+pub(super) enum ContainsPolicy {
+    FirstMatch,
+    AllMatches,
+}
+
+// Older dialects use any? for untracked validity; counted validity,
+// diagnostic counts and annotations need every match.
 pub(super) fn scan_contains(
     len: usize,
+    policy: ContainsPolicy,
     mut evaluate: impl FnMut(usize) -> Verdict,
     mut record: impl FnMut(usize),
 ) -> Result<usize, Verdict> {
@@ -110,6 +116,9 @@ pub(super) fn scan_contains(
             Valid => {
                 matches += 1;
                 record(index);
+                if matches!(policy, ContainsPolicy::FirstMatch) {
+                    break;
+                }
             }
         }
     }
@@ -184,7 +193,14 @@ mod tests {
         let nodes = [(0, 2), (1, 1)];
         let evaluate = |node| if node == 0 { Valid } else { Unsupported };
         for kind in [BranchKind::Any, BranchKind::One] {
-            let result = scan_branches(&nodes, BranchPolicy::Validity(kind), evaluate).unwrap();
+            let result = scan_branches(
+                &nodes,
+                BranchPolicy::Validity(kind),
+                false,
+                evaluate,
+                |_, _| Ok(()),
+            )
+            .unwrap();
             assert_eq!(result.matches, 2);
             assert_eq!(
                 kind.accepts(result.matches),
@@ -192,7 +208,9 @@ mod tests {
             );
         }
         assert!(matches!(
-            scan_branches(&nodes, BranchPolicy::Complete, evaluate),
+            scan_branches(&nodes, BranchPolicy::Complete, false, evaluate, |_, _| Ok(
+                ()
+            )),
             Err(Unsupported)
         ));
     }
@@ -202,6 +220,7 @@ mod tests {
         let mut recorded = vec![];
         let result = scan_contains(
             4,
+            ContainsPolicy::AllMatches,
             |index| verdict(index % 2 == 0),
             |index| recorded.push(index),
         );
@@ -210,6 +229,16 @@ mod tests {
         assert_eq!(
             scan_contains(
                 2,
+                ContainsPolicy::FirstMatch,
+                |index| if index == 0 { Valid } else { Unsupported },
+                |_| {}
+            ),
+            Ok(1)
+        );
+        assert_eq!(
+            scan_contains(
+                2,
+                ContainsPolicy::AllMatches,
                 |index| if index == 0 { Valid } else { Unsupported },
                 |_| {}
             ),

data/ext/schemurai_native/src/format.rs

@@ -51,9 +51,6 @@ impl Format {
             Self::Unsupported => return Unsupported,
         })
     }
-    pub(super) fn eval_items(&self, required: i32, values: &[Value]) -> Verdict {
-        self.visit_invalid_items(required, values, |_, _| Invalid)
-    }
     pub(super) fn visit_invalid_items(
         &self,
         required: i32,
@@ -91,9 +88,14 @@ fn scan_items(
         let mut data = std::ptr::null();
         let mut len = 0;
         let kind = unsafe { sn_format_item_view(value, &mut data, &mut len) };
-        let result = if kind == -TYPE_UNSUPPORTED {
-            Unsupported
-        } else if kind < 0 {
+        if kind == -TYPE_UNSUPPORTED {
+            let status = invalid(index, value);
+            if status != Valid {
+                return status;
+            }
+            continue;
+        }
+        let result = if kind < 0 {
             verdict(required == 0)
         } else {
             matches(unsafe { byte_view(data, len) })
@@ -118,16 +120,100 @@ fn date_exact(bytes: &[u8]) -> bool {
 fn date_time(bytes: &[u8]) -> bool {
     bytes.len() >= 20 && date(bytes) && matches!(bytes[10], b'T' | b't') && time(&bytes[11..])
 }
+// Keep the SIMD body out of the shared format dispatchers. Local x64 benchmarks
+// and disassembly showed that inlining it shifted the unchanged JSON Pointer
+// loop into a slower instruction layout; outlining retains the UUID SIMD gain.
+#[inline(never)]
 fn uuid(bytes: &[u8]) -> bool {
-    bytes.len() == 36
-        && bytes.iter().enumerate().all(|(index, byte)| {
-            if matches!(index, 8 | 13 | 18 | 23) {
-                *byte == b'-'
-            } else {
-                byte.is_ascii_hexdigit()
-            }
-        })
+    if bytes.len() != 36 || [8, 13, 18, 23].iter().any(|&at| bytes[at] != b'-') {
+        return false;
+    }
+    #[cfg(any(
+        all(target_arch = "x86_64", target_feature = "sse2"),
+        all(
+            target_arch = "aarch64",
+            target_feature = "neon",
+            target_endian = "little"
+        )
+    ))]
+    {
+        // The first two vectors contain all four separators. Their exact
+        // positions were checked above; only those lanes may bypass hex checks.
+        hex_block(&bytes[..16], (1 << 8) | (1 << 13))
+            && hex_block(&bytes[16..32], (1 << 2) | (1 << 7))
+            && bytes[32..].iter().all(u8::is_ascii_hexdigit)
+    }
+    #[cfg(not(any(
+        all(target_arch = "x86_64", target_feature = "sse2"),
+        all(
+            target_arch = "aarch64",
+            target_feature = "neon",
+            target_endian = "little"
+        )
+    )))]
+    bytes
+        .iter()
+        .enumerate()
+        .all(|(index, byte)| matches!(index, 8 | 13 | 18 | 23) || byte.is_ascii_hexdigit())
+}
+
+#[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
+fn hex_block(bytes: &[u8], separators: u16) -> bool {
+    use core::arch::x86_64::{
+        _mm_cmpeq_epi8, _mm_loadu_si128, _mm_movemask_epi8, _mm_or_si128, _mm_set1_epi8,
+        _mm_setzero_si128, _mm_sub_epi8, _mm_subs_epu8,
+    };
+    // The caller supplies sixteen readable bytes. SSE2 is a target baseline;
+    // unsigned wrapping subtraction rejects bytes below the ASCII ranges too.
+    let valid = unsafe {
+        let word = _mm_loadu_si128(bytes.as_ptr().cast());
+        let digits = _mm_sub_epi8(word, _mm_set1_epi8(b'0' as i8));
+        let letters = _mm_sub_epi8(
+            _mm_or_si128(word, _mm_set1_epi8(32)),
+            _mm_set1_epi8(b'a' as i8),
+        );
+        let digits = _mm_cmpeq_epi8(_mm_subs_epu8(digits, _mm_set1_epi8(9)), _mm_setzero_si128());
+        let letters = _mm_cmpeq_epi8(
+            _mm_subs_epu8(letters, _mm_set1_epi8(5)),
+            _mm_setzero_si128(),
+        );
+        _mm_movemask_epi8(_mm_or_si128(digits, letters)) as u16
+    };
+    valid | separators == u16::MAX
 }
+
+#[cfg(all(
+    target_arch = "aarch64",
+    target_feature = "neon",
+    target_endian = "little"
+))]
+fn hex_block(bytes: &[u8], separators: u16) -> bool {
+    use core::arch::aarch64::{
+        vcleq_u8, vdupq_n_u8, vget_lane_u64, vld1q_u8, vorrq_u8, vreinterpret_u64_u8,
+        vreinterpretq_u16_u8, vshrn_n_u16, vsubq_u8,
+    };
+    // Each load remains within the sixteen-byte block. Narrowing packs two
+    // four-bit flags per byte in little-endian lane order.
+    let valid = unsafe {
+        let word = vld1q_u8(bytes.as_ptr());
+        let digits = vcleq_u8(vsubq_u8(word, vdupq_n_u8(b'0')), vdupq_n_u8(9));
+        let letters = vcleq_u8(
+            vsubq_u8(vorrq_u8(word, vdupq_n_u8(32)), vdupq_n_u8(b'a')),
+            vdupq_n_u8(5),
+        );
+        let flags = vorrq_u8(digits, letters);
+        let packed = vshrn_n_u16::<4>(vreinterpretq_u16_u8(flags));
+        vget_lane_u64::<0>(vreinterpret_u64_u8(packed))
+    };
+    let mut ignored = 0_u64;
+    for lane in 0..16 {
+        if separators & (1 << lane) != 0 {
+            ignored |= 0xf << (lane * 4);
+        }
+    }
+    valid | ignored == u64::MAX
+}
+
 fn relative_pointer(bytes: &[u8]) -> bool {
     let Some(end) = digits_end(bytes, 0) else {
         return false;
@@ -355,3 +441,29 @@ fn ipv6(bytes: &[u8]) -> bool {
     }
     if compressed { groups < 8 } else { groups == 8 }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn uuid_checks_every_byte_and_separator_without_accepting_non_ascii() {
+        let original = *b"123e4567-e89b-12d3-a456-426614174000";
+        for at in 0..36 {
+            for byte in 0..=255 {
+                let mut input = original;
+                input[at] = byte;
+                let expected = if matches!(at, 8 | 13 | 18 | 23) {
+                    byte == b'-'
+                } else {
+                    byte.is_ascii_hexdigit()
+                };
+                assert_eq!(uuid(&input), expected, "position {at}, byte {byte}");
+            }
+        }
+        assert!(!uuid(&original[..35]));
+        let mut longer = original.to_vec();
+        longer.push(b'0');
+        assert!(!uuid(&longer));
+    }
+}

data/ext/schemurai_native/src/graph.rs

@@ -26,6 +26,34 @@ pub(super) fn postorder(edges: &[Vec<usize>], seen: &mut [bool]) -> Vec<usize> {
     order
 }
 
+pub(super) fn parents(edges: &[Vec<usize>]) -> Vec<Vec<usize>> {
+    let mut parents = vec![vec![]; edges.len()];
+    for (parent, children) in edges.iter().enumerate() {
+        for &child in children {
+            parents[child].push(parent);
+        }
+    }
+    parents
+}
+
+// Reachability flags flow from children to parents, including through cycles.
+// Each newly marked node enters the queue once.
+pub(super) fn propagate(flags: &mut [bool], parents: &[Vec<usize>]) {
+    let mut queue: std::collections::VecDeque<_> = flags
+        .iter()
+        .enumerate()
+        .filter_map(|(node, &set)| set.then_some(node))
+        .collect();
+    while let Some(node) = queue.pop_front() {
+        for &parent in &parents[node] {
+            if !flags[parent] {
+                flags[parent] = true;
+                queue.push_back(parent);
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -39,6 +67,15 @@ mod tests {
         assert!(postorder(&[], &mut []).is_empty());
     }
 
+    #[test]
+    fn flags_propagate_through_cycles_without_marking_disconnected_nodes() {
+        let parents = vec![vec![2], vec![0], vec![1, 3], vec![], vec![4]];
+        let mut flags = vec![false, true, false, false, false];
+        propagate(&mut flags, &parents);
+        assert_eq!(flags, [true, true, true, true, false]);
+        propagate(&mut [], &[]);
+    }
+
     #[test]
     fn deep_chains_use_an_explicit_stack() {
         let count = 100_000;

data/ext/schemurai_native/src/instance_graph.rs

@@ -82,3 +82,93 @@ unsafe extern "C" fn entry(context: *mut c_void, _key: Value, value: Value) -> i
     }))
     .unwrap_or(VERDICT_INVALID)
 }
+
+enum Work {
+    Visit(Value),
+    Finish(Value),
+}
+
+pub(super) enum Safety {
+    Ordinary,
+    Cyclic,
+    Unsupported,
+}
+
+// A failed fingerprint may indicate either an optimization bound or Ruby
+// behavior that native equality must not skip. Classify every reachable value
+// before substituting direct comparisons or a stack error for hashing. Continue
+// after detecting a cycle: any special value still requires Ruby's behavior.
+// Unlike the memoization hint above, this rare path needs no depth/visit cap.
+pub(super) fn ordinary_graph(value: Value, budget: &budget::Budget) -> Safety {
+    let mut work = vec![Work::Visit(value)];
+    let mut states = HashMap::new();
+    let mut cyclic = false;
+    while let Some(task) = work.pop() {
+        if !budget.checkpoint() {
+            return Safety::Unsupported;
+        }
+        match task {
+            Work::Finish(value) => {
+                states.insert(value, true);
+            }
+            Work::Visit(value) => {
+                if let Some(&done) = states.get(&value) {
+                    if !done {
+                        cyclic = true;
+                    }
+                    continue;
+                }
+                match unsafe { sn_kind(value) } {
+                    TYPE_UNSUPPORTED => return Safety::Unsupported,
+                    TYPE_ARRAY => {
+                        states.insert(value, false);
+                        work.push(Work::Finish(value));
+                        for i in (0..unsafe { sn_len(value) }).rev() {
+                            work.push(Work::Visit(unsafe { sn_entry(value, i) }));
+                        }
+                    }
+                    TYPE_OBJECT => {
+                        states.insert(value, false);
+                        work.push(Work::Finish(value));
+                        let mut context = OrdinaryWalk {
+                            work: &mut work,
+                            budget,
+                        };
+                        if unsafe {
+                            sn_hash_each(
+                                value,
+                                (&mut context as *mut OrdinaryWalk<'_>).cast(),
+                                ordinary_entry,
+                            )
+                        } != VERDICT_VALID
+                        {
+                            return Safety::Unsupported;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+    if cyclic {
+        Safety::Cyclic
+    } else {
+        Safety::Ordinary
+    }
+}
+
+struct OrdinaryWalk<'a> {
+    work: &'a mut Vec<Work>,
+    budget: &'a budget::Budget,
+}
+unsafe extern "C" fn ordinary_entry(context: *mut c_void, _: Value, value: Value) -> i32 {
+    catch_unwind(AssertUnwindSafe(|| {
+        let context = unsafe { &mut *context.cast::<OrdinaryWalk<'_>>() };
+        if !context.budget.checkpoint() {
+            return VERDICT_UNSUPPORTED;
+        }
+        context.work.push(Work::Visit(value));
+        VERDICT_VALID
+    }))
+    .unwrap_or(VERDICT_UNSUPPORTED)
+}

data/ext/schemurai_native/src/integer_scan.rs

@@ -0,0 +1,132 @@
+//! Validate complete blocks of borrowed, header-verified immediate integers.
+//! Stop before any uncertain block so the ordinary evaluator retains ordering.
+use super::Value;
+
+pub(super) fn valid_prefix(values: &[Value], min: i64, max: i64, fixnum_flag: Value) -> usize {
+    if fixnum_flag != 1 || values.len() < 16 {
+        return 0;
+    }
+    // Comparing tagged values preserves signed integer order. Clamp the
+    // interval before tagging, since some schema limits exceed Fixnum range.
+    let min = min.max(-(1_i64 << 62));
+    let max = max.min((1_i64 << 62) - 1);
+    if min > max {
+        return 0;
+    }
+    let min = (min << 1) | 1;
+    let max = (max << 1) | 1;
+    #[cfg(target_arch = "x86_64")]
+    if std::is_x86_feature_detected!("avx2") {
+        // Detection includes OS support. The kernel only loads full blocks.
+        return unsafe { avx2_prefix(values, min, max) };
+    }
+    #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
+    return neon_prefix(values, min, max);
+    #[allow(unreachable_code)]
+    {
+        let _ = (min, max);
+        0
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+#[target_feature(enable = "avx2")]
+unsafe fn avx2_prefix(values: &[Value], min: i64, max: i64) -> usize {
+    use core::arch::x86_64::{
+        _mm256_and_si256, _mm256_andnot_si256, _mm256_cmpeq_epi64, _mm256_cmpgt_epi64,
+        _mm256_loadu_si256, _mm256_movemask_epi8, _mm256_or_si256, _mm256_set1_epi64x,
+    };
+    let lower = _mm256_set1_epi64x(min);
+    let upper = _mm256_set1_epi64x(max);
+    let tag = _mm256_set1_epi64x(1);
+    let mut consumed = 0;
+    for block in values.as_chunks::<4>().0 {
+        // Four VALUE words provide all 32 readable bytes. No Ruby object is
+        // dereferenced; the header-validated low bit identifies each Fixnum.
+        let valid = unsafe {
+            let word = _mm256_loadu_si256(block.as_ptr().cast());
+            let tagged = _mm256_cmpeq_epi64(_mm256_and_si256(word, tag), tag);
+            let outside = _mm256_or_si256(
+                _mm256_cmpgt_epi64(lower, word),
+                _mm256_cmpgt_epi64(word, upper),
+            );
+            _mm256_movemask_epi8(_mm256_andnot_si256(outside, tagged)) == -1
+        };
+        if !valid {
+            break;
+        }
+        consumed += 4;
+    }
+    consumed
+}
+
+#[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
+fn neon_prefix(values: &[Value], min: i64, max: i64) -> usize {
+    use core::arch::aarch64::{
+        vandq_u64, vceqq_u64, vcgeq_s64, vcleq_s64, vdupq_n_s64, vdupq_n_u64, vgetq_lane_u64,
+        vld1q_u64, vreinterpretq_s64_u64,
+    };
+    // This function is compiled only when the target guarantees NEON.
+    let (lower, upper, tag) = unsafe { (vdupq_n_s64(min), vdupq_n_s64(max), vdupq_n_u64(1)) };
+    let mut consumed = 0;
+    for block in values.as_chunks::<2>().0 {
+        // Baseline NEON; the unaligned load stays within two borrowed VALUEs.
+        let valid = unsafe {
+            let word = vld1q_u64(block.as_ptr().cast());
+            let tagged = vceqq_u64(vandq_u64(word, tag), tag);
+            let signed = vreinterpretq_s64_u64(word);
+            let bounds = vandq_u64(vcgeq_s64(signed, lower), vcleq_s64(signed, upper));
+            let valid = vandq_u64(tagged, bounds);
+            vgetq_lane_u64::<0>(valid) & vgetq_lane_u64::<1>(valid) == u64::MAX
+        };
+        if !valid {
+            break;
+        }
+        consumed += 2;
+    }
+    consumed
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tag(value: i64) -> Value {
+        ((value << 1) | 1) as Value
+    }
+
+    #[test]
+    fn skips_only_valid_fixnums_before_the_first_uncertain_block() {
+        for len in 0..65 {
+            let original: Vec<_> = (0..len).map(|at| tag((at % 33) as i64 - 16)).collect();
+            for at in 0..len {
+                for value in [0, 2, tag(-17), tag(17), tag(-(1 << 62)), tag((1 << 62) - 1)] {
+                    let mut values = original.clone();
+                    values[at] = value;
+                    let prefix = valid_prefix(&values, -16, 16, 1);
+                    assert!(prefix <= at, "length {len}, position {at}, prefix {prefix}");
+                    assert_eq!(&values[..prefix], &original[..prefix]);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn clamps_schema_limits_without_overflow_and_obeys_disabled_hints() {
+        let values = [tag(-(1 << 62)), tag((1 << 62) - 1)].repeat(32);
+        let prefix = valid_prefix(&values, i64::MIN, i64::MAX, 1);
+        #[cfg(target_arch = "x86_64")]
+        if std::is_x86_feature_detected!("avx2") {
+            assert_eq!(prefix, values.len());
+        }
+        #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
+        assert_eq!(prefix, values.len());
+        assert!(prefix <= values.len());
+        assert_eq!(valid_prefix(&values, i64::MIN, i64::MAX, 0), 0);
+        assert_eq!(valid_prefix(&values, 1 << 62, i64::MAX, 1), 0);
+        assert_eq!(valid_prefix(&values, i64::MIN, -(1 << 62) - 1, 1), 0);
+        assert_eq!(valid_prefix(&values, 1, 0, 1), 0);
+        assert_eq!(valid_prefix(&values, -(1 << 62) + 1, i64::MAX, 1), 0);
+        assert_eq!(valid_prefix(&values, i64::MIN, (1 << 62) - 2, 1), 0);
+    }
+}