leptris 1.9.386.0-ppc64le-linux → 1.9.388.0-ppc64le-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 693b3140d5bc11495cb1fe2569a09502e30a93ffbd0174352428f5fa8db73843
-  data.tar.gz: b68d2e270256b7d92056189a417100fd01c0d71982e6f69a81b9f83cfeac8495
+  metadata.gz: 238b6117d6d53b2e74db8530678f08b444e405ed9569cc0d5c794bc1539de2db
+  data.tar.gz: 6e3a5e2de83a00123bc4ea19fd4818526809f05248b41e0aa6d7a9d9532d71a2
 SHA512:
-  metadata.gz: 526a5ff1640e8adc2c107e0f5289e388eb9cd236fe6c47d8bc54c57a9e0bbf31dde18e0ed3d03ce9a8301f004cb51fef481d9c3b4bb820d9da418b338c96eed2
-  data.tar.gz: 6b0e71839d07aa3734bff6c110da078a7cfa597404bb891e14590756b230928a6058968d265bf6af1c30a24ec34ec01a588a703830d036a23b288de9d897d2a0
+  metadata.gz: ae6c2a635dce0825ae7f0d85ecfaf343a912f551ce7a88e62f5686de2dbfa1ed736aa8c512a3c33ffa3ab236de554ff1ac7ecc316d419cda9bf2e7ec6c68db91
+  data.tar.gz: d96b043f56180f0fc6c79a9a25c1678d1161d099b544ed0ba4ebfa5a220fec998b287b591d6535305d3a42b5bb7eada48576f0276ea930b4cfc5db4313589da5

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+### Changed — 1.9.388.0 (rides libleptris 1.9.388)
+
+- Engine pin 1.9.386 -> 1.9.388: carries the one-pass text-run scan
+  (leptris/leptris#1895, #1842 — text shapes 764-804 -> 1370-1448 MB/s,
+  pugixml gap 2.9x -> 1.70x) and the arena retain-pool size-class split
+  (leptris/leptris#1893, #1846), plus the 1.9.387 wave (ns-declaration
+  snapshot, packed op-blob build, children_batch + name_compare,
+  XSD skip-wildcards / attributeGroup order / length facets / builtin
+  lexical table / schema-set compile_set / anyType default — the
+  schema-set faces this pin un-gates in spec/xml/xsd_spec.rb).
+
 ### Added — 1.9.382.0 (rides libleptris 1.9.382)
 
 - **Schema#version** (moxml#460 item 2): the effective schema

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.387"
+LIBLEPTRIS_VERSION = "1.9.388"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.386.0"
+  VERSION = "1.9.388.0"
 end

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.387
+- libleptris v1.9.388
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,33 @@
 ## [Unreleased]
 
