yeptris 0.1.13.1 → 0.1.13.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17b1311c9327a9986b7bb89f3731fd40ca040c49336fdb97596951fbf87ed1c0
-  data.tar.gz: 6c1b2f707d15d469963ffc0ee030fc90287a5e01954d7431996f24765bddf9e3
+  metadata.gz: dfe67fff242e1aeaa61b4faed0633a90f4b2de0c70b630e733ae557a467cae2e
+  data.tar.gz: e8755921e9b5b8fe78c5db36a24727fee8d61e4742d56aa70ca939e13091034c
 SHA512:
-  metadata.gz: b04ca9a9d899c00207d8cf09ab1d1aa071c1cc63f2adab17cf87453d0a0646fc84c9df9f3e80f245bbc977a32e67feb7f25e2b562293a59adc102764b80507dc
-  data.tar.gz: 25c9033573e619dc69924f4ae15c102b650efdbf7d39c1dcc4d3d73243d1d0ac3037750c7b28b5e6d28562175296fd4b125e39253f4ab9c9ed799529d7fcb4ee
+  metadata.gz: 1f0443a1150f595e94eb6cf59afca9fd182a2ea269f2ca3a784260efb5d3cb1174325f48d056b06edaf50f2b30d4f90f641c90beebe456d0a862918b9edbdfe0
+  data.tar.gz: 0daf1afec8df455dd2bf72353b694f54003f6c3cbfbf1aa4dbf571c84083029362e0abeee5318f3fc22713199b9221650ac8bab1ca1705e39a0bab3a8f7d8467

data/README.adoc

@@ -72,9 +72,9 @@ fastest first:
 +
 ....
 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)
+interleave, N=200; prefix-hashed token cache):
+  ubuntu (x86_64)   mean 0.745x  vs JSON.parse, 200/200 head-to-head
+  macos  (arm64)    mean 0.759x  vs JSON.parse, 169/200 head-to-head
 ....
 
 The parse-window GC strategy is per-arch and runtime-switchable:

data/ext/yeptris_native/extconf.rb

@@ -35,7 +35,11 @@ end
 abort "libyeptris not found (set YEPTRIS_LIB_PATH)" unless libdir
 
 $LIBPATH << libdir
-$LDFLAGS << " -Wl,-rpath,#{libdir}" if RUBY_PLATFORM =~ /linux|darwin/
+# Platform gems bake a RELATIVE rpath so the bundle finds the
+  # vendored libyeptris next to itself; absolute build-time paths
+  # would dangle on user machines.
+  rpath = ENV["YEPTRIS_RPATH"] || libdir
+  $LDFLAGS << " -Wl,-rpath,#{rpath}" if RUBY_PLATFORM =~ /linux|darwin/
 have_library("yeptris", "yep_json_string") or abort "yep_json_string not exported — rebuild libyeptris"
 have_library("yeptris", "yeptris_visit_json") or abort "yeptris_visit_json missing"
 

data/ext/yeptris_native/json_ruby.c

@@ -5,6 +5,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include "parse/scalars.h"
+#include <yeptris/visit.h>
 #include "scan/json.h"
 
 #define YEP_JR_MAX 1000
@@ -29,6 +30,7 @@ typedef struct {
 } jr;
 
 static VALUE jr_value(jr* j);
