nosj 0.3.2 → 0.4.1

data/ext/nosj/src/sink.rs

@@ -35,24 +35,21 @@ pub(crate) enum SinkAbort {
     NonFiniteFloat(&'static str),
 }
 
-/// `RB_INT2FIX` ported from Ruby's public inline headers: fixnums are
-/// `(i << 1) + 1` for `|i| <= LONG_MAX / 2`, and the range is defined by
-/// the C `long`, which is 32-bit on Windows (LLP64): fixnums there hold
-/// only 31 bits, and tagging anything wider crashes Ruby with
-/// "Unnormalized Fixnum value". C extensions get the check inlined by the
-/// header; going through the extern `rb_ll2inum` costs an FFI call per
-/// integer. Non-fixable values still take the call.
-// The widening is an identity on LP64 hosts (clippy flags it there) but
-// required on Windows, where c_long is 32-bit.
-#[allow(clippy::unnecessary_cast)]
+/// Integer VALUE for `i` via rb-sys's inline `LONG2NUM` (the header
+/// macro: a Fixnum tagged inline when it fits, else a Bignum), which
+/// saves the FFI call per integer that `rb_ll2inum` costs. The fixable
+/// range is defined by the C `long`, which is 32-bit on Windows (LLP64):
+/// fixnums there hold only 31 bits, and tagging anything wider crashes
+/// Ruby with "Unnormalized Fixnum value"; values beyond `long` take
+/// `rb_ll2inum`.
+// The conversion is an identity on LP64 hosts (clippy flags it there)
+// but narrows on Windows, where c_long is 32-bit.
+#[allow(clippy::useless_conversion, clippy::unnecessary_fallible_conversions)]
 #[inline(always)]
 fn int_to_raw(i: i64) -> rb_sys::VALUE {
-    const FIXABLE_MIN: i64 = (std::os::raw::c_long::MIN / 2) as i64;
-    const FIXABLE_MAX: i64 = (std::os::raw::c_long::MAX / 2) as i64;
-    if (FIXABLE_MIN..=FIXABLE_MAX).contains(&i) {
-        ((i as u64) << 1).wrapping_add(1) as rb_sys::VALUE
-    } else {
-        unsafe { rb_sys::rb_ll2inum(i) }
+    match std::os::raw::c_long::try_from(i) {
+        Ok(l) => rb_sys::macros::LONG2NUM(l),
+        Err(_) => unsafe { rb_sys::rb_ll2inum(i) },
     }
 }
 

data/ext/nosj/src/state.rs

@@ -10,18 +10,36 @@ use ahash::AHashMap;
 use magnus::typed_data::Obj;
 use magnus::{DataTypeFunctions, TypedData};
 use nosj::Buffers;
-use std::cell::RefCell;
+use std::cell::Cell;
+use std::thread::LocalKey;
 
-/// Everything a parse touches, allocated once per thread and reused:
-/// nosj's scratch buffers, the interned-key caches, and the GC-marked
-/// stacks.
+/// Run `f` on a pooled thread-local value, taken OUT of its cell for the
+/// call and stored back afterwards. Pooled state is never borrowed
+/// across a call that can reach Ruby: any allocation can raise
+/// NoMemoryError, whose longjmp skips these frames, and a RefCell borrow
+/// held across it would stay borrowed for good (under panic=abort, the
+/// next borrow kills the process). A value lost that way is only leaked;
+/// the next call, like a nested one finding the cell empty, starts from
+/// `T::default()`. The outermost call's value is the one stored back.
+pub(crate) fn with_taken<T: Default, R>(
+    key: &'static LocalKey<Cell<T>>,
+    f: impl FnOnce(&mut T) -> R,
+) -> R {
+    let mut value = key.take();
+    let result = f(&mut value);
+    key.set(value);
+    result
+}
+
+/// Everything a parse touches, reused across calls: nosj's scratch
+/// buffers, the interned-key caches, and the GC-marked stacks.
 pub(crate) struct PullState {
     pub(crate) bufs: Buffers,
     pub(crate) keys: AHashMap<Box<str>, rb_sys::VALUE>,
     /// Separate cache for symbolize_names mode: symbol and string VALUEs
     /// must never share a map.
     pub(crate) sym_keys: AHashMap<Box<str>, rb_sys::VALUE>,
-    /// Leaked once per thread; kept alive + GC-marked via the wrapped
+    /// Leaked once per state; kept alive + GC-marked via the wrapped
     /// handle.
     pub(crate) vstack: Option<&'static mut VStackShadow>,
     /// Marked shadow holding the cached key VALUEs; keys are kept alive by
@@ -29,14 +47,36 @@ pub(crate) struct PullState {
     pub(crate) key_shadow: Option<&'static mut VStackShadow>,
 }
 
+impl PullState {
+    #[cold]
+    fn fresh() -> Box<Self> {
+        Box::new(PullState {
+            bufs: Buffers::new(),
+            keys: AHashMap::with_capacity(256),
+            sym_keys: AHashMap::new(),
+            vstack: None,
+            key_shadow: None,
+        })
+    }
+}
+
 thread_local! {
-    pub(crate) static PULL_STATE: RefCell<PullState> = RefCell::new(PullState {
-        bufs: Buffers::new(),
-        keys: AHashMap::with_capacity(256),
-        sym_keys: AHashMap::new(),
-        vstack: None,
-        key_shadow: None,
-    });
+    static PULL_STATE: Cell<Option<Box<PullState>>> = const { Cell::new(None) };
+}
+
+/// Run `f` on this thread's parse state, taken out like [`with_taken`]
+/// (a state lost to a longjmp leaks its shadows' last VALUEs; a nested
+/// call would start a fresh one). Unlike the generate scratch, parse
+/// bodies never run Ruby code, so the thread cannot hop native threads
+/// mid-call and one thread-local access serves both the take and the
+/// put-back: measured ~5ns per call on tiny documents against two.
+pub(crate) fn with_pull_state<R>(f: impl FnOnce(&mut PullState) -> R) -> R {
+    PULL_STATE.with(|cell| {
+        let mut state = cell.take().unwrap_or_else(PullState::fresh);
+        let result = f(&mut state);
+        cell.set(Some(state));
+        result
+    })
 }
 
 /// GC-marked holder for pending VALUEs.
@@ -48,6 +88,12 @@ pub(crate) struct VStackShadow {
 /// through [`DataTypeFunctions::mark`] (its trampoline, not ours),
 /// pinning every pending VALUE with `rb_gc_mark` semantics. The class
 /// is defined (and made a private constant) at init.
+///
+/// Deliberately NOT `wb_protected`: parses push VALUEs into the shadow
+/// with plain stores, no write barriers, so an old protected handle
+/// would let the GC miss young values it holds (a use-after-free).
+/// Staying write-barrier-unprotected makes every GC rescan the handle,
+/// which costs nothing measurable: there are one to three per thread.
 #[derive(TypedData)]
 #[magnus(class = "NOSJ::ValueStackShadow", mark)]
 pub(crate) struct ShadowHandle(*const VStackShadow);
@@ -74,7 +120,7 @@ impl DataTypeFunctions for ShadowHandle {
     }
 }
 
-/// Create (once per thread) a leaked, GC-marked VStackShadow.
+/// Create (once per owning state) a leaked, GC-marked VStackShadow.
 pub(crate) fn ensure_marked_shadow(slot: &mut Option<&'static mut VStackShadow>) {
     if slot.is_none() {
         let ruby = magnus::Ruby::get().expect("called on a Ruby thread");
@@ -83,7 +129,7 @@ pub(crate) fn ensure_marked_shadow(slot: &mut Option<&'static mut VStackShadow>)
         }));
         let ptr = std::ptr::from_mut::<VStackShadow>(shadow).cast_const();
         let handle: Obj<ShadowHandle> = ruby.obj_wrap(ShadowHandle(ptr));
-        magnus::gc::register_mark_object(handle);
+        ruby.gc_register_mark_object(handle);
         *slot = Some(shadow);
     }
 }

data/ext/nosj/src/stats.rs

@@ -12,7 +12,7 @@ use crate::errors::{nesting_error, parser_error, parser_error_at};
 use crate::files::with_mapped_file;
 use crate::parse::{parse_native_opts, utf8_input};
 use crate::sink::SinkAbort;
-use crate::state::PULL_STATE;
+use crate::state::with_pull_state;
 
 /// What the document's root value was; reported as a Symbol. The
 /// Default is never observable (a successful pass always saw a root
@@ -256,8 +256,7 @@ fn stats_over(ruby: &Ruby, input: &[u8], opts: Value) -> Result<Value, Error> {
         },
         ..StatsSink::default()
     };
-    let result = PULL_STATE.with(|cell| {
-        let mut state = cell.borrow_mut();
+    let result = with_pull_state(|state| {
         // Safety: callers verified UTF-8 (coderange or a full scan).
         unsafe { nosj::parse_utf8_unchecked_with(input, &mut state.bufs, &mut sink, o.popts) }
     });

data/lib/nosj/version.rb

@@ -2,5 +2,5 @@
 
 module NOSJ
   # The gem version.
-  VERSION = "0.3.2"
+  VERSION = "0.4.1"
 end

data/lib/nosj.rb

@@ -205,7 +205,8 @@ module NOSJ
 
   # Partial parsing by JSON Pointer (with the standard +~0+/+~1+
   # escapes). The matched subtree materializes under the same options
-  # as {.parse}.
+  # as {.parse}; +allow_nan+ and +allow_trailing_comma+ also govern the
+  # walk to it.
   #
   # @example
   #   NOSJ.at_pointer(json, "/users/3/name")  #=> "grace" or nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nosj
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.1
 platform: ruby
 authors:
 - Yaroslav Markin
@@ -104,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: An extremely fast JSON parser and generator for Ruby, written in Rust and
   SIMD-accelerated on every platform.