+## [1.9.388] - 2026-10-29
+
+### Fixed
+
+- **Arena retain pool split by size class (leptris#1893, leptris#1846).**
+  Mid-sized spans (256 KB - 2 MB) could evict all four large-span retain
+  slots, so mixed-traffic workloads lost their warm large spans and
+  re-faulted them every parse. The retain pool is now two tiers (mid /
+  large at the 2 MB boundary) under the same shared ceiling, and a
+  pointer-identity test pins same-size reuse across mixed traffic.
+
+### Performance
+
+- **One-pass text-run scan (leptris#1895, leptris#1842).** The direct
+  parser's text path found `<` with a byte-at-a-time inline loop over
+  the first 48 bytes, then paid up to three libc memchr calls per run
+  (`<`, `&`, CR) — about 90ns of scan per ~55-byte run, capping
+  text-heavy documents near 800 MB/s while pugixml ran one vectorized
+  pass (profile: 72% of parse samples in the inline loop, 9% in the
+  three memchr sites). The new `leptris_text_scan_run` kernel (scalar +
+  NEON + AVX2, dispatched like the other simd_text primitives) finds
+  the first `<` and flags `&`/CR over the prefix in a single memory
+  pass; the recover-mode unescaped-`<` re-scan uses the same kernel.
+  Text shapes: 764-804 → 1370-1448 MB/s; gap vs pugixml 2.9x → 1.70x
+  (1.30x at 5 MB). Attr shapes unchanged.
+
+
+
 ## [1.9.387] - 2026-10-28
 
 ### Added

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.387
+    VERSION 1.9.388
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/benchmarks/parse/arena_ab.sh

@@ -0,0 +1,40 @@
+#!/bin/sh
+# arena_ab.sh — interleaved A/B for parse-arena sizing changes
+# (leptris#1846 discipline: same-process-pair, order-alternating,
+# median of per-pair ratios — cross-wave deltas are NOT a valid
+# referee, the 2026-10-25 wave swung both directions at noise
+# magnitude).
+#
+# Usage: arena_ab.sh <base-build-dir> <patch-build-dir> <fixture> [pairs]
+# Both build dirs must contain benchmarks/parse_ab (the file-mode
+# bench_parse_ab). Each pair runs BASE then PATCH, then PATCH then
+# BASE (ABBA), so thermal/load drift cancels; the reported number is
+# the median of patch/base MB/s ratios.
+set -e
+BASE=$(ls "$1"/benchmarks/parse_ab "$1"/benchmarks/bench_parse_ab 2>/dev/null | head -1)
+PATCH=$(ls "$2"/benchmarks/parse_ab "$2"/benchmarks/bench_parse_ab 2>/dev/null | head -1)
+FIX="$3"
+N="${4:-10}"
+if [ -z "$BASE" ] || [ -z "$PATCH" ] || [ -z "$FIX" ]; then
+    echo "usage: $0 <base-build-dir> <patch-build-dir> <fixture> [pairs]" >&2
+    exit 1
+fi
+run_one() {
+    "$1" "$FIX" | awk '{print $4}'
+}
+ratios=""
+i=0
+while [ "$i" -lt "$N" ]; do
+    a=$(run_one "$BASE"); b=$(run_one "$PATCH")
+    b2=$(run_one "$PATCH"); a2=$(run_one "$BASE")
+    ratios="$ratios
+$(echo "$b $a" | awk '{printf "%.4f", $1/$2}')
+$(echo "$b2 $a2" | awk '{printf "%.4f", $1/$2}')"
+    i=$((i + 1))
+done
+echo "$ratios" | sort -n | awk '
+    { v[NR] = $1 }
+    END {
+        m = (NR % 2) ? v[(NR + 1) / 2] : (v[NR / 2] + v[NR / 2 + 1]) / 2
+        printf "pairs=%d median patch/base = %.4fx\n", NR, m
+    }'

data/vendor-src/libleptris/benchmarks/parse/bench_parse_ab.cpp

@@ -5,6 +5,13 @@
  * runners; the interleaved lane's slices are gated on THESE
  * numbers, never a loaded dev machine (2026-09-20: a Mac at load
  * 340 measured a 472 MB/s build at 46-85).
+ *
+ * leptris#1846: `argv[1]` switches to file mode — parse+free one
+ * fixture in a loop (median of N in-process runs, best-of-5
+ * batches) and print one `FILE <path> <bytes> <MB/s>` row. The
+ * arena-sizing A/B runner (arena_ab.sh) interleaves two builds of
+ * this binary and takes the median of per-pair ratios, so runner
+ * load cannot fake or hide the effect.
  */
 #include <stdio.h>
 #include <stdlib.h>
@@ -22,6 +29,45 @@ static double now_us(void) {
     return ts.tv_sec * 1e6 + ts.tv_nsec / 1e3;
 }
 
+static int file_mode(const char* path) {
+    FILE* f = fopen(path, "rb");
+    if (!f) { fprintf(stderr, "cannot open %s\n", path); return 1; }
+    fseek(f, 0, SEEK_END);
+    long sz = ftell(f);
+    fseek(f, 0, SEEK_SET);
+    char* doc = (char*)malloc((size_t)sz);
+    if (!doc || fread(doc, 1, (size_t)sz, f) != (size_t)sz) {
+        fprintf(stderr, "cannot read %s\n", path);
+        fclose(f);
+        return 1;
+    }
+    fclose(f);
+    /* LEPTRIS_BENCH_ITERS: profiling escape hatch (sample(1) needs a
+     * long-running process, not a 10ms one). */
+    const char* iters_env = getenv("LEPTRIS_BENCH_ITERS");
+    int iters = iters_env ? atoi(iters_env) : 5;
+    double best = 1e18;
+    double sum = 0;
+    for (int r = 0; r < iters; r++) {
+        double a = now_us();
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisDocument d = leptris_parse_string(doc, (size_t)sz, &st);
+        double b = now_us();
+        if (!d) { printf("PARSE FAILED\n"); return 1; }
+        leptris_document_free(d);
+        if (b - a < best) best = b - a;
+        sum += b - a;
+    }
+    /* #1846: the MEAN prices in the cold parses (fresh span + full
+     * first-touch) that a best-of hides — the warm-span retention fix
+     * lives exactly there. */
+    printf("FILE %s %ld %.1f MB/s mean %.1f MB/s\n", path, sz,
+           sz / 1048576.0 / (best / 1e6),
+           sz / 1048576.0 / ((sum / (double)iters) / 1e6));
+    free(doc);
+    return 0;
+}
+
 static size_t gen(char* out, size_t target, int text_shape) {
     size_t len = 0;
     len += (size_t)sprintf(out + len, "<root>");
@@ -40,7 +86,8 @@ static size_t gen(char* out, size_t target, int text_shape) {
     return len;
 }
 
-int main(void) {
+int main(int argc, char** argv) {
+    if (argc > 1) return file_mode(argv[1]);
     const size_t sizes[3] = {1500 * 1024, 5000 * 1024, 13000 * 1024};
     const char* names[2] = {"attr", "text"};
     printf("%-6s %9s %12s %12s\n", "shape", "bytes", "leptris", "pugixml");

data/vendor-src/libleptris/src/leptris/common/simd_text.c

@@ -63,6 +63,29 @@ static void (*g_count3_high_fn)(const char*, size_t, char, char, char,
                                 int*) = NULL;
 static void (*g_copy3_fn)(char*, const char*, size_t, char, char, char,
                           size_t*, size_t*, size_t*) = NULL;
+static ptrdiff_t (*g_scan_run_fn)(const char*, size_t, char, char, char,
+                                  int*, int*) = NULL;
+
+/* #1842: one pass, three byte classes — the direct parser's text path
+ * (find '<', flag '&'/CR) drops its 48-byte inline loop and up to
+ * three per-run memchr calls for this. */
+static ptrdiff_t scan_run_scalar(const char* s, size_t len, char term,
+                                 char f1, char f2,
+                                 int* saw_f1, int* saw_f2) {
+    int a = 0, b = 0;
+    const char* p = s;
+    const char* end = s + len;
+    while (p < end) {
+        char ch = *p;
+        if (ch == term) break;
+        a |= (ch == f1);
+        b |= (ch == f2);
+        p++;
+    }
+    *saw_f1 = a;
+    *saw_f2 = b;
+    return (p < end) ? (ptrdiff_t)(p - s) : -1;
+}
 
 static size_t count_scalar(const char* s, size_t len, char c) {
     size_t n = 0;
@@ -108,6 +131,7 @@ static void dispatch_init(void) {
         g_find3_fn = leptris_text_find3_avx2;
         g_count_fn = leptris_text_count_char_avx2;
         g_count3_high_fn = count3_high_scalar;
+        g_scan_run_fn = leptris_text_scan_run_avx2;
         return;
     }
 #endif
@@ -119,6 +143,7 @@ static void dispatch_init(void) {
         g_count3_fn = leptris_text_count3_neon;
         g_count3_high_fn = leptris_text_count3_high_neon;
         g_copy3_fn = leptris_copy_count3_neon;
+        g_scan_run_fn = leptris_text_scan_run_neon;
         return;
     }
 #endif
@@ -127,6 +152,7 @@ static void dispatch_init(void) {
     g_find3_fn = find3_scalar;
     g_count_fn = count_scalar;
     g_count3_high_fn = count3_high_scalar;
+    g_scan_run_fn = scan_run_scalar;
 }
 
 /* Scalar kernel: one byte loop counts all three chars and detects
@@ -213,6 +239,13 @@ void leptris_copy_count3(char* dst, const char* src, size_t len,
     leptris_text_count3(src, len, c0, c1, c2, n0, n1, n2);
 }
 
+ptrdiff_t leptris_text_scan_run(const char* s, size_t len, char term,
+                                char f1, char f2,
+                                int* saw_f1, int* saw_f2) {
+    if (!g_scan_run_fn) dispatch_init();
+    return g_scan_run_fn(s, len, term, f1, f2, saw_f1, saw_f2);
+}
+
 /* ---- Structural span scan (TODO 193 Phase 1) ---- */
 
 unsigned char leptris_dp_class_table[256];

data/vendor-src/libleptris/src/leptris/common/simd_text.h

@@ -66,6 +66,17 @@ void leptris_copy_count3(char* dst, const char* src, size_t len,
                         char c0, char c1, char c2,
                         size_t* n0, size_t* n1, size_t* n2);
 
+/* One-pass text-run scan (#1842): find the first `term` byte in
+ * [s, s+len) and report whether f1/f2 occur strictly before it.
+ * Returns the term offset, or -1 when absent (flags then cover the
+ * whole span). saw_f1/saw_f2 are always written (0 or 1). Replaces
+ * the direct parser's 48-byte inline loop plus up to three per-run
+ * memchr calls with a single memory pass. term/f1/f2 must be
+ * distinct. */
+ptrdiff_t leptris_text_scan_run(const char* s, size_t len, char term,
+                                char f1, char f2,
+                                int* saw_f1, int* saw_f2);
+
 /* ---- Structural span scan (TODO 193 Phase 1: parser v3) ----
  *
  * Records every byte of the XML structural set in [buf, buf+len)
@@ -121,6 +132,12 @@ void leptris_copy_count3_neon(char* dst, const char* src, size_t len,
                               size_t* ca, size_t* cb, size_t* cc);
 size_t leptris_text_scan_events_neon(const char* buf, size_t len,
                                      LeptrisScanEvent* events, size_t max);
+ptrdiff_t leptris_text_scan_run_avx2(const char* s, size_t len, char term,
+                                     char f1, char f2,
+                                     int* saw_f1, int* saw_f2);
+ptrdiff_t leptris_text_scan_run_neon(const char* s, size_t len, char term,
+                                     char f1, char f2,
+                                     int* saw_f1, int* saw_f2);
 
 /* Append events for every structural byte to out (capacity max).
  * Returns the number of events written; returns max unchanged as

data/vendor-src/libleptris/src/leptris/common/simd_text_avx2.c

@@ -103,3 +103,53 @@ size_t leptris_text_count_char_avx2(const char* s, size_t len, char c) {
 }
 
 #endif /* LEPTRIS_ARCH_X86 && __AVX2__ */
+
+/* #1842: one-pass text-run scan — AVX2 mirror of the NEON kernel:
+ * full 32-byte chunks OR-accumulate the f1/f2 movemasks; the term
+ * mask hits and the first lane is ctz-resolved with a scalar prefix
+ * fold. */
+ptrdiff_t leptris_text_scan_run_avx2(const char* s, size_t len, char term,
+                                     char f1, char f2,
+                                     int* saw_f1, int* saw_f2) {
+    const char* p = s;
+    const char* end = s + len;
+    const __m256i kt = _mm256_set1_epi8(term);
+    const __m256i k1 = _mm256_set1_epi8(f1);
+    const __m256i k2 = _mm256_set1_epi8(f2);
+    uint32_t acc1 = 0, acc2 = 0;
+
+    while (end - p >= 32) {
+        __m256i v = _mm256_loadu_si256((const __m256i*)p);
+        uint32_t mt =
+            (uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v, kt));
+        if (mt) {
+            unsigned idx = (unsigned)LEPTRIS_CTZ(mt);
+            int a = (acc1 != 0);
+            int b = (acc2 != 0);
+            for (unsigned j = 0; j < idx; j++) {
+                a |= (p[j] == f1);
+                b |= (p[j] == f2);
+            }
+            *saw_f1 = a;
+            *saw_f2 = b;
+            return (ptrdiff_t)(p + idx - s);
+        }
+        acc1 |= (uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v, k1));
+        acc2 |= (uint32_t)_mm256_movemask_epi8(_mm256_cmpeq_epi8(v, k2));
+        p += 32;
+    }
+    {
+        int a = (acc1 != 0);
+        int b = (acc2 != 0);
+        while (p < end) {
+            char ch = *p;
+            if (ch == term) break;
+            a |= (ch == f1);
+            b |= (ch == f2);
+            p++;
+        }
+        *saw_f1 = a;
+        *saw_f2 = b;
+        return (p < end) ? (ptrdiff_t)(p - s) : -1;
+    }
+}

data/vendor-src/libleptris/src/leptris/common/simd_text_neon.c

@@ -328,3 +328,55 @@ size_t leptris_text_scan_events_neon(const char* buf, size_t len,
     }
     return n;
 }
+
+/* #1842: one-pass text-run scan — first `term` byte plus f1/f2
+ * seen-flags over the prefix. Full chunks OR-accumulate the f1/f2
+ * compare masks; a term hit resolves its lane scalar (once per run,
+ * at most 15 bytes of prefix re-check) and returns without folding
+ * the post-hit lanes. */
+ptrdiff_t leptris_text_scan_run_neon(const char* s, size_t len, char term,
+                                     char f1, char f2,
+                                     int* saw_f1, int* saw_f2) {
+    const char* p = s;
+    const char* end = s + len;
+    const uint8x16_t kt = vdupq_n_u8((uint8_t)term);
+    const uint8x16_t k1 = vdupq_n_u8((uint8_t)f1);
+    const uint8x16_t k2 = vdupq_n_u8((uint8_t)f2);
+    uint8x16_t acc1 = vdupq_n_u8(0);
+    uint8x16_t acc2 = vdupq_n_u8(0);
+
+    while (end - p >= 16) {
+        uint8x16_t v = vld1q_u8((const uint8_t*)p);
+        uint8x16_t eqt = vceqq_u8(v, kt);
+        if (vmaxvq_u8(eqt) != 0) {
+            int i = 0;
+            while (p[i] != term) i++;
+            int a = vmaxvq_u8(acc1) != 0;
+            int b = vmaxvq_u8(acc2) != 0;
+            for (int j = 0; j < i; j++) {
+                a |= (p[j] == f1);
+                b |= (p[j] == f2);
+            }
+            *saw_f1 = a;
+            *saw_f2 = b;
+            return (ptrdiff_t)(p + i - s);
+        }
+        acc1 = vorrq_u8(acc1, vceqq_u8(v, k1));
+        acc2 = vorrq_u8(acc2, vceqq_u8(v, k2));
+        p += 16;
+    }
+    {
+        int a = vmaxvq_u8(acc1) != 0;
+        int b = vmaxvq_u8(acc2) != 0;
+        while (p < end) {
+            char ch = *p;
+            if (ch == term) break;
+            a |= (ch == f1);
+            b |= (ch == f2);
+            p++;
+        }
+        *saw_f1 = a;
+        *saw_f2 = b;
+        return (p < end) ? (ptrdiff_t)(p - s) : -1;
+    }
+}

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -1726,44 +1726,31 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                 if (q >= p.end) break;
                 if (*q == '<') { p.pos = q; continue; }
             }
-            /* Text content — FUSED scan (TODO 184): one inline loop
-             * finds '<' AND counts '\n' (issue #223 line tracking),
-             * replacing the memchr + dp_advance_line re-walk (two
-             * passes; memchr pays ~10ns setup on short text — the
-             * same finding as the attr-value scan). First 48 bytes
-             * inline, SIMD fallback for longer spans. */
+            /* Text content — one-pass scan (#1842): leptris_text_
+             * scan_run finds '<' AND flags '&'/'\r' in a single SIMD
+             * pass, replacing the 48-byte inline loop plus up to
+             * three per-run memchr calls (the three setup costs
+             * dominated on text-heavy shapes: ~90ns of scan per
+             * ~55-byte run). Identical semantics: flags cover
+             * [text_start, lt) only. */
             char* text_start = p.pos;
             uint32_t text_off =
                 p.line_offsets_ok
                     ? (uint32_t)(text_start - p.buf) + 1u : 0u;
             char* lt = NULL;
-            /* #1285 slice 4: '&' tracking fused into the scan (one
-             * predicted compare per byte) — the flush below needs
-             * it and a separate memchr per run cost ~7% parse on
-             * entity-free docs. The memchr fallback covers the
-             * >48-byte tail region only. */
             int has_amp = 0;
-            /* §2.11 (#326): literal-CR tracking rides the same fused
-             * loop — CR-bearing runs take the pool-copy collapse,
-             * CR-free runs (the norm) keep the zero-copy carve. */
+            /* §2.11 (#326): literal-CR tracking rides the same pass —
+             * CR-bearing runs take the pool-copy collapse, CR-free
+             * runs (the norm) keep the zero-copy carve. */
             int has_cr = 0;
             {
-                const char* q = p.pos;
-                const char* probe_end = p.probe_slack
-                    ? q + 48
-                    : ((p.end - q > 48) ? q + 48 : p.end);
-                while (q < probe_end) {
-                    char ch = *q;
-                    if (ch == '<') { lt = (char*)q; break; }
-                    has_amp |= (ch == '&');
-                    has_cr |= (ch == '\r');
-                    q++;
-                }
-                if (q >= p.end) goto text_done;
-                lt = (char*)memchr(q, '<', p.end - q);
-                if (!lt) lt = p.end;
-                has_amp |= memchr(q, '&', (size_t)((char*)lt - q)) != NULL;
-                has_cr |= memchr(q, '\r', (size_t)((char*)lt - q)) != NULL;
+                int saw_amp = 0, saw_cr = 0;
+                ptrdiff_t t_off = leptris_text_scan_run(
+                    p.pos, (size_t)(p.end - p.pos), '<', '&', '\r',
+                    &saw_amp, &saw_cr);
+                lt = (t_off >= 0) ? (char*)(p.pos + t_off) : NULL;
+                has_amp |= saw_amp;
+                has_cr |= saw_cr;
             }
             /* leptris#1748: a '<' that opens no markup construct
              * ('!', '?', '/', name-start) is unescaped text. Strict
@@ -1783,14 +1770,13 @@ static struct leptris_document* direct_parse_internal(char* buf, size_t len,
                     LEPTRIS_DIAG_UNESCAPED_LT, NULL,
                     "Unescaped < not allowed in a text node");
                 const char* nq = lt + 1;
-                const char* nlt =
-                    memchr(nq, '<', (size_t)(p.end - nq));
-                const char* span_end = nlt ? nlt : p.end;
-                has_amp |= memchr(nq, '&',
-                                  (size_t)(span_end - nq)) != NULL;
-                has_cr |= memchr(nq, '\r',
-                                 (size_t)(span_end - nq)) != NULL;
-                lt = (char*)nlt;
+                int saw_amp2 = 0, saw_cr2 = 0;
+                ptrdiff_t n_off = leptris_text_scan_run(
+                    nq, (size_t)(p.end - nq), '<', '&', '\r',
+                    &saw_amp2, &saw_cr2);
+                has_amp |= saw_amp2;
+                has_cr |= saw_cr2;
+                lt = (n_off >= 0) ? (char*)(nq + n_off) : NULL;
             }
         text_done:
             p.pos = lt ? lt : p.end;

data/vendor-src/libleptris/src/leptris/memory/arena.c

@@ -6,6 +6,7 @@
 #include "../common/port.h" /* LEPTRIS_THREAD_LOCAL */
 #include <stdint.h> /* uintptr_t: was transitive via glibc's mman graph */
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 #if defined(__linux__)
 #include <sys/mman.h>   /* madvise(MADV_HUGEPAGE) — Linux only */
@@ -53,6 +54,14 @@ static inline size_t align_up(size_t n) {
  * twice per document lifetime, so contention is irrelevant. */
 #define ARENA_RETAIN_MIN (256u * 1024u)
 #define ARENA_RETAIN_MAX_BLOCKS 4u
+/* #1846 slice 4: the global tier is split by size class. With ONE
+ * 4-slot pool, every parked block kind competes for the same slots —
+ * and parse input copies (freed at document close, never taken back)
+ * permanently occupy slots, so arena spans hit the FULL free path and
+ * the next same-size parse lands on a cold mapping (fresh mmap +
+ * full first-touch: 2 of 5 takes missed on the 306KB fixture). Mid
+ * [256KB, 2MB) and large [2MB, ..) now churn among themselves. */
+#define ARENA_RETAIN_LARGE_MIN (2u * 1024u * 1024u)
 /* 96MB: a large-document parse arena (~4x input with the
  * pre-sized estimate) must survive the free to be reused by the
  * next parse — at the old 32MB ceiling, every big-doc cycle
@@ -73,7 +82,12 @@ static struct {
     size_t size[ARENA_RETAIN_MAX_BLOCKS];
     size_t count;
     size_t bytes;
-} g_retain;
+} g_retain_mid, g_retain_large;
+
+/* Shared byte ceiling across both tiers (the footprint bound). */
+static size_t retain_bytes_total(void) {
+    return g_retain_mid.bytes + g_retain_large.bytes;
+}
 
 #if defined(_MSC_VER)
 #include <intrin.h>
@@ -171,18 +185,43 @@ static char* retain_take(size_t request, size_t* capacity) {
     char* found = NULL;
     size_t found_size = 0;
     retain_lock();
-    for (size_t i = 0; i < g_retain.count; i++) {
-        if (g_retain.size[i] >= request &&
-            (found_size == 0 || g_retain.size[i] < found_size)) {
-            found = g_retain.base[i];
-            found_size = g_retain.size[i];
-            g_retain.base[i] = g_retain.base[g_retain.count - 1];
-            g_retain.size[i] = g_retain.size[g_retain.count - 1];
-            g_retain.count--;
+    /* #1846: search ONLY the request's size class — mid blocks can't
+     * serve large requests, and a large block must never serve a mid
+     * request (it would burn the only large slots on input-copy
+     * churn). */
+    struct {
+        char** base;
+        size_t* size;
+        size_t* count;
+    } t;
+    size_t tcount;
+    if (request >= ARENA_RETAIN_LARGE_MIN) {
+        t.base = g_retain_large.base;
+        t.size = g_retain_large.size;
+        tcount = g_retain_large.count;
+    } else {
+        t.base = g_retain_mid.base;
+        t.size = g_retain_mid.size;
+        tcount = g_retain_mid.count;
+    }
+    for (size_t i = 0; i < tcount; i++) {
+        if (t.size[i] >= request &&
+            (found_size == 0 || t.size[i] < found_size)) {
+            found = t.base[i];
+            found_size = t.size[i];
+            t.base[i] = t.base[tcount - 1];
+            t.size[i] = t.size[tcount - 1];
+            tcount--;
             break;
         }
     }
-    g_retain.bytes -= found_size;
+    if (request >= ARENA_RETAIN_LARGE_MIN) {
+        g_retain_large.count = tcount;
+        g_retain_large.bytes -= found_size;
+    } else {
+        g_retain_mid.count = tcount;
+        g_retain_mid.bytes -= found_size;
+    }
     retain_unlock();
     if (found) *capacity = found_size;
     return found;
@@ -203,16 +242,25 @@ static void retain_give(char* base, size_t size) {
         return;
     }
     retain_lock();
-    if (g_retain.count >= ARENA_RETAIN_MAX_BLOCKS ||
-        g_retain.bytes + size > ARENA_RETAIN_MAX_BYTES) {
+    const int large_class = size >= ARENA_RETAIN_LARGE_MIN;
+    size_t count = large_class ? g_retain_large.count : g_retain_mid.count;
+    if (count >= ARENA_RETAIN_MAX_BLOCKS ||
+        retain_bytes_total() + size > ARENA_RETAIN_MAX_BYTES) {
         retain_unlock();
         leptris_free_hook(base);
         return;
     }
-    g_retain.base[g_retain.count] = base;
-    g_retain.size[g_retain.count] = size;
-    g_retain.count++;
-    g_retain.bytes += size;
+    if (large_class) {
+        g_retain_large.base[count] = base;
+        g_retain_large.size[count] = size;
+        g_retain_large.count = count + 1;
+        g_retain_large.bytes += size;
+    } else {
+        g_retain_mid.base[count] = base;
+        g_retain_mid.size[count] = size;
+        g_retain_mid.count = count + 1;
+        g_retain_mid.bytes += size;
+    }
     retain_unlock();
 }
 
@@ -231,10 +279,14 @@ void leptris_arena_retain_drain(void) {
     g_small.bytes = 0;
 
     retain_lock();
-    for (size_t i = 0; i < g_retain.count; i++)
-        leptris_free_hook(g_retain.base[i]);
-    g_retain.count = 0;
-    g_retain.bytes = 0;
+    for (size_t i = 0; i < g_retain_mid.count; i++)
+        leptris_free_hook(g_retain_mid.base[i]);
+    g_retain_mid.count = 0;
+    g_retain_mid.bytes = 0;
+    for (size_t i = 0; i < g_retain_large.count; i++)
+        leptris_free_hook(g_retain_large.base[i]);
+    g_retain_large.count = 0;
+    g_retain_large.bytes = 0;
     retain_unlock();
 }
 

data/vendor-src/libleptris/test/common/test_simd_text.cpp

@@ -139,4 +139,141 @@ TEST(SimdText, Find3TerminatorAtVeryEnd) {
     EXPECT_EQ(leptris_text_find3(u.data(), u.size(), '-', '-', '>'), -1);
 }
 
+/* ---- leptris_text_scan_run (#1842): one-pass text-run scan ----
+ *
+ * Parser contract: find the first `term` byte and report whether f1/f2
+ * occur strictly BEFORE it. Replaces the 48-byte inline loop plus up to
+ * three per-run memchr calls in the direct parser's text path. */
+
+TEST(SimdText, ScanRunFindsTermEveryPosition) {
+    std::string base = "abcdefghijklmnopqrstuvwxyz";
+    for (size_t len = 1; len <= 80; len++) {
+        std::string s;
+        for (size_t i = 0; i < len; i++) s += base[i % base.size()];
+        for (size_t pos = 0; pos < len; pos++) {
+            std::string t = s;
+            t[pos] = '<';
+            int saw_amp = -1, saw_cr = -1;
+            ptrdiff_t off = leptris_text_scan_run(
+                t.data(), t.size(), '<', '&', '\r', &saw_amp, &saw_cr);
+            EXPECT_EQ(off, (ptrdiff_t)pos)
+                << "len=" << len << " pos=" << pos;
+            EXPECT_EQ(saw_amp, 0) << "len=" << len << " pos=" << pos;
+            EXPECT_EQ(saw_cr, 0) << "len=" << len << " pos=" << pos;
+        }
+    }
+}
+
+TEST(SimdText, ScanRunFlagsCountPrefixOnly) {
+    /* '&'/CR before the term set the flags; the same bytes after it
+     * must NOT (the parser's entity/CR handling only covers the run
+     * it carves). */
+    {
+        std::string t = "ab&cd<ef&gh";
+        int saw_amp = -1, saw_cr = -1;
+        ptrdiff_t off = leptris_text_scan_run(
+            t.data(), t.size(), '<', '&', '\r', &saw_amp, &saw_cr);
+        EXPECT_EQ(off, 5);
+        EXPECT_EQ(saw_amp, 1);
+        EXPECT_EQ(saw_cr, 0);
+    }
+    {
+        std::string t = "ab<cd&";  /* flag byte after the term is skipped */
+        int saw_amp = -1, saw_cr = -1;
+        ptrdiff_t off = leptris_text_scan_run(
+            t.data(), t.size(), '<', '&', '\r', &saw_amp, &saw_cr);
+        EXPECT_EQ(off, 2);
+        EXPECT_EQ(saw_amp, 0);
+        EXPECT_EQ(saw_cr, 0);
+    }
+    {
+        std::string t = "a\r\rb<c\r";
+        int saw_amp = -1, saw_cr = -1;
+        ptrdiff_t off = leptris_text_scan_run(
+            t.data(), t.size(), '<', '&', '\r', &saw_amp, &saw_cr);
+        EXPECT_EQ(off, 4);
+        EXPECT_EQ(saw_amp, 0);
+        EXPECT_EQ(saw_cr, 1);
+    }
+    {
+        std::string t = "&x\ry<z";
+        int saw_amp = -1, saw_cr = -1;
+        ptrdiff_t off = leptris_text_scan_run(
+            t.data(), t.size(), '<', '&', '\r', &saw_amp, &saw_cr);
+        EXPECT_EQ(off, 4);
+        EXPECT_EQ(saw_amp, 1);
+        EXPECT_EQ(saw_cr, 1);
+    }
+}
+
+TEST(SimdText, ScanRunNoTermFlagsWholeSpan) {
+    std::string base = "The quick brown fox jumps over the lazy dog ";
+    for (size_t len = 0; len <= 200; len++) {
+        std::string s;
+        for (size_t i = 0; i < len; i++) s += base[i % base.size()];
+        int saw_amp = -1, saw_cr = -1;
+        ptrdiff_t off = leptris_text_scan_run(
+            s.data(), s.size(), '<', '&', '\r', &saw_amp, &saw_cr);
+        EXPECT_EQ(off, -1) << "len=" << len;
+        EXPECT_EQ(saw_amp, 0) << "len=" << len;
+        EXPECT_EQ(saw_cr, 0) << "len=" << len;
+    }
+    /* Flags fire across chunk boundaries when the term is absent. */
+    std::string t(15, 'x');
+    t += '&';
+    t.append(20, 'x');
+    t += '\r';
+    t.append(40, 'x');
+    int saw_amp = -1, saw_cr = -1;
+    EXPECT_EQ(leptris_text_scan_run(t.data(), t.size(), '<', '&', '\r',
+                                    &saw_amp, &saw_cr),
+              -1);
+    EXPECT_EQ(saw_amp, 1);
+    EXPECT_EQ(saw_cr, 1);
+}
+
+TEST(SimdText, ScanRunTermAtVeryEnd) {
+    std::string t(40, 'y');
+    t += '<';
+    int saw_amp = -1, saw_cr = -1;
+    EXPECT_EQ(leptris_text_scan_run(t.data(), t.size(), '<', '&', '\r',
+                                    &saw_amp, &saw_cr),
+              40);
+    EXPECT_EQ(saw_amp, 0);
+    EXPECT_EQ(saw_cr, 0);
+}
+
+TEST(SimdText, ScanRunEmptySpan) {
+    int saw_amp = -1, saw_cr = -1;
+    EXPECT_EQ(leptris_text_scan_run("", 0, '<', '&', '\r', &saw_amp,
+                                    &saw_cr),
+              -1);
+    EXPECT_EQ(saw_amp, 0);
+    EXPECT_EQ(saw_cr, 0);
+}
+
+TEST(SimdText, ScanRunLongBodyEveryPosition) {
+    /* Vector-loop coverage: term at every offset of a 300-byte body,
+     * with flag bytes seeded before and after each position. */
+    std::string body(300, 'x');
+    for (size_t pos = 0; pos < body.size(); pos++) {
+        std::string t = body;
+        if (pos > 0) t[pos / 2] = '&';
+        if (pos > 2) t[pos / 3] = '\r';
+        t[pos] = '<';
+        /* Expected flags derive from the final seeded string. */
+        int e_amp = 0, e_cr = 0;
+        for (size_t i = 0; i < pos; i++) {
+            e_amp |= (t[i] == '&');
+            e_cr |= (t[i] == '\r');
+        }
+        int saw_amp = -1, saw_cr = -1;
+        ptrdiff_t off = leptris_text_scan_run(
+            t.data(), t.size(), '<', '&', '\r', &saw_amp, &saw_cr);
+        ASSERT_EQ(off, (ptrdiff_t)pos) << "pos=" << pos;
+        EXPECT_EQ(saw_amp, e_amp) << "pos=" << pos;
+        EXPECT_EQ(saw_cr, e_cr) << "pos=" << pos;
+    }
+}
+
 }  // namespace

data/vendor-src/libleptris/test/memory/test_arena.cpp

@@ -377,3 +377,41 @@ TEST(ArenaSmallRecycle, BulkDestroyParksUpToTheBound) {
     leptris_arena_retain_drain();
 }
 
+
+// ---- #1846 slice 4: mixed-size traffic must not evict arena spans ---
+// The single 4-slot global pool mixes every parked block kind (parse
+// input copies never get taken back; they just occupy slots). With
+// more block kinds than slots the FULL path frees ARENA spans and the
+// next same-size create lands on a cold mapping. The fix splits the
+// global tier by size class: mid [256KB, 2MB) and large [2MB, ..),
+// each with its own slots — the four mid kinds churn among
+// themselves and the large span keeps its slot.
+TEST(LeptrisArena, SameSizeReuseSurvivesMixedSizeTraffic) {
+#if defined(ARENA_TESTS_ASAN)
+    GTEST_SKIP() << "retain cache disabled under ASAN";
+#endif
+    const size_t huge = 4u * 1024u * 1024u;
+    void* huge_base = nullptr;
+    for (int round = 0; round < 3; round++) {
+        /* mid-class traffic: four distinct sizes, one per slot */
+        for (size_t mid : {300u * 1024u, 350u * 1024u, 400u * 1024u,
+                           450u * 1024u}) {
+            LeptrisArena* m = leptris_arena_create(mid);
+            ASSERT_NE(m, nullptr);
+            memset(leptris_arena_base(m), 1, mid);
+            leptris_arena_destroy(m);
+        }
+        /* the large arena: after warmup its mapping must repeat */
+        LeptrisArena* h = leptris_arena_create(huge);
+        ASSERT_NE(h, nullptr);
+        memset(leptris_arena_base(h), 1, huge);
+        if (round == 0) {
+            huge_base = leptris_arena_base(h);
+        } else {
+            EXPECT_EQ(leptris_arena_base(h), huge_base)
+                << "round " << round
+                << ": the large span was evicted by mid traffic";
+        }
+        leptris_arena_destroy(h);
+    }
+}

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.387",
+  "version": "1.9.388",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.386.0
+  version: 1.9.388.0
 platform: ppc64le-linux
 authors:
 - Ribose Inc.
@@ -441,6 +441,7 @@ files:
 - vendor-src/libleptris/benchmarks/modification/bench_append_split.cpp
 - vendor-src/libleptris/benchmarks/modification/bench_leptris_modify.c
 - vendor-src/libleptris/benchmarks/modification/bench_node_creation.c
+- vendor-src/libleptris/benchmarks/parse/arena_ab.sh
 - vendor-src/libleptris/benchmarks/parse/bench_parse_ab.cpp
 - vendor-src/libleptris/benchmarks/sax/bench_iterparse.c
 - vendor-src/libleptris/benchmarks/sax/bench_leptris.c