teptris 0.2.46-powerpc64le-linux → 0.2.48-powerpc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71c630c73569f644a50a04114db4f358cf08c2711a1b92bf584e36f5f506c417
-  data.tar.gz: 3cf2c459a6a0cf3dc1dc1c32b2afaf5cbecf0ed9ecdc9777a921f8f45ac6d64e
+  metadata.gz: 6ab5c640ceac5cbe96addaf083d40607a834e3ffbf93063cf95085c4a7b19fe9
+  data.tar.gz: fc71dd53f489b7b47ff550b07a4039e8bd5fe7a79fd192bde0a8690dda37a415
 SHA512:
-  metadata.gz: 14d6540302e2ce77fdd787234ae9e64af792fa86cbd4d0d37d18d8c875c59f339c2869885b03fa67c51bab4b8f1d261f8860488cab5c7e29e2e8ed7287188020
-  data.tar.gz: c5b26705f69016eef8c91a1636e727ba06105d411cd48114aa0f136c36acaba8d0f704b8e6cf68b509cfea50ab854ea6202fd46b4e894681390b88d703ffadfb
+  metadata.gz: 1545f3eeaaf6d7ec37bb5f8e31c6143cf5193c0f7ae9747284f2dbc9ebe2071113cb44a3bfb84d64fe331bb4a52f361581d4f04ae4b25547b0c8ced922f0a177
+  data.tar.gz: 1181e760f9351324f8edf9bae816d8f8b5626735c222e1d81dfa86d2eb9135ee018d8065d5d778acc9b009891c560a0310008575ac3e0ec52122dfa7ce8b95f4

data/ext/teptris_ext/materialize.c

