Skip to content

Commit 06abc57

Browse files
authored
Merge pull request #85 from BuddhiLW/swarm/perf-strings
perf: string and vector hot paths (CLJW-PERF-STRINGS-COLLS)
2 parents a07e103 + 279a832 commit 06abc57

14 files changed

Lines changed: 284 additions & 82 deletions

File tree

‎.dev/optimizations.md‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -114,6 +114,14 @@
114114
| O-051 | `runtime/collection/map.zig` (`arrayMapKeywordSlot` helper + `get`/`contains` keyword fast path) (ADR-0165/ADR-0148; destructure, gc_large_heap) | An `.array_map` `get`/`contains` scanned every entry through `keyEq`→`equal.eqConsult`→`isSimpleEqKey`×2→`keyEqValue` (a `!bool` error-union chain) even when the lookup key is a keyword — yet keywords are INTERNED, so `=` over two keywords IS NaN-box payload bit-identity. destructure (`{:keys [a b c]} m` ×100k = 3 keyword gets/iter) + every keyword config-map lookup pay the chain per entry. (O-049 cut the TLV read inside `eqConsult`; this removes the call chain + error union entirely for the dominant keyword case.) | `arrayMapKeywordSlot(am, kw)`: when `k.tag()==.keyword`, scan `am.entries` comparing `@intFromEnum(entry_key)==@intFromEnum(kw)` inline (no call, no `try`), returning the entry index or null. `get`/`contains` take it on the keyword branch; non-keyword keys keep the general `keyEq` path. Correct because keyword interning makes bit-equality ⟺ `=`, and a keyword can only bit-match a keyword entry (distinct NaN-box tags). The `>8`-entry `.hash_map` path is unchanged (keyword-keyed maps are overwhelmingly small). | **clean old-vs-new ReleaseSafe binary A/B (hyperfine -N, 30 runs, same session): `37_destructure` 51.5→48.1 ms (−6.6%); `27_gc_large_heap` 33.2→31.7 ms (−4.5%); 300k-get microbench 23.7→21.1 ms (−11.0%); map-destructure micro 34.8→32.6 (−6.3%).** Broad win for every keyword `(get map k)` / `(contains? map k)` / `:keys` destructure. | `zig build test -Dwasm` ×2 (diff oracle TreeWalk≡VM, identical Values) + new map.zig unit test (keyword hit/miss + mixed keyword/int/string keys, re-interned keyword identity) + lint | O-048, O-049, O-026, ADR-0165, ADR-0148, D-450, D-520 |
115115
| O-050 | `runtime/numeric/promote.zig` (`ratioArith` add/sub branch) + `runtime/numeric/ratio.zig` (`allocFromReducedManagedPair`/`finishReducedPair`) (ADR-0148; ratio_sum) | The BIG-tier ratio add `(an*bd ± bn*ad)/(ad*bd)` reduced via a full gcd in `allocFromManagedPair`. O-046's i64 small tier covers tiny ratios, but the harmonic-sum ACCUMULATOR (`(reduce + …)`) grows past i64 → big-tier add ~45×/call, each paying the big gcd. | Knuth TAOCP 4.5.1 / GMP `mpq_add` gcd-first add: `g = gcd(ad, bd)` FIRST (the added term's denom ≤ 50 → a tiny gcd), reduce by g; coprime denominators (g=1) SKIP the final gcd entirely, else a small `gcd(t, g≤50)`. Result is coprime → `allocFromReducedManagedPair` (factored post-gcd tail of `allocFromManagedPair`, no redundant final gcd; zero-numerator→int-0 guarded). mul/div keep the full reduce. | **`33_ratio_sum` ReleaseSafe 39.6→31.0 ms (hyperfine -N, 15 runs, 1.28×±0.20 over the pre-Knuth baseline, same machine/session A/B).** Complements O-046 (small tier); broad win for all big-tier ratio `+`/`-`. | `zig build test -Dwasm` ×2 (diff oracle) + corpus 3656 + 10 clj-verified edge cases (coprime / g>1 reduction / zero / integer-collapse / negative / large-coprime / harmonic) | O-037, O-046, ADR-0148, D-450 |
116116
| O-054 (renumbered 2026-08-05 — the 2026-07-07 D-529 commit duplicated O-051, which the 2026-06-24 keyword-map-get row already held; external O-051 references all mean that row) | ~30 sites across `runtime/` + `lang/primitive/` (grep `PERF:` without an `O-NNN` ref for the live list) | Each site's naive form is stated IN its own marker comment (e.g. "empty + N×conj" vs `fromSlice`; seqFn walk vs index-walk; per-element vs chunk-append) | Self-documenting micro fast-paths: the marker text itself records the naive↔optimized pair, so a dedicated ledger row per site would duplicate the comment without adding information. This umbrella row makes that class OFFICIAL (D-529 audit, 2026-07-07): a `PERF:` marker whose comment states its own naive form and cites no `O-NNN` belongs to this row (O-054) implicitly. New MEASURED optimizations still get their own row. | n/a (micro; individually unmeasured by design) | the dual-backend diff oracle + corpus cover each site's behaviour | D-529 |
117+
| O-070 | `lang/primitive/string.zig` (`-join` leaf, any seqable) + `lang/clj/clojure/string.clj` `join` (bench/vs_bb string_ops) | 2-arity `join` was `(apply str (interpose sep coll))`: a lazy interpose seq (closure call + lazy cell per element) plus an `apply` arg spill; profiled ~87% of string_ops | `-join` is clj's StringBuilder loop in Zig: vector arm indexes directly, every other seqable walks `seq`/`first`/`next` under a GC-root frame; sep and elements render through `print.writeStrValue` (the `str` renderer), so nil→"" and char/keyword/number render as `str` would. Both arities call it | string_ops cljw 3760→943 ms in-proc (with O-071/O-072; 9.33×→2.27× vs bb) | spot vs clj: vector/list/string/map/empty-set colls, nil sep, nil/char/keyword elements, non-seqable raises IAE | O-012 |
118+
| O-071 | `runtime/charset.zig` (`upperCaseAlloc`/`lowerCaseAlloc` ASCII fast path) | upper/lower-case walked a `Utf8Iterator` + SpecialCasing/simple-map table lookup per codepoint even for pure-ASCII input | OR-reduce the bytes; all-ASCII → byte-for-byte `std.ascii` fold (every ASCII codepoint's full mapping is its ASCII fold, 1:1). Non-ASCII keeps the table walk (ß→SS unchanged) | part of string_ops 3760→943 ms | `(upper-case "aßc")`→"ASSC", ASCII round trips | D-057 |
119+
| O-072 | `runtime/regex/match.zig` (`Scanner`) + `runtime/regex/replace.zig` (`splitToVector`) | `split` allocated+freed a fresh VM thread-list pair per match via `findFrom`, then built the result with N persistent `conj`s | One `Scanner` (one VM state) for the whole split; pieces published by `vector.fromSlice` inside a fabrication region | part of string_ops 3760→943 ms | `(split "a,b,,c,," #",")`, `(split "abc" #"")` == clj; regex_parity e2e | O-035, ADR-0150 |
120+
| O-073 | `lang/primitive/collection.zig` (`__subvec-fast`) + `core.clj` `subvec` | `subvec` ran ~10 interpreted checks + an `->idx` closure alloc per call before the O(1) `__subvec` view | `__subvec-fast` answers the in-bounds immediate-int vector/subvec case natively; nil (never a real subvec result) falls through to the unchanged coercing/throwing path | vector_assoc 1452→1092 ms (with O-074; 3.24×→1.94× vs bb) | subvec nested/1-arity/float index/OOB IOOBE/nil NPE == clj | O-059, D-583 |
121+
| O-074 | `runtime/collection/vector.zig` (`copyHamt`/`newTail`) | node copies did `.{ .header = … }` (nil-init all 32 slots) then `@memcpy`: every slot written twice on every conj/assoc/pop/pushTail | Write header + slots once; tails copy the live prefix and nil-fill only the dead suffix | part of vector_assoc 1452→1092 ms | zig unit tests + diff oracle | O-040 |
122+
| O-075 | `lang/primitive/core.zig` (`strFn` stack-buffer path) | multi-arg `str` always built a heap `Allocating` writer (gpa alloc+free) and dispatched `writeStrValue` per arg | when every arg is a string / immediate int / nil and the result fits 256 bytes, concatenate into a stack buffer and allocate the string once; anything else takes the unchanged general path | `(str "item-" i "-x")` x500k 316→144 ms (bb 125) | spot vs clj: nil/int/negative/mixed/float+kw+char fallback/overflow past 256 bytes | O-042 |
123+
| O-076 | `runtime/keyword.zig` (`stackKey` probe in `internUnlocked`/`findUnlocked`) | every `keyword` intern allocated and freed a `ns/name` lookup key even on a hit | probe the table with a stack-built key (or the name itself when there is no ns); allocate only on a miss or a key over 128 bytes | `(keyword "abc")` x500k 235→104 ms; vector_assoc ~950→~800 ms in-proc (A/B, loaded box) | `=` identity of re-interned long/ns keywords, `find-keyword` hit/miss | O-051 |
124+
| O-077 | `lang/primitive/chunk_transform.zig` (`__dorun`) + `core.clj` `dorun` 1-arity | `dorun` (and so `doall`) stepped `(next s)` through the interpreter per element | native walk: chunked_cons skips its whole realized chunk via `chunk-rest`, other seqs step with `seqable.next` (realization runs once per element, in order) | `(doall (map identity (range 2000)))` x250 225→135 ms | side-effect counts, lazy/concat mixes, nil/vector/string/map, non-seqable raises IAE | O-032 |
117125
| O-090 | `eval/bytecode/serialize.zig` (`readValue` `.list` arm), cold-start axis | Each quoted-list constant decoded from the AOT bootstrap blob took its forward-read scratch buffer from `std.heap.page_allocator` | The buffer comes from the reader's allocator (`ctx.allocator`), as `readCollection` already does; the count header is bounds-checked against the remaining bytes first | `page_allocator` is one `mmap` + `munmap` + first-touch page fault per list, 927 per cold start. `perf stat -r 20` on `cljw -e nil`, ReleaseSafe: task-clock 38.8 → 27.3 ms, kernel instructions 22.2M → 7.9M, page faults 2741 → 1792 (bb: 29.1 ms, 4868 faults); pinned `taskset -c 2`: kernel instructions 29.3M → 12.3M (bb 26.8M), user unchanged 61.6M (bb 16.2M, the residual is D-610) | `test/run_all.sh --smoke` + `perf stat`/`strace -c` A/B | card CLJW-PERF-STARTUP |
118126

119127
## Identified high-ROI candidates (measured, not yet implemented)

‎data/placement.yaml‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -24,9 +24,9 @@
2424
schema_version: "2.0"
2525
summary:
2626
namespaces_required: 36
27-
total: 1459
28-
zig: 428
29-
clj: 805
27+
total: 1462
28+
zig: 430
29+
clj: 806
3030
value: 220
3131
unbound: 6
3232
vars:
@@ -86,6 +86,7 @@ vars:
8686
"cljw.internal/__defrecord!": { impl: zig, flags: "-" }
8787
"cljw.internal/__deftype!": { impl: zig, flags: "-" }
8888
"cljw.internal/__delay-create": { impl: zig, flags: "-" }
89+
"cljw.internal/__dorun": { impl: zig, flags: "-" }
8990
"cljw.internal/__dump-host-classes": { impl: zig, flags: "-" }
9091
"cljw.internal/__dump-placement": { impl: zig, flags: "-" }
9192
"cljw.internal/__entry-at": { impl: zig, flags: "-" }
@@ -131,6 +132,7 @@ vars:
131132
"cljw.internal/__string-reader": { impl: zig, flags: "-" }
132133
"cljw.internal/__string-writer": { impl: zig, flags: "-" }
133134
"cljw.internal/__subvec": { impl: zig, flags: "-" }
135+
"cljw.internal/__subvec-fast": { impl: zig, flags: "-" }
134136
"cljw.internal/__unsupported-host-ref": { impl: zig, flags: "-" }
135137
"cljw.internal/__update-in": { impl: zig, flags: "-" }
136138
"cljw.internal/__vector-pop": { impl: zig, flags: "-" }
@@ -314,6 +316,7 @@ vars:
314316
"clojure.core/-sorted-seq-from": { impl: value, flags: "-" }
315317
"clojure.core/-spread": { impl: clj, flags: "-" }
316318
"clojure.core/-sub-sequence": { impl: value, flags: "-" }
319+
"clojure.core/-subvec-slow": { impl: clj, flags: "private" }
317320
"clojure.core/-take-eager": { impl: zig, flags: "private,zig-leaf" }
318321
"clojure.core/-tset-contains?": { impl: value, flags: "-" }
319322
"clojure.core/-tx-seq-pump": { impl: clj, flags: "-" }

‎src/lang/clj/clojure/core.clj‎

Lines changed: 14 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -516,8 +516,9 @@
516516
;; bootstrap-order-safe. The lazy-seq realization utilities (clojure.core).
517517
(def dorun
518518
(fn* ([coll]
519-
(loop* [s (seq coll)]
520-
(if s (recur (next s)) nil)))
519+
;; PERF: the seq/next walk runs natively, a chunk at a time over a
520+
;; chunked seq. [refs: O-077]
521+
(cljw.internal/__dorun coll))
521522
([n coll]
522523
(loop* [i n s (seq coll)]
523524
(if (if (pos? i) s nil) (recur (dec i) (next s)) nil)))))
@@ -731,9 +732,8 @@
731732
;; defaults to (count v)) as a vector. For a vector this is JVM's O(1)
732733
;; shared-structure VIEW (the `.sub_vector` tag; D-583); a non-vector
733734
;; seqable falls back to the eager take/drop build.
734-
(def subvec
735-
(fn* ([v start] (subvec v start (count v)))
736-
([v start end]
735+
(def ^:private -subvec-slow
736+
(fn* ([v start end]
737737
(when (nil? v)
738738
(throw (NullPointerException. "subvec: nil vector")))
739739
(when-not (vector? v)
@@ -763,6 +763,15 @@
763763
;; O(1) shared-structure view, preserving numeric coercion and bounds.
764764
(cljw.internal/__subvec v start end)))))
765765

766+
(def subvec
767+
(fn* ([v start] (subvec v start (count v)))
768+
([v start end]
769+
;; PERF: in-bounds integer indices over a vector are answered by one
770+
;; native step; nil means "not that shape", so everything below is the
771+
;; coercing / throwing path. [refs: O-073]
772+
(or (cljw.internal/__subvec-fast v start end)
773+
(-subvec-slow v start end)))))
774+
766775
;; `(bounded-count n coll)` — for a `counted?` coll return its FULL count (clj:
767776
;; `(bounded-count 3 (range 100))` → 100, range is O(1) counted); otherwise walk
768777
;; at most n elements so it terminates on infinite / expensive seqs (D-134).

‎src/lang/clj/clojure/string.clj‎

Lines changed: 6 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -68,21 +68,14 @@
6868
;; `-capitalize` leaf, which already does exactly this over codepoints.
6969
(def capitalize (fn* [s] (-capitalize s)))
7070

71-
;; join: 1-arity (coll) = (apply str coll); 2-arity (sep coll) interposes the
72-
;; separator and builds the result in one `apply str`. Variadic via `[& args]`
73-
;; + count discrimination since cw v1 lacks multi-arity `fn*` (D-070).
71+
;; join: 1-arity (coll) = (apply str coll); 2-arity (sep coll) puts `(str sep)`
72+
;; between the `str` of each element of `(seq coll)`. Both arities are the
73+
;; `-join` leaf: one native walk + one buffer, no interpose seq.
7474
;; (join sep) transducer arity is deferred (D-070 + ADR-0033 D6a).
75-
;;
76-
;; PERF: the old 2-arity `(reduce (fn [acc x] (str acc sep x)) nil coll)` copied
77-
;; the growing accumulator string on EVERY element → O(n²) in total length. The
78-
;; JVM idiom `(apply str (interpose sep coll))` walks once and builds the result
79-
;; in a single `str` pass (O(n) — `apply str` is the native variadic builder).
80-
;; [refs: O-012]
75+
;; [refs: O-012, O-070]
8176
(def join
82-
(fn* [& args]
83-
(if (= 1 (count args))
84-
(apply str (first args))
85-
(apply str (interpose (first args) (first (rest args)))))))
77+
(fn* ([coll] (-join coll))
78+
([separator coll] (-join separator coll))))
8679

8780
;; ----------------------------------------------------------------
8881
;; Row 7.12 cycle 3 (D-078): `replace` / `replace-first` Pattern A

‎src/lang/primitive/chunk_transform.zig‎

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,7 @@ const SourceLocation = error_mod.SourceLocation;
2929
const chunked_cons = @import("../../runtime/collection/chunked_cons.zig");
3030
const root_set = @import("../../runtime/gc/root_set.zig");
3131
const invokeCallable = @import("higher_order.zig").invokeCallable;
32+
const seqable = @import("../../runtime/seqable.zig");
3233

3334
/// PERF: in-Zig chunk-map drain — `f` over all of `s`'s current chunk → a filled
3435
/// ChunkBuffer (the `.clj` arm does `(chunk-cons <buf> (-map-lazy f (chunk-rest
@@ -64,6 +65,34 @@ pub fn chunkMapStepFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceL
6465
return buf;
6566
}
6667

68+
/// `(__dorun coll)`: the 1-arity `dorun` walk, `(loop [s (seq coll)] (when s
69+
/// (recur (next s))))`, in Zig. A chunked_cons skips its whole current chunk
70+
/// in one step (`chunk-rest`, the elements are already realized), which is
71+
/// what clj's `next` on a ChunkedCons amounts to for a forcing walk. Every
72+
/// other seq is stepped with `seqable.next`, so lazy realization (and any side
73+
/// effect it carries) runs exactly once per element, in order. Returns nil.
74+
/// PERF: the `.clj` loop paid an interpreted `next` call per element (bench
75+
/// vs_bb string_ops `doall (map …)`). [refs: O-077]
76+
pub fn dorunFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
77+
try error_catalog.checkArity("__dorun", args, 1, loc);
78+
// GC-ROOT: frame [cursor]; `next` may realize a lazy cell (re-enters eval).
79+
var gc_roots: [1]Value = .{.nil_val};
80+
var gc_sp: u16 = 1;
81+
var gc_frame: root_set.EvalFrame = .{ .stack = &gc_roots, .sp = &gc_sp, .locals = &.{}, .parent = root_set.eval_frame_head };
82+
root_set.eval_frame_head = &gc_frame;
83+
defer root_set.eval_frame_head = gc_frame.parent;
84+
85+
gc_roots[0] = try seqable.seq(rt, env, args[0], loc);
86+
while (gc_roots[0].tag() != .nil) {
87+
if (gc_roots[0].tag() == .chunked_cons and chunked_cons.currentChunkCount(gc_roots[0]) > 0) {
88+
gc_roots[0] = try seqable.seq(rt, env, chunked_cons.chunkRest(gc_roots[0]), loc);
89+
} else {
90+
gc_roots[0] = try seqable.next(rt, env, gc_roots[0], loc);
91+
}
92+
}
93+
return .nil_val;
94+
}
95+
6796
/// PERF: in-Zig chunk-filter drain — `pred` over all of `s`'s current chunk →
6897
/// a ChunkBuffer of survivors (partial; empty → the `.clj` `chunk-cons` returns
6998
/// the tail directly). [refs: O-032, O-004]