+static VALUE jr_object_body(jr* j, VALUE h_pre);
 
 static void jr_ws(jr* j) {
     while (j->i < j->len) {
@@ -38,15 +40,33 @@ static void jr_ws(jr* j) {
     }
 }
 
+/* Token-cache knob (TODO.restructure/37): off = fresh strings
+ * everywhere (JSON.parse's shape: every key pays its own aset
+ * hashing); on = interned keys/tokens (shared frozen VALUEs
+ * memoize their hash). The CI referee A/Bs the net sign per arch. */
+enum { YEP_CACHE_ON = 0, YEP_CACHE_OFF = 1 };
+static int yep_cache_mode = YEP_CACHE_ON;
+
+/* Allocation-shape knob (TODO.restructure/39): pre = capa(8) up
+ * front (forces heap buffers even for tiny arrays); natural =
+ * rb_ary_new() so 3-element arrays stay EMBEDDED in the RVALUE, and
+ * bulk-path hashes get exact capacity from the counted pairs. */
+enum { YEP_SHAPE_PRE = 0, YEP_SHAPE_NATURAL = 1 };
+static int yep_shape_mode = YEP_SHAPE_PRE;
+
 static uint64_t jr_hash(const char* sp, long sl) {
-    /* FNV-1a 64 — cheap, good enough for short keys */
-    uint64_t h = 14695981039346656037ull;
-    for (long i = 0; i < sl; i++) {
-        h ^= (unsigned char)sp[i];
-        h *= 1099511628211ull;
-    }
-    h ^= (uint64_t)sl;
-    return h;
+    /* 8-byte-prefix key (the leptris nametab trick): one safe load
+     * of min(8, len) bytes + a multiply mix. Replaced byte-wise FNV
+     * (~15-20ns per token on the cached path, ~15k tokens per
+     * reference-corpus parse - the x86 materialization cost the
+     * decomposition isolated, TODO.restructure/37/38). */
+    uint64_t k = 0;
+    uint64_t take = (uint64_t)sl < 8 ? (uint64_t)sl : 8;
+    memcpy(&k, sp, (size_t)take);
+    k ^= (uint64_t)sl * 0x9E3779B97F4A7C15ull;
+    k *= 0xC2B2AE3D27D4EB4Full;
+    k ^= k >> 29;
+    return k;
 }
 
 static VALUE jr_cached(jr* j, const char* sp, long sl) {
@@ -86,7 +106,7 @@ static VALUE jr_str(jr* j, int as_key) {
         sp = j->p + start + 1;
         sl = (long)(close - start - 1);
     }
-    if (as_key || sl <= 24) return jr_cached(j, sp, sl);
+    if (yep_cache_mode == YEP_CACHE_ON && (as_key || sl <= 24)) return jr_cached(j, sp, sl);
     return rb_enc_str_new(sp, sl, j->enc);
 }
 
@@ -128,9 +148,20 @@ 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);
+    if (yep_shape_mode == YEP_SHAPE_PRE) {
+        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; }
+        return jr_object_body(j, h);
+    }
     jr_ws(j);
