yeptris 0.1.13.0 → 0.1.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76bc800fd5065540397d957ca2162d2491474a086eda5b08436f016daa8f65e4
-  data.tar.gz: 683259ac45cfb084722337af80c066890bdf56f2608843343ebf8951589eafa8
+  metadata.gz: 17b1311c9327a9986b7bb89f3731fd40ca040c49336fdb97596951fbf87ed1c0
+  data.tar.gz: 6c1b2f707d15d469963ffc0ee030fc90287a5e01954d7431996f24765bddf9e3
 SHA512:
-  metadata.gz: 3b2be1bc057ee5a059e80ac087000afd2cee325473d834db34bd0f898318634e7b9be95dce9b523f909ae6884a56c9ede549a0e7142184eddf4cc96a13a11cb9
-  data.tar.gz: e95683f3b475a0dca70488a43cdf23a249d2bcd49c440b4c75bf31914265c0eae9fd2992d1bf6c0ebfa5b0487b796f1a24505e42b4715840c1731ce2af845a4c
+  metadata.gz: b04ca9a9d899c00207d8cf09ab1d1aa071c1cc63f2adab17cf87453d0a0646fc84c9df9f3e80f245bbc977a32e67feb7f25e2b562293a59adc102764b80507dc
+  data.tar.gz: 25c9033573e619dc69924f4ae15c102b650efdbf7d39c1dcc4d3d73243d1d0ac3037750c7b28b5e6d28562175296fd4b125e39253f4ab9c9ed799529d7fcb4ee

data/README.adoc

@@ -71,10 +71,20 @@ fastest first:
    ~29k-value corpus, Ruby 3.4:
 +
 ....
-JSON.parse        min 0.670  med 0.966  mean 0.910 ms
-Yeptris::JSON     min 0.637  med 0.674  mean 0.680 ms
-                  mean 0.75x faster, head-to-head 370/400 (92.5%)
+CI referee (gated at 1.05 on both platforms, order-alternating
+interleave, N=200):
+  ubuntu (x86_64, gc=disable)   mean 0.961x  vs JSON.parse
+  macos  (arm64,  gc=none)      mean 0.718x  (head-to-head 173/200)
 ....
+
+The parse-window GC strategy is per-arch and runtime-switchable:
+`Yeptris::Native.gc_mode` / `YEPTRIS_NATIVE_GC` = `:none`
+(steady-state: +0 heap pages, the stdlib's own GC cadence — the
+default on arm64) or `:disable` (no GC during the parse — the
+default on x86_64, faster where pages are free). On a LOADED x86_64
+box prefer `:none`: `:disable` grows ~478 heap pages per 50 parses,
+and page growth under contention is exactly the loaded-box
+regression. `:start` (in-window collection) measured 8x — dead.
 2. **Record-drain fallback** (always available): the strict-JSON
    validator gates, then the value records convert without the Psych
    quirk table — exact parity with engine 1, spec-pinned.

data/ext/yeptris_native/json_ruby.c

@@ -119,14 +119,18 @@ static VALUE jr_num(jr* j) {
     return DBL2NUM(dv);
 }
 
