teptris 0.2.51 → 0.2.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9378e4039e62c8ef1b8271ccf3b2cc8f07ad8db855b4cb399ce4725d25f1d17f
-  data.tar.gz: b8012bdfb1f3b070f4a42e966da73d9541bce3376a879c252a801af6208b675e
+  metadata.gz: 2537428f82b791a55389c0be4bb2eaa2115f118238839705a913e51da11e6af1
+  data.tar.gz: a95d1d2b3f582803ef44c0bacbc1ec9172a9cf044c30cf56a488963f575c4007
 SHA512:
-  metadata.gz: 588eb7a305d2c39495de417dd95dd091aa5a3bb1251e62b5feb9e5115c9a9740b202a2d3debc7e8a1934d1ec0459a1d8835c31e01675d5938f59c2be4367d3c9
-  data.tar.gz: d21e70ded4f0441c8d2f9e5b7d5d7e18d0f6a12c9601f902f70dd4e11a98f154e9f5716cf97839043e2f6247b62af04e6187445523b1b783bd02f231907d0e23
+  metadata.gz: 2a8d04664b9cb79842b466a7bc4e877e167ff61aaa58258c2e2419363d601d75ad759913f439c3f722c0b3ceccee603548414dcbcf828aa169acd00793fad92c
+  data.tar.gz: 27633d7ecf115edbb86be8b669552b8bdd4ccc427aacd1c775dea017a4a143aa7df267a4dfb0ffa59de3f1e827f0056f6e6989f16e022ee808d277ee2e32bcc8

data/ext/teptris_ext/materialize.c

@@ -1,4 +1,5 @@
 #include <ruby.h>
+#include <ruby/thread.h>
 #include <ruby/encoding.h>
 #include "teptris/teptris.h"
 #include "teptris/plan.h"
@@ -237,9 +238,36 @@ static VALUE obj_from_node(const teptris_node *n, unsigned flags,
     }}
 }
 
