v2.10.0

RELEASE.md

@@ -29,6 +29,26 @@ truth for the version** — no version literal is ever hand-edited in source.
    - packages `rayforce-X.Y.Z-<os>-<arch>.tar.gz` + a `.sha256` checksum,
    - publishes a GitHub Release with a feature-oriented changelog and the
      artifacts.
+5. **Merge `master` back into `dev`** right after the release PR merges:
+
+   ```sh
+   git fetch origin
+   git switch dev && git pull --ff-only
+   git merge --no-ff -s ours origin/master \
+     -m "chore: merge master back into dev after the vX.Y.Z release (#N)"
+   git diff origin/dev --stat   # must print nothing
+   git push origin dev
+   ```
+
+   Merging the release PR leaves a squash or merge commit on `master` that `dev`
+   doesn't contain. `master` requires branches to be up to date before merging,
+   so without this step the next release PR is blocked as "out of date with the
+   base". After a squash, it also shows conflicts that aren't real. Copying the
+   release commit onto `dev` doesn't help: only a merge makes `master`'s commit
+   an ancestor of `dev`. `-s ours` is correct because `dev` already contains
+   everything the release shipped, so the empty `git diff` proves the merge
+   changed no files. If `master` ever carries a hotfix that isn't on `dev`,
+   drop `-s ours` and do a normal merge instead.
 
 That's the whole ritual. **Never edit the version in source to make a release** —
 the tag is authoritative.

bench/concat_text_nulls.c

@@ -0,0 +1,45 @@
+/* Focused concat benchmark: build with release library, run before/after. */
+#define _POSIX_C_SOURCE 200809L
+#include <rayforce.h>
+#include "mem/heap.h"
+#include "vec/vec.h"
+#include <stdio.h>
+#include <time.h>
+
+static double now(void) {
+    struct timespec t;
+    clock_gettime(CLOCK_MONOTONIC, &t);
+    return t.tv_sec + t.tv_nsec * 1e-9;
+}
+
+int main(void) {
+    ray_heap_init();
+    const int64_t n = 1000000;
+    const int reps = 40;
+    for (int kind = 0; kind < 2; kind++) {
+        for (int mode = 0; mode < 3; mode++) {
+            ray_t* a = ray_vec_new(kind ? RAY_SYM : RAY_STR, n);
+            if (!a || RAY_IS_ERR(a)) return 1;
+            if (kind) {
+                a->len = n;
+                for (int64_t i = 0; i < n; i++) ((int64_t*)ray_data(a))[i] = 1;
+            } else {
+                for (int64_t i = 0; i < n; i++) a = ray_str_vec_append(a, "abc", 3);
+            }
+            if (mode == 1) ray_vec_set_null(a, 0, true);
+            if (mode == 2) ray_vec_set_null(a, n - 1, true);
+            double start = now();
+            for (int r = 0; r < reps; r++) {
+                ray_t* out = ray_vec_concat(a, a);
+                if (!out || RAY_IS_ERR(out) || out->len != 2 * n) return 2;
+                ray_release(out);
+            }
+            printf("%s %s rows=%lld reps=%d ms_per_concat=%.6f\n",
+                   kind ? "SYM64" : "STR-inline", mode == 0 ? "no-null" : mode == 1 ? "first-null" : "last-null",
+                   (long long)n, reps, (now() - start) * 1000 / reps);
+            ray_release(a);
+        }
+    }
+    ray_heap_destroy();
+    return 0;
+}

docs/docs/guides/memory.md

@@ -385,7 +385,7 @@ This tells you the join needed about 1 GB of temporary memory beyond what was al
 | Tool | What It Does | When to Use |
 |---|---|---|
 | `(.sys.mem 0)` | Returns heap allocation statistics | Monitor memory usage, detect leaks |
-| `(.sys.gc 0)` | Flushes caches, releases pages | Between heavy queries, before benchmarks |
+| `(.sys.gc)` | Flushes caches, releases pages | Between heavy queries, before benchmarks |
 | `(.sys.info 0)` | Shows system and runtime info | Check total RAM, CPU count, OS details |
 | `(timeit expr)` | Measures execution time of one expression | Benchmark a specific operation |
 | `:timeit` | Toggles profiling for all REPL expressions | Interactive performance exploration |