@@ -21,18 +21,25 @@ static int64_t days_from_civil(int32_t y, uint8_t m, uint8_t d) {
 }
 
 /* exact (no double) Time materialization: nsec stays nsec. Offset
- * datetimes go through timespec+fixed-offset; local datetimes through
- * Time.local with Rational seconds (rb_time_timespec_new's INT_MAX
- * treats the timespec as an absolute instant, not wall-clock local). */
+ * datetimes carry a fixed utc offset via rb_time_num_new; local
+ * datetimes go through Time.local with Rational seconds (both treat
+ * the epoch value as wall-clock for locals / instant+offset for
+ * fixed zones). No struct timespec crosses the Ruby boundary:
+ * armhf glibc rubies build with _TIME_BITS=64 (16-byte timespec)
+ * while an ext compiled without it lays out 8 bytes — the struct
+ * APIs then read (load) or write (dump) past each side's layout. */
 static VALUE time_from_dt(const teptris_datetime *d, bool has_offset) {
     if (has_offset) {
         int64_t days = days_from_civil(d->year, d->month, d->day);
         int64_t secs =
             days * 86400 + d->hour * 3600 + d->minute * 60 + d->second;
-        struct timespec ts;
-        ts.tv_sec = (time_t)(secs - d->offset_seconds);
-        ts.tv_nsec = (long)d->nanosecond;
-        return rb_time_timespec_new(&ts, d->offset_seconds);
+        VALUE num = LL2NUM(secs - d->offset_seconds);
+        if (d->nanosecond != 0) {
+            num = rb_funcall(num, '+', 1,
+                             rb_Rational(LL2NUM((int64_t)d->nanosecond),
+                                         LL2NUM(1000000000)));
+        }
+        return rb_time_num_new(num, INT2FIX(d->offset_seconds));
     }
     VALUE args[6] = {INT2FIX(d->year), INT2FIX(d->month), INT2FIX(d->day),
                      INT2FIX(d->hour), INT2FIX(d->minute),
@@ -82,7 +89,87 @@ static VALUE dt_string(const teptris_datetime *d, int kind) {
     return rb_enc_str_new(buf, l, rb_utf8_encoding());
 }
 
-static VALUE obj_from_node(const teptris_node *n, unsigned flags) {
+/* ---- per-load table-key cache ------------------------------------------------
+ * TOML keys repeat within a document and across a batch; a fresh String
+ * per occurrence costs an allocation and a full Hash re-hash each time.
+ * This cache maps key CONTENT to one frozen String, shared everywhere:
+ * repeated keys become a single GC-pinned object with its hash already
+ * computed. It is document-local (dies with the load call), capped at
+ * KC_CAP entries so unique-key corpora pay only a cheap failed probe
+ * after the cap, and never touches the VM's global fstring table (the
+ * intern-always attempt regressed there — teptris-ruby#122: unique
+ * keys make the intern table pure overhead). Strings are frozen so the
+ * sharing cannot alias a mutation. NULL cache = fresh strings (the
+ * low-volume schema-RAW path). */
+
+#define KC_CAP 4096
+#define KC_SLOTS (KC_CAP * 2) /* stays <=50% full: probes stay ~2 */
+
+typedef struct {
+    VALUE str; /* Qfalse = empty slot */
+} kc_slot;
+
+typedef struct {
+    VALUE keep; /* Ruby Array pinning every cached String */
+    kc_slot *slots;
+    size_t used;
+} keycache;
+
+static uint64_t kc_hash(const char *p, size_t len)
+{
+    uint64_t h = 1469598103934665603ULL;
+    for (size_t i = 0; i < len; i++) {
+        h ^= (unsigned char)p[i];
+        h *= 1099511628211ULL;
+    }
+    return h;
+}
+
+static void kc_init(keycache *kc)
+{
+    kc->keep = rb_ary_new_capa(64);
+    kc->slots = calloc(KC_SLOTS, sizeof(kc_slot)); /* zero = Qfalse empty */
+    if (kc->slots == NULL) {
+        /* no cache is a correctness-preserving fallback */
+        kc->keep = Qnil;
+        return;
+    }
+    kc->used = 0;
+}
+
+static void kc_free(keycache *kc)
+{
+    free(kc->slots);
+    kc->slots = NULL;
+}
+
+static VALUE kc_key(keycache *kc, const char *p, size_t len)
+{
+    if (kc == NULL || kc->slots == NULL) {
+        return rb_enc_str_new(p, (long)len, rb_utf8_encoding());
+    }
+    size_t mask = KC_SLOTS - 1;
+    size_t slot = (size_t)kc_hash(p, len) & mask;
+    while (kc->slots[slot].str != Qfalse) {
+        VALUE s = kc->slots[slot].str;
+        if ((size_t)RSTRING_LEN(s) == len &&
+            memcmp(RSTRING_PTR(s), p, len) == 0) {
+            return s; /* hit: one shared object, hash already cached */
+        }
+        slot = (slot + 1) & mask;
+    }
+    VALUE fresh = rb_enc_str_new(p, (long)len, rb_utf8_encoding());
+    rb_obj_freeze(fresh);
+    rb_ary_push(kc->keep, fresh); /* GC pin before it enters the slots */
+    if (kc->used < KC_CAP) {
+        kc->slots[slot].str = fresh;
+        kc->used++;
+    }
+    return fresh;
+}
+
+static VALUE obj_from_node(const teptris_node *n, unsigned flags,
+                           keycache *kc) {
     switch (teptris_node_kind(n)) {
     case TEPTRIS_TABLE: {
         size_t len = teptris_node_table_length(n);
@@ -90,9 +177,8 @@ static VALUE obj_from_node(const teptris_node *n, unsigned flags) {
         for (size_t i = 0; i < len; i++) {
             teptris_view key;
             const teptris_node *v = teptris_node_table_at(n, i, &key);
-            rb_hash_aset(h,
-                rb_enc_str_new(key.ptr, (long)key.len, rb_utf8_encoding()),
-                obj_from_node(v, flags));
+            rb_hash_aset(h, kc_key(kc, key.ptr, (size_t)key.len),
+                         obj_from_node(v, flags, kc));
         }
         return h;
     }
@@ -100,7 +186,7 @@ static VALUE obj_from_node(const teptris_node *n, unsigned flags) {
         size_t len = teptris_node_array_length(n);
         VALUE a = rb_ary_new_capa((long)len);
         for (size_t i = 0; i < len; i++)
-            rb_ary_push(a, obj_from_node(teptris_node_array_at(n, i), flags));
+            rb_ary_push(a, obj_from_node(teptris_node_array_at(n, i), flags, kc));
         return a;
     }
     case TEPTRIS_STRING: {
@@ -169,7 +255,10 @@ static VALUE ext_load(int argc, VALUE *argv, VALUE self) {
         if (RTEST(fd)) flags |= FMT_FORBID_DATE;
     }
     teptris_document *doc = parse_or_raise(str);
-    VALUE out = obj_from_node(teptris_document_root(doc), flags);
+    keycache kc;
+    kc_init(&kc);
+    VALUE out = obj_from_node(teptris_document_root(doc), flags, &kc);
+    kc_free(&kc);
     teptris_document_free(doc);
     return out;
 }
@@ -180,7 +269,7 @@ static VALUE ext_version(VALUE self) {
 
 /* ------------------------------------------------------------------ dump */
 
-static ID id_utc_offset, id_to_s;
+static ID id_utc_offset, id_to_s, id_to_i, id_nsec;
 
 static void dump_check(teptris_status st) {
     if (st == TEPTRIS_OK) return;
@@ -206,12 +295,12 @@ static void civil_from_days(int64_t z, int32_t *y, uint8_t *m, uint8_t *d) {
     *d = (uint8_t)dd;
 }
 
-/* two crossings per Time: timespec + utc_offset; the civil fields come
- * from integer math (epoch + offset -> y/m/d h:m:s + tv_nsec) */
+/* the instant and its subsecond part come back as Integers (to_i
+ * floors, nsec stays in [0, 1e9) — same split the timespec gave);
+ * the civil fields are integer math on epoch + offset */
 static void fill_dt_from_time(VALUE v, teptris_datetime *dt) {
-    struct timespec ts = rb_time_timespec(v);
     dt->offset_seconds = NUM2INT(rb_funcall(v, id_utc_offset, 0));
-    int64_t secs = (int64_t)ts.tv_sec + dt->offset_seconds;
+    int64_t secs = NUM2LL(rb_funcall(v, id_to_i, 0)) + dt->offset_seconds;
     int64_t days = secs / 86400;
     int32_t rem = (int32_t)(secs % 86400);
     if (rem < 0) { /* floor division: keep rem in [0, 86400) */
@@ -222,7 +311,7 @@ static void fill_dt_from_time(VALUE v, teptris_datetime *dt) {
     dt->hour = (uint8_t)(rem / 3600);
     dt->minute = (uint8_t)((rem / 60) % 60);
     dt->second = (uint8_t)(rem % 60);
-    dt->nanosecond = (uint32_t)ts.tv_nsec;
+    dt->nanosecond = (uint32_t)NUM2LL(rb_funcall(v, id_nsec, 0));
 }
 
 static void dump_scalar(teptris_builder *b, const char *key, size_t klen,
@@ -519,7 +608,7 @@ static VALUE asm_rows(const teptris_plan *p, const teptris_plan_result *res,
         case TEPTRIS_PLAN_RAW_RESULT: {
             const teptris_node *raw = teptris_plan_result_raw_at(res, i);
             if (raw != NULL) {
-                val = obj_from_node(raw, 0);
+                val = obj_from_node(raw, 0, NULL);
             }
             break;
         }
@@ -773,7 +862,11 @@ static VALUE lazy_dig(int argc, VALUE *argv, VALUE self) {
 /* full materialization: the eager path, owned */
 static VALUE lazy_to(VALUE self) {
     lazy_value *v = lazy_self(self);
-    return obj_from_node(v->node, 0);
+    keycache kc;
+    kc_init(&kc);
+    VALUE out = obj_from_node(v->node, 0, &kc);
+    kc_free(&kc);
+    return out;
 }
 
 /* ---------------------------------------------------------------- batch --
@@ -929,11 +1022,14 @@ static VALUE ext_load_batch(int argc, VALUE *argv, VALUE self) {
         rb_exc_raise(ex);
     }
     VALUE out = rb_ary_new_capa(n);
+    keycache kc;
+    kc_init(&kc); /* one cache across the batch: keys repeat across docs */
     for (long i = 0; i < n; i++) {
         const teptris_node *root = teptris_document_root(s->docs[i]);
-        rb_ary_store(out, i, obj_from_node(root, flags));
+        rb_ary_store(out, i, obj_from_node(root, flags, &kc));
         teptris_document_free(s->docs[i]);
     }
+    kc_free(&kc);
     batch_scratch_free(s);
     return out;
 }
@@ -967,4 +1063,6 @@ void Init_teptris_ext(void) {
     cDate = rb_const_get(rb_cObject, rb_intern("Date"));
     id_utc_offset = rb_intern("utc_offset");
     id_to_s = rb_intern("to_s");
+    id_to_i = rb_intern("to_i");
+    id_nsec = rb_intern("nsec");
 }

data/lib/teptris/version.rb

@@ -1,3 +1,3 @@
 module Teptris
-  VERSION = "0.2.46"
+  VERSION = "0.2.48"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teptris
 version: !ruby/object:Gem::Version
-  version: 0.2.46
+  version: 0.2.48
 platform: powerpc64le-linux
 authors:
 - teptris contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-23 00:00:00.000000000 Z
+date: 2026-09-26 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.