+/* Insert strategy (TODO.restructure/34): bulk lands all pairs in one
+ * rb_hash_bulk_insert (skips per-pair dispatch) but costs +1.4k
+ * intermediate allocations on the reference corpus — the CI referee
+ * rules per platform. aset = the per-pair rb_hash_aset loop. */
+enum { YEP_INS_BULK = 0, YEP_INS_ASET = 1 };
+static int yep_ins_mode = YEP_INS_BULK;
+
 static VALUE jr_object(jr* j) {
     j->i++; j->depth++;
     VALUE h = rb_hash_new_capa(8);
     jr_ws(j);
     if (j->i < j->len && j->p[j->i] == '}') { j->i++; j->depth--; return h; }
-    /* pairs collect into a flat buffer and land in ONE bulk insert:
-     * rb_hash_bulk_insert skips the per-pair method dispatch the
-     * aset loop pays (TODO.restructure/26's margin work) */
     VALUE pairs[64];
     VALUE* pv = pairs;
     size_t pcap = 64, pn = 0, heap_cap = 0;
@@ -140,23 +144,29 @@ static VALUE jr_object(jr* j) {
         j->i++;
         VALUE val = jr_value(j);
         if (j->err) goto out;
-        if (pn + 2 > pcap) {
-            size_t ncap = pcap * 2;
-            VALUE* nv = malloc(ncap * sizeof(VALUE));
-            if (!nv) { j->err = -1; goto out; }
-            memcpy(nv, pv, pn * sizeof(VALUE));
-            if (pv != pairs) { free(pv); heap_cap = 1; }
-            pv = nv; pcap = ncap;
+        if (yep_ins_mode == YEP_INS_ASET) {
+            rb_hash_aset(h, key, val);
+        } else {
+            if (pn + 2 > pcap) {
+                size_t ncap = pcap * 2;
+                VALUE* nv = malloc(ncap * sizeof(VALUE));
+                if (!nv) { j->err = -1; goto out; }
+                memcpy(nv, pv, pn * sizeof(VALUE));
+                if (pv != pairs) { free(pv); heap_cap = 1; }
+                pv = nv; pcap = ncap;
+            }
+            pv[pn++] = key;
+            pv[pn++] = val;
         }
-        pv[pn++] = key;
-        pv[pn++] = val;
         jr_ws(j);
         if (j->i >= j->len) { j->err = -2; goto out; }
         if (j->p[j->i] == ',') { j->i++; continue; }
         if (j->p[j->i] == '}') { j->i++; break; }
         j->err = -2; goto out;
     }
-    rb_hash_bulk_insert((long)pn, (const VALUE*)pv, h);
+    if (yep_ins_mode == YEP_INS_BULK) {
+        rb_hash_bulk_insert((long)pn, (const VALUE*)pv, h);
+    }
 out:
     if (pv != pairs) { free(pv); (void)heap_cap; }
     if (j->err) return Qnil;
@@ -205,16 +215,56 @@ static VALUE jr_value(jr* j) {
     j->err = -2; return Qnil;
 }
 
+/* GC strategy for the parse window (TODO.restructure/34): JSON.parse
+ * pays minor GCs mid-parse and recycles slots continuously; a blanket
+ * disable defers every collection — fresh pages each iteration, which
+ * is cheap idle and expensive exactly under memory contention (the
+ * loaded-box regression). The strategy is a runtime choice so the CI
+ * referee can A/B without rebuilds:
+ *   disable (default) — pause GC for the window
+ *   none               — never pause
+ *   start              — pause, then one gc_start before returning
+ *                        (pay the minor GC in-window, like JSON.parse)
+ */
+enum { YEP_GC_DISABLE = 0, YEP_GC_NONE = 1, YEP_GC_START = 2 };
+/* Default per arch (TODO.restructure/35, two CI rounds of evidence):
+ * - aarch64/darwin: NONE — +0 heap pages, the stdlib's own GC cadence
+ *   (0.745x mean, h2h 91% on mac runners; disable was 0.899x/48%).
+ * - x86_64: DISABLE — fresh CI VMs have free pages and cheaper
+ *   page faults than minor GCs (0.911-0.922x vs none's 1.06-1.20x).
+ * The mechanism cuts both ways under load: disable's +478 pages/50
+ * iters is exactly what a LOADED x86 box punishes — set
+ * YEPTRIS_NATIVE_GC=none there (documented in README). */
+#if defined(__aarch64__) || defined(__arm__) || defined(__ARMEL__) || defined(_M_ARM64)
+#define YEP_GC_DEFAULT YEP_GC_NONE
+#else
+#define YEP_GC_DEFAULT YEP_GC_DISABLE
+#endif
+static int yep_gc_mode = YEP_GC_DEFAULT;
+
+int yep_rb_gc_mode(void) { return yep_gc_mode; }
+int yep_rb_ins_mode(void) { return yep_ins_mode; }
+void yep_rb_set_ins_mode(int mode) {
+    if (mode == YEP_INS_BULK || mode == YEP_INS_ASET) yep_ins_mode = mode;
+}
+void yep_rb_set_gc_mode(int mode) {
+    if (mode >= YEP_GC_DISABLE && mode <= YEP_GC_START) {
+        yep_gc_mode = mode;
+    }
+}
+
 VALUE yep_rb_parse_json(const char* p, size_t len) {
     jr j;
     memset(&j, 0, sizeof(j));
     j.p = p; j.len = len; j.enc = rb_utf8_encoding();
-    VALUE already = rb_gc_disable();
+    VALUE already = Qtrue;
+    if (yep_gc_mode != YEP_GC_NONE) already = rb_gc_disable();
     VALUE v = jr_value(&j);
     jr_ws(&j);
     if (j.i != len && j.err == 0) j.err = -2;
     free(j.scratch);
     if (already == Qfalse) rb_gc_enable();
+    if (yep_gc_mode == YEP_GC_START && j.err == 0) rb_gc_start();
     if (j.err == -1) rb_raise(rb_eNoMemError, "yeptris native json");
     if (j.err != 0) rb_raise(rb_path2class("Yeptris::ParseError"), "native json parse failed");
     return v;

data/ext/yeptris_native/yeptris_native.c

@@ -322,6 +322,49 @@ static VALUE native_load_stream(VALUE self, VALUE input, VALUE schema) {
     return ctx_result(&s.inner, st == YEPTRIS_OK ? YEPTRIS_ERROR_INTERNAL : st);
 }
 
+/* GC-strategy surface (TODO.restructure/34): ENV at load sets the
+ * default; the setter re-picks at runtime so the CI referee can A/B
+ * in-process. Symbols: :disable, :none, :start. */
+extern int yep_rb_gc_mode(void);
+extern void yep_rb_set_gc_mode(int mode);
+extern int yep_rb_ins_mode(void);
+extern void yep_rb_set_ins_mode(int mode);
+
+static VALUE native_gc_mode(VALUE self) {
+    (void)self;
+    switch (yep_rb_gc_mode()) {
+    case 1: return ID2SYM(rb_intern("none"));
+    case 2: return ID2SYM(rb_intern("start"));
+    default: return ID2SYM(rb_intern("disable"));
+    }
+}
+
+static VALUE native_ins_mode(VALUE self) {
+    (void)self;
+    return yep_rb_ins_mode() == 1 ? ID2SYM(rb_intern("aset")) : ID2SYM(rb_intern("bulk"));
+}
+
+static VALUE native_ins_mode_set(VALUE self, VALUE mode) {
+    (void)self;
+    Check_Type(mode, T_SYMBOL);
+    ID id = rb_sym2id(mode);
+    if (id == rb_intern("bulk")) yep_rb_set_ins_mode(0);
+    else if (id == rb_intern("aset")) yep_rb_set_ins_mode(1);
+    else rb_raise(rb_eArgError, "ins_mode must be :bulk or :aset");
+    return mode;
+}
+
+static VALUE native_gc_mode_set(VALUE self, VALUE mode) {
+    (void)self;
+    Check_Type(mode, T_SYMBOL);
+    ID id = rb_sym2id(mode);
+    if (id == rb_intern("disable")) yep_rb_set_gc_mode(0);
+    else if (id == rb_intern("none")) yep_rb_set_gc_mode(1);
+    else if (id == rb_intern("start")) yep_rb_set_gc_mode(2);
+    else rb_raise(rb_eArgError, "gc_mode must be :disable, :none, or :start");
+    return mode;
+}
+
 RUBY_FUNC_EXPORTED void Init_native(void) {
     utf8_enc = rb_utf8_encoding();
     VALUE mYep = rb_define_module("Yeptris");
@@ -329,5 +372,15 @@ RUBY_FUNC_EXPORTED void Init_native(void) {
     rb_define_singleton_method(mNat, "load_json", native_load_json, 1);
     rb_define_singleton_method(mNat, "load", native_load, 2);
     rb_define_singleton_method(mNat, "load_stream", native_load_stream, 2);
+    rb_define_singleton_method(mNat, "gc_mode", native_gc_mode, 0);
+    rb_define_singleton_method(mNat, "gc_mode=", native_gc_mode_set, 1);
+    rb_define_singleton_method(mNat, "ins_mode", native_ins_mode, 0);
+    rb_define_singleton_method(mNat, "ins_mode=", native_ins_mode_set, 1);
     rb_define_const(mNat, "AVAILABLE", Qtrue);
+    const char* env = getenv("YEPTRIS_NATIVE_GC");
+    if (env != NULL && strcmp(env, "none") == 0) yep_rb_set_gc_mode(1);
+    else if (env != NULL && strcmp(env, "start") == 0) yep_rb_set_gc_mode(2);
+    else if (env != NULL && strcmp(env, "disable") == 0) yep_rb_set_gc_mode(0);
+    const char* ins = getenv("YEPTRIS_NATIVE_INSERT");
+    if (ins != NULL && strcmp(ins, "aset") == 0) yep_rb_set_ins_mode(1);
 }

data/lib/yeptris.rb

@@ -3,7 +3,7 @@
 module Yeptris
   # The gem's version lives in the parent namespace's file — the last
   # internal require (yeptris/version) retired with it.
-  VERSION = "0.1.13.0".freeze
+  VERSION = "0.1.13.1".freeze
   # The error hierarchy lives in THIS file (the parent namespace's
   # own file): nested constants do not trigger a parent-constant
   # autoload, and the law forbids internal requires — defining the

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeptris
 version: !ruby/object:Gem::Version
-  version: 0.1.13.0
+  version: 0.1.13.1
 platform: ruby
 authors:
 - Ribose Inc.