-    if (j->i < j->len && j->p[j->i] == '}') { j->i++; j->depth--; return h; }
+    if (j->i < j->len && j->p[j->i] == '}') { j->i++; j->depth--; return rb_hash_new(); }
+    return jr_object_body(j, Qundef); /* created post-loop with exact capa */
+
+    /* NOTREACHED */
+}
+
+static VALUE jr_object_body(jr* j, VALUE h_pre) {
     VALUE pairs[64];
     VALUE* pv = pairs;
     size_t pcap = 64, pn = 0, heap_cap = 0;
@@ -145,7 +176,7 @@ static VALUE jr_object(jr* j) {
         VALUE val = jr_value(j);
         if (j->err) goto out;
         if (yep_ins_mode == YEP_INS_ASET) {
-            rb_hash_aset(h, key, val);
+            rb_hash_aset(h_pre == Qundef ? (h_pre = rb_hash_new_capa(8)) : h_pre, key, val);
         } else {
             if (pn + 2 > pcap) {
                 size_t ncap = pcap * 2;
@@ -165,18 +196,23 @@ static VALUE jr_object(jr* j) {
         j->err = -2; goto out;
     }
     if (yep_ins_mode == YEP_INS_BULK) {
+        VALUE h = (h_pre == Qundef) ? rb_hash_new_capa((long)(pn / 2)) : h_pre;
         rb_hash_bulk_insert((long)pn, (const VALUE*)pv, h);
+        if (pv != pairs) { free(pv); }
+        j->depth--;
+        return h;
     }
+    if (h_pre == Qundef) { h_pre = rb_hash_new_capa(8); }
 out:
     if (pv != pairs) { free(pv); (void)heap_cap; }
     if (j->err) return Qnil;
     j->depth--;
-    return h;
+    return h_pre;
 }
 
 static VALUE jr_array(jr* j) {
     j->i++; j->depth++;
-    VALUE a = rb_ary_new_capa(8);
+    VALUE a = (yep_shape_mode == YEP_SHAPE_NATURAL) ? rb_ary_new() : rb_ary_new_capa(8);
     jr_ws(j);
     if (j->i < j->len && j->p[j->i] == ']') { j->i++; j->depth--; return a; }
     for (;;) {
@@ -244,6 +280,14 @@ 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; }
+int yep_rb_cache_mode(void) { return yep_cache_mode; }
+int yep_rb_shape_mode(void) { return yep_shape_mode; }
+void yep_rb_set_shape_mode(int mode) {
+    if (mode == YEP_SHAPE_PRE || mode == YEP_SHAPE_NATURAL) yep_shape_mode = mode;
+}
+void yep_rb_set_cache_mode(int mode) {
+    if (mode == YEP_CACHE_ON || mode == YEP_CACHE_OFF) yep_cache_mode = mode;
+}
 void yep_rb_set_ins_mode(int mode) {
     if (mode == YEP_INS_BULK || mode == YEP_INS_ASET) yep_ins_mode = mode;
 }
@@ -253,6 +297,21 @@ void yep_rb_set_gc_mode(int mode) {
     }
 }
 
+/* Pure grammar walk, no materialization (TODO.restructure/37): the
+ * same scan kernels through the null vtable. Decomposes scan vs
+ * materialize cost. Returns seconds for n iterations. */
+#include <time.h>
+double yep_rb_scan_time(const char* p, size_t len, int n) {
+    static const YeptrisVisitVTable none = {0};
+    struct timespec t0, t1;
+    clock_gettime(CLOCK_MONOTONIC, &t0);
+    for (int i = 0; i < n; i++) {
+        (void)yeptris_visit_json(p, len, &none, NULL);
+    }
+    clock_gettime(CLOCK_MONOTONIC, &t1);
+    return (double)(t1.tv_sec - t0.tv_sec) + (double)(t1.tv_nsec - t0.tv_nsec) / 1e9;
+}
+
 VALUE yep_rb_parse_json(const char* p, size_t len) {
     jr j;
     memset(&j, 0, sizeof(j));

data/ext/yeptris_native/yeptris_native.c

@@ -329,6 +329,11 @@ 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);
+extern int yep_rb_cache_mode(void);
+extern void yep_rb_set_cache_mode(int mode);
+extern int yep_rb_shape_mode(void);
+extern void yep_rb_set_shape_mode(int mode);
+extern double yep_rb_scan_time(const char* p, size_t len, int n);
 
 static VALUE native_gc_mode(VALUE self) {
     (void)self;
@@ -354,6 +359,44 @@ static VALUE native_ins_mode_set(VALUE self, VALUE mode) {
     return mode;
 }
 
+static VALUE native_cache_mode(VALUE self) {
+    (void)self;
+    return yep_rb_cache_mode() == 1 ? ID2SYM(rb_intern("off")) : ID2SYM(rb_intern("on"));
+}
+
+static VALUE native_cache_mode_set(VALUE self, VALUE mode) {
+    (void)self;
+    Check_Type(mode, T_SYMBOL);
+    ID id = rb_sym2id(mode);
+    if (id == rb_intern("on")) yep_rb_set_cache_mode(0);
+    else if (id == rb_intern("off")) yep_rb_set_cache_mode(1);
+    else rb_raise(rb_eArgError, "cache_mode must be :on or :off");
+    return mode;
+}
+
+static VALUE native_scan_time(VALUE self, VALUE input, VALUE count) {
+    (void)self;
+    StringValue(input);
+    int n = NUM2INT(count);
+    double secs = yep_rb_scan_time(RSTRING_PTR(input), (size_t)RSTRING_LEN(input), n);
+    return DBL2NUM(secs / (double)n);
+}
+
+static VALUE native_shape_mode(VALUE self) {
+    (void)self;
+    return yep_rb_shape_mode() == 1 ? ID2SYM(rb_intern("natural")) : ID2SYM(rb_intern("pre"));
+}
+
+static VALUE native_shape_mode_set(VALUE self, VALUE mode) {
+    (void)self;
+    Check_Type(mode, T_SYMBOL);
+    ID id = rb_sym2id(mode);
+    if (id == rb_intern("pre")) yep_rb_set_shape_mode(0);
+    else if (id == rb_intern("natural")) yep_rb_set_shape_mode(1);
+    else rb_raise(rb_eArgError, "shape_mode must be :pre or :natural");
+    return mode;
+}
+
 static VALUE native_gc_mode_set(VALUE self, VALUE mode) {
     (void)self;
     Check_Type(mode, T_SYMBOL);
@@ -376,6 +419,11 @@ RUBY_FUNC_EXPORTED void Init_native(void) {
     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_singleton_method(mNat, "cache_mode", native_cache_mode, 0);
+    rb_define_singleton_method(mNat, "cache_mode=", native_cache_mode_set, 1);
+    rb_define_singleton_method(mNat, "shape_mode", native_shape_mode, 0);
+    rb_define_singleton_method(mNat, "shape_mode=", native_shape_mode_set, 1);
+    rb_define_singleton_method(mNat, "scan_time", native_scan_time, 2);
     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);
@@ -383,4 +431,8 @@ RUBY_FUNC_EXPORTED void Init_native(void) {
     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);
+    const char* cache = getenv("YEPTRIS_NATIVE_CACHE");
+    if (cache != NULL && strcmp(cache, "off") == 0) yep_rb_set_cache_mode(1);
+    const char* shape = getenv("YEPTRIS_NATIVE_SHAPE");
+    if (shape != NULL && strcmp(shape, "natural") == 0) yep_rb_set_shape_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.1".freeze
+  VERSION = "0.1.13.3".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.1
+  version: 0.1.13.3
 platform: ruby
 authors:
 - Ribose Inc.