docs/docs/namespaces/log.md

@@ -15,11 +15,11 @@ The journal is intentionally minimal: there's no per-entry timestamp or transact
 | [`.log.write`](#log-write) | unary | — | Append a serialised expression to the open journal. |
 | [`.log.sync`](#log-sync) | variadic | — | `fsync` the journal. |
 | [`.log.snapshot`](#log-snapshot) | variadic | restricted | Write a snapshot of current state and roll to a fresh segment. |
-| [`.log.roll`](#log-roll) | variadic | restricted | Close the active segment and start a new one. |
+| [`.log.roll`](#log-roll) | nullary | restricted | Close the active segment and start a new one. |
 | [`.log.replay`](#log-replay) | unary | restricted | Replay a journal file; return entry count. |
 | [`.log.validate`](#log-validate) | unary | — | Scan a journal file; return `(chunks valid_bytes)`. |
 | [`.log.close`](#log-close) | variadic | restricted | Flush and close the active journal. |
-| [`.log.purge`](#log-purge) | variadic | restricted | Close the active journal and delete all its files. |
+| [`.log.purge`](#log-purge) | nullary | restricted | Close the active journal and delete all its files. |
 
 ## `.log.open` { #log-open }
 

src/core/platform.c

@@ -369,7 +369,7 @@ static uint64_t cache_sysfs_llc_bytes(void) {
 }
 #endif
 
-uint64_t ray_cache_llc_bytes(void) {
+static uint64_t cache_llc_probe(void) {
     static uint64_t cached = UINT64_MAX;
     if (cached != UINT64_MAX) return cached;
     uint64_t bytes = 0;
@@ -642,7 +642,7 @@ uint32_t ray_physical_core_count(void) {
 /* Sum of every level-3 cache instance reported by the processor topology
  * (each SYSTEM_LOGICAL_PROCESSOR_INFORMATION cache record is one instance).
  * 0 when the query fails. */
-uint64_t ray_cache_llc_bytes(void) {
+static uint64_t cache_llc_probe(void) {
     static uint64_t cached = UINT64_MAX;
     if (cached != UINT64_MAX) return cached;
     uint64_t bytes = 0;
@@ -800,7 +800,7 @@ ray_err_t ray_thread_join(ray_thread_t t) {
 }
 
 uint32_t ray_thread_count(void) { return 1; }
-uint64_t ray_cache_llc_bytes(void) { return 0; }
+static uint64_t cache_llc_probe(void) { return 0; }
 
 /* Semaphore — counter-only.  Single-threaded so wait never blocks (the
  * counter must already be positive when wait fires). */
@@ -818,3 +818,21 @@ void ray_sem_wait(ray_sem_t* s) {
 void ray_sem_signal(ray_sem_t* s) { (*s)++; }
 
 #endif /* RAY_OS_WASM */
+
+#ifdef DEBUG
+/* Test pin for the probed LLC size: routing that bounds replicated state by
+ * the cache (group dense slabs) otherwise picks a different strategy on
+ * every CI runner.  0 restores the platform probe. */
+static uint64_t g_llc_for_test = 0;
+
+void ray_cache_llc_set_for_test(uint64_t bytes) {
+    g_llc_for_test = bytes;
+}
+#endif
+
+uint64_t ray_cache_llc_bytes(void) {
+#ifdef DEBUG
+    if (g_llc_for_test) return g_llc_for_test;
+#endif
+    return cache_llc_probe();
+}

src/core/platform.h

@@ -180,6 +180,10 @@ uint32_t ray_physical_core_count(void);
  * 0 when the platform cannot report it.  Bounds replicated per-task state
  * whose random-access working set must stay cache-resident to scale. */
 uint64_t ray_cache_llc_bytes(void);
+#ifdef DEBUG
+/* Pin ray_cache_llc_bytes to `bytes` (0 = probe again). */
+void ray_cache_llc_set_for_test(uint64_t bytes);
+#endif
 
 void ray_parallel_begin(void);
 void ray_parallel_end(void);