‎src/lang/primitive/collection.zig‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1291,6 +1291,28 @@ pub fn subvecFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocatio
12911291
return sub_vector.make(rt, v, start, end);
12921292
}
12931293

1294+
/// `(__subvec-fast v start end)` — the common `subvec` call answered in one
1295+
/// native step: `v` a vector (or subvec view), `start`/`end` immediate
1296+
/// integers with `0 <= start <= end <= (count v)` → the O(1) view. Any other
1297+
/// shape (nil, a non-vector, a float / ratio / non-number index, an
1298+
/// out-of-bounds range) answers nil, and `clojure.core/subvec` falls through
1299+
/// to its full coercion + throwing path. A real subvec is never nil, so nil
1300+
/// is an unambiguous "not handled".
1301+
/// PERF: the wrapper otherwise allocated an `->idx` closure and ran ~10
1302+
/// interpreted checks per call (bench/vs_bb vector_assoc). [refs: O-073]
1303+
pub fn subvecFastFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
1304+
_ = env;
1305+
try error_catalog.checkArity("__subvec-fast", args, 3, loc);
1306+
const v = args[0];
1307+
if (v.tag() != .vector and v.tag() != .sub_vector) return .nil_val;
1308+
if (!args[1].isInt() or !args[2].isInt()) return .nil_val;
1309+
const start = args[1].asInteger();
1310+
const end = args[2].asInteger();
1311+
const c: i64 = if (v.tag() == .vector) vector.count(v) else sub_vector.count(v);
1312+
if (start < 0 or end < start or c < end) return .nil_val;
1313+
return sub_vector.make(rt, v, @intCast(start), @intCast(end));
1314+
}
1315+
12941316
/// `#queue (e1 e2 …)` data-reader (ADR-0087): build a queue by conj-ing the
12951317
/// form's elements in order. cljw extension (clj has no `#queue` reader); makes
12961318
/// the cljw print form reader-round-trippable.
@@ -1366,6 +1388,7 @@ const ENTRIES = [_]Entry{
13661388
.{ .name = "__queue-pop", .f = &queuePopFn },
13671389
.{ .name = "__vector-pop", .f = &vectorPopFn },
13681390
.{ .name = "__subvec", .f = &subvecFn },
1391+
.{ .name = "__subvec-fast", .f = &subvecFastFn },
13691392
.{ .name = "disj", .f = &disjFn },
13701393
.{ .name = "contains?", .f = &containsQFn },
13711394
.{ .name = "get", .f = &getFn },

‎src/lang/primitive/core.zig‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -945,6 +945,28 @@ pub fn strFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation)
945945
const s = std.fmt.bufPrint(&dbuf, "{d}", .{args[0].asInteger()}) catch unreachable;
946946
return try string_mod.alloc(rt, s);
947947
}
948+
// PERF: when every arg is a string / immediate integer / nil, render into
949+
// a stack buffer: no heap writer alloc+free, no per-arg writeStrValue
950+
// switch. Output is byte-identical to writeStrValue for those tags (bare
951+
// string, decimal int, nil → ""). Anything else, or an overflow of the
952+
// buffer, takes the general path below. [refs: O-075]
953+
simple: {
954+
var sbuf: [256]u8 = undefined;
955+
var len: usize = 0;
956+
for (args) |arg| {
957+
if (arg.tag() == .string) {
958+
const s = string_mod.asString(arg);
959+
if (s.len > sbuf.len - len) break :simple;
960+
@memcpy(sbuf[len..][0..s.len], s);
961+
len += s.len;
962+
} else if (arg.isInt()) {
963+
if (sbuf.len - len < 24) break :simple;
964+
const s = std.fmt.bufPrint(sbuf[len..], "{d}", .{arg.asInteger()}) catch unreachable;
965+
len += s.len;
966+
} else if (arg.tag() != .nil) break :simple;
967+
}
968+
return try string_mod.alloc(rt, sbuf[0..len]);
969+
}
948970
var aw: std.Io.Writer.Allocating = .init(rt.gpa);
949971
defer aw.deinit();
950972
// Per-value str rendering lives in `print.writeStrValue` — the single

‎src/lang/primitive/sequence.zig‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -594,6 +594,7 @@ const ENTRIES = [_]Entry{
594594
// O-032: in-Zig chunk-map/filter drain (chunk_transform.zig) — the
595595
// producer-side analogue of reduceFn's O-004 chunk drain.
596596
.{ .name = "__chunk-map-step", .f = &chunk_transform.chunkMapStepFn },
597+
.{ .name = "__dorun", .f = &chunk_transform.dorunFn },
597598
.{ .name = "__chunk-filter-step", .f = &chunk_transform.chunkFilterStepFn },
598599
};
599600

0 commit comments

Comments
 (0)