+/* the parse is pure C over the buffer with no VM access: run it
+ * GVL-free so other threads progress during long parses (and parallel
+ * batch loads overlap). The string is locked (pinned) across the
+ * release so a concurrent compacting GC cannot relocate the buffer. */
+struct gvl_parse_arg {
+    const char *data;
+    size_t len;
+    teptris_document **doc;
+    teptris_status st;
+};
+
+static void *parse_without_gvl(void *p)
+{
+    struct gvl_parse_arg *a = (struct gvl_parse_arg *)p;
+    a->st = teptris_parse(a->data, a->len, NULL, a->doc);
+    return NULL;
+}
+
 static teptris_document *parse_or_raise(VALUE str) {
     teptris_document *doc = NULL;
-    teptris_status st = teptris_parse(RSTRING_PTR(str), (size_t)RSTRING_LEN(str), NULL, &doc);
+    /* frozen strings cannot take the tmp lock (ruby 4.0 raises
+     * FrozenError - chilled literals); a dup is movable-page-safe the
+     * same way, at one input copy for frozen callers only */
+    volatile VALUE pin = OBJ_FROZEN(str) ? rb_str_dup(str) : str;
+    rb_str_locktmp(pin);
+    struct gvl_parse_arg arg = {RSTRING_PTR(pin), (size_t)RSTRING_LEN(pin),
+                                &doc, TEPTRIS_OK};
+    rb_thread_call_without_gvl(parse_without_gvl, &arg, RUBY_UBF_IO, NULL);
+    rb_str_unlocktmp(pin);
+    teptris_status st = arg.st;
     if (st != TEPTRIS_OK) {
         const teptris_error *e = teptris_document_error(doc);
         VALUE ex = rb_exc_new(eParseError, e->message, (long)strlen(e->message));
@@ -995,6 +1023,100 @@ static VALUE ext_load_lazy_batch(VALUE self, VALUE strings) {
  * as ext_load. opts is parsed once; safe_load semantics apply uniformly.
  * The caller's input Array is read-only; its strings stay referenced
  * for the duration of the C call (no separate keeper Array). */
+/* slice-level GVL release: one thread parses K documents under a
+ * single release (no per-document GVL ping-pong), then materializes
+ * them under the GVL with one shared key cache (batch semantics).
+ * All inputs are pinned (dup'd when frozen) across the release. */
+struct slice_parse_arg {
+    long n;
+    const char **data;
+    size_t *lens;
+    teptris_document **docs;
+    teptris_status *stats;
+};
+
+static void *slice_parse_without_gvl(void *p)
+{
+    struct slice_parse_arg *a = (struct slice_parse_arg *)p;
+    for (long i = 0; i < a->n; i++) {
+        a->docs[i] = NULL;
+        a->stats[i] = teptris_parse(a->data[i], a->lens[i], NULL, &a->docs[i]);
+    }
+    return NULL;
+}
+
+static VALUE ext_load_slice(int argc, VALUE *argv, VALUE self) {
+    VALUE strs, opts;
+    rb_scan_args(argc, argv, "11", &strs, &opts);
+    Check_Type(strs, T_ARRAY);
+    long n = RARRAY_LEN(strs);
+    if (n == 0) return rb_ary_new();
+    unsigned flags = flags_from_opts(opts);
+
+    volatile VALUE *pins = ALLOC_N(VALUE, n);
+    const char **data = ALLOC_N(const char *, n);
+    size_t *lens = ALLOC_N(size_t, n);
+    teptris_document **docs = ALLOC_N(teptris_document *, n);
+    teptris_status *stats = ALLOC_N(teptris_status, n);
+    /* the tmp lock is one-per-string: repeated objects in the slice
+     * get a dup before pinning (frozen inputs dup for the same reason
+     * - they cannot take the lock, yet compaction can move them) */
+    VALUE seen = rb_hash_new();
+    long i;
+    for (i = 0; i < n; i++) {
+        VALUE str = rb_ary_entry(strs, i);
+        StringValue(str);
+        VALUE id = rb_obj_id(str);
+        if (!NIL_P(rb_hash_aref(seen, id))) {
+            str = rb_str_dup(str);
+        } else {
+            rb_hash_aset(seen, id, Qtrue);
+            if (OBJ_FROZEN(str)) str = rb_str_dup(str);
+        }
+        pins[i] = str;
+        rb_str_locktmp(pins[i]);
+        data[i] = RSTRING_PTR(pins[i]);
+        lens[i] = (size_t)RSTRING_LEN(pins[i]);
+    }
+    struct slice_parse_arg arg = {n, data, lens, docs, stats};
+    rb_thread_call_without_gvl(slice_parse_without_gvl, &arg,
+                               RUBY_UBF_IO, NULL);
+    for (i = 0; i < n; i++) rb_str_unlocktmp(pins[i]);
+
+    VALUE out = rb_ary_new_capa(n);
+    keycache kc;
+    kc_init(&kc);
+    for (i = 0; i < n; i++) {
+        if (stats[i] != TEPTRIS_OK && docs[i] == NULL) {
+            const char *msg = "parse failed (out of memory)";
+            VALUE ex = rb_exc_new(eParseError, msg, (long)strlen(msg));
+            kc_free(&kc);
+            xfree(pins); xfree(data); xfree(lens); xfree(docs); xfree(stats);
+            rb_exc_raise(ex);
+        }
+        const teptris_error *e = teptris_document_error(docs[i]);
+        if (stats[i] != TEPTRIS_OK) {
+            VALUE ex = rb_exc_new(eParseError, e->message,
+                                  (long)strlen(e->message));
+            rb_iv_set(ex, "@line", SIZET2NUM(e->line));
+            rb_iv_set(ex, "@column", SIZET2NUM(e->column));
+            long j;
+            for (j = i; j < n; j++) teptris_document_free(docs[j]);
+            kc_free(&kc);
+            xfree(pins); xfree(data); xfree(lens); xfree(docs); xfree(stats);
+            rb_exc_raise(ex);
+        }
+    }
+    for (i = 0; i < n; i++) {
+        rb_ary_store(out, i,
+                     obj_from_node(teptris_document_root(docs[i]), flags, &kc));
+        teptris_document_free(docs[i]);
+    }
+    kc_free(&kc);
+    xfree(pins); xfree(data); xfree(lens); xfree(docs); xfree(stats);
+    return out;
+}
+
 static VALUE ext_load_batch(int argc, VALUE *argv, VALUE self) {
     VALUE strings, opts;
     rb_scan_args(argc, argv, "11", &strings, &opts);
@@ -1052,6 +1174,7 @@ void Init_teptris_ext(void) {
     rb_define_module_function(m, "load", ext_load, -1);
     rb_define_module_function(m, "load_lazy", ext_load_lazy, 1);
     rb_define_module_function(m, "load_batch", ext_load_batch, -1);
+    rb_define_module_function(m, "load_slice", ext_load_slice, -1);
     rb_define_module_function(m, "load_lazy_batch", ext_load_lazy_batch, 1);
     cLazyOwner = rb_define_class_under(m, "LazyOwner", rb_cObject);
     cLazyValue = rb_define_class_under(m, "LazyValue", rb_cObject);

data/lib/teptris/toml.rb

@@ -51,9 +51,53 @@ module Teptris
       # struct across the batch, return one eager Hash per document.
       # Same datetime contract as load. A failing document raises
       # Teptris::ParseError carrying the first failure's line/column.
-      def load_batch(tomls, safe_load: nil, datetime_policy: :native)
+      def load_batch(tomls, safe_load: nil, datetime_policy: :native,
+                    threads: 1)
         _validate_batch!(tomls, safe_load, datetime_policy)
-        TeptrisExt.load_batch(tomls, _safe_load_opts(safe_load, datetime_policy))
+        opts = _safe_load_opts(safe_load, datetime_policy)
+        return TeptrisExt.load_batch(tomls, opts) if threads <= 1
+
+        # threads > 1: slice across Ruby threads. The C parse releases
+        # the GVL, so parses overlap; materialization serializes on the
+        # GVL. Contiguous slices keep error order deterministic: the
+        # lowest-index failure raises after all threads join.
+        n = tomls.size
+        threads = [threads, n].min
+        return TeptrisExt.load_batch(tomls, opts) if threads <= 1
+        # load_slice releases the GVL once per slice (no per-document
+        # ping-pong) and shares one key cache across its documents.
+        # Repeated objects are dup'd once each HERE: a repeat landing in
+        # two slices would double-lock across threads (the slice-level
+        # guard cannot see across slices); frozen dup'ing is C-side.
+        seen = {}
+        tomls = tomls.map do |s|
+          next s.dup if seen[s.object_id]
+          seen[s.object_id] = true
+          s
+        end
+        per = (n.to_f / threads).ceil
+        results = Array.new(n)
+        first_error = nil
+        mutex = Mutex.new
+        threads.times.map do |ti|
+          Thread.new(ti) do |i|
+            base = i * per
+            slice = tomls[base, per] || []
+            begin
+              loaded = TeptrisExt.load_slice(slice, opts)
+              slice.each_with_index { |_, j| results[base + j] = loaded[j] }
+            rescue StandardError => e
+              mutex.synchronize do
+                first_error ||= [base, e]
+              end
+            end
+          end
+        end.each(&:join)
+        if first_error
+          _, err = first_error
+          raise err
+        end
+        results
       end
 
       # Lazy twin of load_batch: parse N inputs eagerly, hand back an

data/lib/teptris/version.rb

@@ -1,3 +1,3 @@
 module Teptris
-  VERSION = "0.2.51"
+  VERSION = "0.2.52"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teptris
 version: !ruby/object:Gem::Version
-  version: 0.2.51
+  version: 0.2.52
 platform: ruby
 authors:
 - teptris contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies: []
 description: A native C extension over libteptris, a C99 TOML 1.1 parser/emitter.
   API shape mirrors the tomlib gem.