dftracer-utils 0.0.14.post6.dev0__tar.gz → 0.0.14.post8.dev0__tar.gz

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/CHANGELOG.md

@@ -9,6 +9,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 
 ### Changed
 
+- Push `unique()` and `drop_duplicates()` into the trace scan, so a distinct row query dedups each worker's rows before they become frame rows.
+  The result keeps the first occurrence in unit order, a key column the scan cannot key exactly falls back to the host cursor, and the host `unique` cursor now keys rows by a 64-bit hash with no per-row string allocation.
+  On the 17 GB genesis sweep, `filter(gtype == "counter").select("run", "metric").unique()` takes 33.5 s instead of 592 s, uses 74 cores instead of 10 and peaks at 11.0 GB instead of 13.8 GB.
 - Find the gzip members of a trace with 16 reads in flight instead of one, and keep the `sketch` strings of genesis records out of the index build.
   The member scan of the 20.7 GB genesis sweep took about 45 s on one core, and its sketches filled the string table to about 36 GB.
   The index of the regrouped 17 GB sweep now builds in 313 to 338 s at a 5 to 8 GB peak instead of 385 s at 42 GB ([#112](https://github.com/llnl-asr/dftracer-utils/pull/112)).

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dftracer-utils
-Version: 0.0.14.post6.dev0
+Version: 0.0.14.post8.dev0
 Summary: Python binding for dftracer-utils
 Author-Email: Ray Andrew Sinurat <raydreww@gmail.com>, "Hariharan Devarajan (Hari)" <hariharandev1@llnl.gov>
 License: MIT

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/include/dftracer/utils/dataframe/lazyframe.h

@@ -280,6 +280,14 @@ class Source {
         const AggregateSpec&) const {
         return std::nullopt;
     }
+    /// Distinct rows by `subset` (empty = every column), keeping the first
+    /// occurrence in source order. The output keeps every column and its
+    /// schema. A source that accepts it must produce the first-occurrence
+    /// order itself; the planner removes the UniqueOp.
+    virtual std::optional<SourceApplication> apply_distinct(
+        const std::vector<std::string>&) const {
+        return std::nullopt;
+    }
     virtual std::optional<SourceApplication> apply_sort(const SortSpec&) const {
         return std::nullopt;
     }

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/python/dftracer/utils/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.14.post6.dev0'
-__version_tuple__ = version_tuple = (0, 0, 14, 'post6', 'dev0')
+__version__ = version = '0.0.14.post8.dev0'
+__version_tuple__ = version_tuple = (0, 0, 14, 'post8', 'dev0')
 
 __commit_id__ = commit_id = None

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/src/dftracer/utils/dataframe/agg/finalize.cpp

@@ -39,8 +39,7 @@ OccResult occ_summarize(
     o.total = total;
     o.span = te > ts ? te - ts : 0;
     if (deltas.empty()) return o;
-    std::vector<std::pair<std::uint64_t, std::int64_t>> pts(deltas.begin(),
-                                                            deltas.end());
+    std::vector<std::pair<std::uint64_t, std::int64_t>> pts = deltas.values();
     std::sort(pts.begin(), pts.end(),
               [](const auto& x, const auto& y) { return x.first < y.first; });
     std::int64_t depth = 0;

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/src/dftracer/utils/dataframe/lazy/first_rows_spill.cpp

@@ -1,4 +1,8 @@
+#include <dftracer/utils/core/common/hash/fnv1a.h>
 #include <dftracer/utils/dataframe/lazy/cursors.h>
+#include <dftracer/utils/dataframe/lazy/hash_arena.h>
+
+#include <algorithm>
 
 namespace dftracer::utils::dataframe {
 
@@ -6,43 +10,6 @@ using namespace lazy_internal;
 
 namespace {
 
-// Radix-partition `keys` by hash into `seen_p.size()` buckets, each with its
-// own running hash set, and mark keep[i] the first time each key is seen
-// (order-preserving): buckets never overlap, so each is probed by exactly one
-// worker with no lock. `seen_p` carries state across calls, bounded by the
-// distinct-key count rather than the row count. An empty `seen_p` means no
-// parallel backend is installed; the single `seen_serial` set is used instead
-// so the partition bookkeeping is never paid for nothing.
-std::vector<std::uint8_t> first_seen_mask(
-    std::vector<std::string>& keys, std::int64_t n,
-    ankerl::unordered_dense::set<std::string>& seen_serial,
-    std::vector<ankerl::unordered_dense::set<std::string>>& seen_p) {
-    std::vector<std::uint8_t> keep_mask(static_cast<std::size_t>(n), 0);
-    if (seen_p.empty()) {
-        for (std::int64_t i = 0; i < n; ++i)
-            if (seen_serial.insert(std::move(keys[static_cast<std::size_t>(i)]))
-                    .second)
-                keep_mask[static_cast<std::size_t>(i)] = 1;
-        return keep_mask;
-    }
-    const std::size_t p = seen_p.size();
-    std::vector<std::vector<std::int64_t>> buckets(p);
-    for (std::int64_t i = 0; i < n; ++i)
-        buckets[std::hash<std::string>{}(keys[static_cast<std::size_t>(i)]) % p]
-            .push_back(i);
-    parallel_for(
-        static_cast<std::int64_t>(p), 1, [&](std::int64_t pb, std::int64_t pe) {
-            for (std::int64_t g = pb; g < pe; ++g)
-                for (std::int64_t i : buckets[static_cast<std::size_t>(g)])
-                    if (seen_p[static_cast<std::size_t>(g)]
-                            .insert(
-                                std::move(keys[static_cast<std::size_t>(i)]))
-                            .second)
-                        keep_mask[static_cast<std::size_t>(i)] = 1;
-        });
-    return keep_mask;
-}
-
 // Appends cell `i` to a head_by key. Numbers encode by value, so equal numbers
 // of different numeric types (1, 1u, 1.0, and 0.0 / -0.0) share one key and
 // every NaN is one key; any other cell uses append_cell's exact bytes.
@@ -85,6 +52,10 @@ void append_value_key(std::string& key, const Series& c, std::int64_t i) {
     put('i', static_cast<std::int64_t>(read_u64(c, i)));
 }
 
+// Rows whose unique() key bytes share one buffer, and the unit of parallel
+// work that builds them.
+constexpr std::size_t KEY_CHUNK_ROWS = std::size_t{1} << 13;
+
 // Fan-out width for the partitioned first-seen dedup below.
 constexpr std::size_t DEDUP_PARTITIONS = 32;
 
@@ -456,24 +427,66 @@ class UniqueCursor : public Cursor {
         if (!spilling_) {
             while (auto m = co_await in_->next(max_rows)) {
                 const std::int64_t n = m->rows;
-                // Build the exact row keys in parallel (scalar string work,
-                // one per row, independent), then dedupe (radix-partitioned
-                // when a parallel backend is installed, else one serial set).
-                std::vector<std::string> keys(static_cast<std::size_t>(n));
+                // Build each row's key bytes once, in parallel: one buffer per
+                // chunk of rows (not one allocation per row) plus the row's
+                // offset, length and hash. The dedup below only compares them.
                 const std::vector<Series> kc = key_cols(m->columns);
-                parallel_for(n, std::int64_t{1} << 13,
-                             [&](std::int64_t b, std::int64_t e) {
-                                 for (std::int64_t i = b; i < e; ++i)
-                                     keys[static_cast<std::size_t>(i)] =
-                                         row_key(kc, i);
-                             });
-                std::vector<std::uint32_t> key_len(static_cast<std::size_t>(n));
-                for (std::int64_t i = 0; i < n; ++i)
-                    key_len[static_cast<std::size_t>(i)] =
-                        static_cast<std::uint32_t>(
-                            keys[static_cast<std::size_t>(i)].size());
-                std::vector<std::uint8_t> keep_mask =
-                    first_seen_mask(keys, n, seen_, seen_p_);
+                const auto nz = static_cast<std::size_t>(n);
+                const std::size_t nchunks =
+                    (nz + KEY_CHUNK_ROWS - 1) / KEY_CHUNK_ROWS;
+                std::vector<std::string> chunk_bytes(nchunks);
+                std::vector<std::uint64_t> hashes(nz);
+                std::vector<std::uint64_t> key_off(nz);
+                std::vector<std::uint32_t> key_len(nz);
+                parallel_for(
+                    static_cast<std::int64_t>(nchunks), 1,
+                    [&](std::int64_t cb, std::int64_t ce) {
+                        for (std::int64_t c = cb; c < ce; ++c) {
+                            std::string& buf =
+                                chunk_bytes[static_cast<std::size_t>(c)];
+                            const std::size_t lo =
+                                static_cast<std::size_t>(c) * KEY_CHUNK_ROWS;
+                            const std::size_t hi =
+                                std::min(nz, lo + KEY_CHUNK_ROWS);
+                            for (std::size_t at = lo; at < hi; ++at) {
+                                const std::size_t start = buf.size();
+                                for (const Series& col : kc)
+                                    append_cell(buf, col,
+                                                static_cast<std::int64_t>(at));
+                                key_off[at] = start;
+                                key_len[at] = static_cast<std::uint32_t>(
+                                    buf.size() - start);
+                                hashes[at] = hash::fnv1a_mix(hash::fnv1a_hash(
+                                    buf.data() + start, buf.size() - start));
+                            }
+                        }
+                    });
+                auto key_ptr = [&](std::size_t at) {
+                    return chunk_bytes[at / KEY_CHUNK_ROWS].data() +
+                           key_off[at];
+                };
+                std::vector<std::uint8_t> keep_mask(nz, 0);
+                if (seen_p_.empty()) {
+                    for (std::size_t at = 0; at < nz; ++at)
+                        if (seen_.insert(hashes[at], key_ptr(at), key_len[at]))
+                            keep_mask[at] = 1;
+                } else {
+                    const std::size_t p = seen_p_.size();
+                    std::vector<std::vector<std::size_t>> buckets(p);
+                    for (std::size_t at = 0; at < nz; ++at)
+                        buckets[hashes[at] % p].push_back(at);
+                    parallel_for(
+                        static_cast<std::int64_t>(p), 1,
+                        [&](std::int64_t pb, std::int64_t pe) {
+                            for (std::int64_t g = pb; g < pe; ++g)
+                                for (std::size_t at :
+                                     buckets[static_cast<std::size_t>(g)])
+                                    if (seen_p_[static_cast<std::size_t>(g)]
+                                            .insert(hashes[at], key_ptr(at),
+                                                    key_len[at]))
+                                        keep_mask[at] = 1;
+                        });
+                }
                 std::vector<std::int64_t> keep;
                 keep.reserve(static_cast<std::size_t>(n));
                 for (std::int64_t i = 0; i < n; ++i) {
@@ -533,18 +546,20 @@ class UniqueCursor : public Cursor {
     }
 
     bool already_seen(const std::string& key) const {
+        const std::uint64_t h =
+            hash::fnv1a_mix(hash::fnv1a_hash(key.data(), key.size()));
+        const auto len = static_cast<std::uint32_t>(key.size());
         if (!seen_p_.empty())
-            return seen_p_[std::hash<std::string>{}(key) % seen_p_.size()]
-                .contains(key);
-        return seen_.contains(key);
+            return seen_p_[h % seen_p_.size()].contains(h, key.data(), len);
+        return seen_.contains(h, key.data(), len);
     }
 
     std::unique_ptr<Cursor> in_;
     std::vector<std::string> sch_;
     std::vector<std::int64_t> key_idx_;
     std::uint64_t budget_;
-    ankerl::unordered_dense::set<std::string> seen_;
-    std::vector<ankerl::unordered_dense::set<std::string>> seen_p_;
+    HashArena seen_;
+    std::vector<HashArena> seen_p_;
     std::size_t fast_bytes_ = 0;
     std::int64_t next_row_id_ = 0;
     bool spilling_ = false;

dftracer_utils-0.0.14.post8.dev0/src/dftracer/utils/dataframe/lazy/hash_arena.h

@@ -0,0 +1,74 @@
+#ifndef DFTRACER_UTILS_DATAFRAME_LAZY_HASH_ARENA_H
+#define DFTRACER_UTILS_DATAFRAME_LAZY_HASH_ARENA_H
+
+#include <ankerl/unordered_dense.h>
+
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+namespace dftracer::utils::dataframe::lazy_internal {
+
+/// Exact first-seen state over keys the caller hashes, with no per-key heap
+/// allocation. The bytes of each distinct key live once in a growing arena and
+/// a hash maps to the chain of keys that share it, so two keys with the same
+/// hash still compare their real bytes. One entry per distinct key, never one
+/// per input row: a duplicate pays only a lookup and a compare. Not
+/// thread-safe; `hash` must be a pure function of the key bytes.
+class HashArena {
+   public:
+    /// True when `key` was not present (and is now); false on a duplicate.
+    bool insert(std::uint64_t hash, const char* key, std::uint32_t len) {
+        const auto it = head_.find(hash);
+        std::uint32_t next = 0;
+        if (it != head_.end()) {
+            next = it->second;
+            if (find_in_chain(next, key, len)) return false;
+        }
+        Node fresh;
+        fresh.off = bytes_.size();
+        fresh.len = len;
+        fresh.next = next;
+        bytes_.insert(bytes_.end(), key, key + len);
+        nodes_.push_back(fresh);
+        const auto node = static_cast<std::uint32_t>(nodes_.size());
+        if (it != head_.end())
+            it->second = node;
+        else
+            head_.emplace(hash, node);
+        return true;
+    }
+
+    bool contains(std::uint64_t hash, const char* key,
+                  std::uint32_t len) const {
+        const auto it = head_.find(hash);
+        return it != head_.end() && find_in_chain(it->second, key, len);
+    }
+
+   private:
+    struct Node {
+        std::uint64_t off;
+        std::uint32_t len;
+        std::uint32_t next;
+    };
+
+    bool find_in_chain(std::uint32_t node, const char* key,
+                       std::uint32_t len) const {
+        while (node != 0) {
+            const Node& n = nodes_[node - 1];
+            if (n.len == len &&
+                (len == 0 || std::memcmp(bytes_.data() + n.off, key, len) == 0))
+                return true;
+            node = n.next;
+        }
+        return false;
+    }
+
+    std::vector<char> bytes_;
+    std::vector<Node> nodes_;
+    ankerl::unordered_dense::map<std::uint64_t, std::uint32_t> head_;
+};
+
+}  // namespace dftracer::utils::dataframe::lazy_internal
+
+#endif  // DFTRACER_UTILS_DATAFRAME_LAZY_HASH_ARENA_H

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/src/dftracer/utils/dataframe/lazyframe.cpp

@@ -3770,6 +3770,8 @@ std::optional<SourceApplication> offer_op(const Source& source,
         schema_changing = true;
         return source.apply_aggregation(*spec);
     }
+    if (const auto* u = std::get_if<UniqueOp>(&op.node))
+        return source.apply_distinct(u->subset);
     if (const auto* o = std::get_if<SortByOp>(&op.node))
         return source.apply_sort({{o->name}, {o->descending}});
     if (const auto* o = std::get_if<SortByMultiOp>(&op.node))

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/src/dftracer/utils/plugins/fold_adapter.cpp

@@ -757,7 +757,7 @@ int host_trace_read(void* h, const char* path, dftu_stream_item_fn on_batch,
         dftracer::utils::default_runtime().run_blocking(
             "dft-plugin-trace-read", [&](CoroScope&) -> coro::CoroTask<void> {
                 dftracer::utils::json::RecordParser parser;
-                std::vector<views::detail::FoldEvent> batch_events;
+                views::detail::FoldEventBuffer batch_events;
                 namespace ix = dftracer::utils::index;
                 const ix::RecordSchema& schema = ix::detect_file_schema(p);
                 const bool by_path = schema.decoder == ix::Decoder::PATH;
@@ -768,24 +768,25 @@ int host_trace_read(void* h, const char* path, dftu_stream_item_fn on_batch,
                     [&](std::size_t,
                         const std::vector<std::string_view>& events) {
                         batch_events.clear();
-                        batch_events.reserve(events.size());
                         for (std::string_view ev : events) {
                             simdjson::padded_string ps(ev);
                             simdjson::dom::element root;
                             if (parser.parse(ps).get(root)) continue;
-                            batch_events.push_back(
-                                by_path ? views::detail::decode_record(
-                                              root, intern,
-                                              /*capture_schema=*/false, nullptr,
-                                              declared)
-                                        : views::detail::extract_fold_event(
-                                              root, intern,
-                                              /*needs_args=*/true));
+                            if (by_path)
+                                views::detail::decode_record_into(
+                                    batch_events.append(), root, intern,
+                                    /*capture_schema=*/false, nullptr,
+                                    declared);
+                            else
+                                views::detail::extract_fold_event_into(
+                                    batch_events.append(), root, intern,
+                                    /*needs_args=*/true);
                         }
                         if (batch_events.empty()) return;
                         dataframe::DataFrame df =
-                            views::detail::build_row_frame(batch_events, intern,
-                                                           {}, 1.0, by_path);
+                            views::detail::build_row_frame(
+                                batch_events.events(), intern, {}, 1.0,
+                                by_path);
                         std::vector<dftu_series*> handles;
                         handles.reserve(df.columns.size());
                         std::vector<const char*> names;

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/src/dftracer/utils/trace/views/batch_bridge.cpp

@@ -8,7 +8,7 @@ namespace dftracer::utils::trace::views::detail {
 
 namespace {
 
-dataframe::DataFrame base_frame(std::span<const FoldEvent> events,
+dataframe::DataFrame base_frame(EventRows events,
                                 const dftracer::utils::StringIntern& intern,
                                 const ColumnSpec& spec) {
     dataframe::DataFrame f = build_row_frame(events, intern, spec.select,
@@ -28,8 +28,8 @@ dataframe::DataFrame base_frame(std::span<const FoldEvent> events,
 }  // namespace
 
 dataframe::DataFrame events_to_frame(
-    std::span<const FoldEvent> events,
-    const dftracer::utils::StringIntern& intern, const ColumnSpec& spec) {
+    EventRows events, const dftracer::utils::StringIntern& intern,
+    const ColumnSpec& spec) {
     dataframe::DataFrame f = base_frame(events, intern, spec);
     if (spec.emit_dyn)
         for (auto& [name, col] :
@@ -41,8 +41,7 @@ dataframe::DataFrame events_to_frame(
 }
 
 dataframe::Morsel events_to_morsel(
-    std::span<const FoldEvent> events,
-    std::shared_ptr<dftracer::utils::StringIntern> intern,
+    EventRows events, std::shared_ptr<dftracer::utils::StringIntern> intern,
     const ColumnSpec& spec) {
     dataframe::DataFrame f = events_to_frame(events, *intern, spec);
 

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/src/dftracer/utils/trace/views/batch_bridge.h

@@ -50,14 +50,13 @@ struct ColumnSpec {
 /// `spec.select`, then the auto-numeric dyn columns appended when
 /// `spec.emit_dyn`.
 dataframe::DataFrame events_to_frame(
-    std::span<const FoldEvent> events,
-    const dftracer::utils::StringIntern& intern, const ColumnSpec& spec);
+    EventRows events, const dftracer::utils::StringIntern& intern,
+    const ColumnSpec& spec);
 
 /// The same columns as a morsel, each named in Morsel::name_ids. `intern` is
 /// shared with the morsel, which keeps it alive.
 dataframe::Morsel events_to_morsel(
-    std::span<const FoldEvent> events,
-    std::shared_ptr<dftracer::utils::StringIntern> intern,
+    EventRows events, std::shared_ptr<dftracer::utils::StringIntern> intern,
     const ColumnSpec& spec);
 
 /// The records of `batch` that `keep` accepts, in scan order. `keep` is called

{dftracer_utils-0.0.14.post6.dev0 → dftracer_utils-0.0.14.post8.dev0}/src/dftracer/utils/trace/views/fold.cpp

@@ -372,12 +372,12 @@ void FoldPortBus::clear() {
     frame.reset();
 }
 
-FoldEvent build_fold_event(const DFTracerEvent& scalars,
+void build_fold_event_into(FoldEvent& ev, const DFTracerEvent& scalars,
                            simdjson::dom::element args, bool has_args,
                            dftracer::utils::StringIntern& intern,
                            bool needs_args, DecodeHints* leaves) {
     if (!needs_args) leaves = nullptr;
-    FoldEvent ev;
+    reset_fold_event(ev);
     ev.phase = scalars.phase;
     ev.pid = scalars.pid;
     ev.tid = scalars.tid;
@@ -387,7 +387,7 @@ FoldEvent build_fold_event(const DFTracerEvent& scalars,
     if (!scalars.cat.empty()) ev.cat_id = intern.get_or_insert(scalars.cat);
     if (!scalars.name.empty()) ev.name_id = intern.get_or_insert(scalars.name);
 
-    if (!has_args) return ev;
+    if (!has_args) return;
 
     // fhash/hhash are group dimensions even for folds that want no other args,
     // so they are always harvested; the rest only when a fold asks.
@@ -416,10 +416,9 @@ FoldEvent build_fold_event(const DFTracerEvent& scalars,
             }
         }
     }
-    return ev;
 }
 
-FoldEvent extract_fold_event(simdjson::dom::element root,
+void extract_fold_event_into(FoldEvent& ev, simdjson::dom::element root,
                              dftracer::utils::StringIntern& intern,
                              bool needs_args,
                              const std::vector<std::string>* extra_fields,
@@ -427,8 +426,10 @@ FoldEvent extract_fold_event(simdjson::dom::element root,
     DFTracerEvent scalars;
     simdjson::dom::element args;
     bool has_args = false;
-    if (!DFTracerEvent::parse_scalars(root, scalars, args, has_args))
-        return FoldEvent{};
+    if (!DFTracerEvent::parse_scalars(root, scalars, args, has_args)) {
+        reset_fold_event(ev);
+        return;
+    }
     // An empty or non-object args is left to the leaf walk, which records it.
     simdjson::dom::object args_obj;
     DecodeHints* leaves =
@@ -437,14 +438,13 @@ FoldEvent extract_fold_event(simdjson::dom::element root,
                 args_obj.size() > 0
             ? hints
             : nullptr;
-    FoldEvent ev =
-        build_fold_event(scalars, args, has_args, intern, needs_args, leaves);
+    build_fold_event_into(ev, scalars, args, has_args, intern, needs_args,
+                          leaves);
     if (extra_fields)
         for (const auto& name : *extra_fields)
             capture_extra_field(ev, root, intern, name);
     if (capture_schema)
         capture_schema_leaves(ev, root, intern, leaves != nullptr);
-    return ev;
 }
 
 namespace {
@@ -770,14 +770,15 @@ void decode_leaves(std::string& path, simdjson::dom::element v, LeafDecode& d) {
 
 }  // namespace
 
-FoldEvent decode_record(
-    simdjson::dom::element root, dftracer::utils::StringIntern& intern,
-    bool capture_schema, const std::vector<std::string>* paths,
+void decode_record_into(
+    FoldEvent& ev, simdjson::dom::element root,
+    dftracer::utils::StringIntern& intern, bool capture_schema,
+    const std::vector<std::string>* paths,
     const dftracer::utils::index::RecordSchema* record_schema,
     const std::vector<const dftracer::utils::index::FieldSpec*>* path_fields,
     std::size_t max_children, DecodeHints* hints, bool skip_never_indexed) {
     namespace ix = dftracer::utils::index;
-    FoldEvent ev;
+    reset_fold_event(ev);
     ev.phase = RecordPhase::COMPLETE;
     ev.by_path = true;
     const auto* fields = paths ? path_fields : nullptr;
@@ -799,10 +800,11 @@ FoldEvent decode_record(
                  hints,
                  skip_never_indexed};
     if (hints) ev.args.reserve(hints->args);
-    std::string path;
+    std::string local_path;
+    std::string& path = hints ? hints->path : local_path;
+    path.clear();
     decode_leaves(path, root, d);
     if (hints) hints->args = ev.args.size();
-    return ev;
 }
 
 void capture_schema_leaves(FoldEvent& ev, simdjson::dom::element root,
@@ -898,6 +900,7 @@ coro::CoroTask<void> for_slices(std::vector<std::unique_ptr<Fold>>& slices,
 coro::CoroTask<void> fuse_worker(FuseWorkerCtx ctx, std::size_t w) {
     auto& slices = ctx.fslice[w];
     FoldPortBus bus;
+    FoldEventBuffer fold_buffer;
     for (auto& s : slices) s->bind_port_bus(&bus);
     PendingCoverage pending(ctx.covered_v[w]);
 
@@ -937,6 +940,7 @@ coro::CoroTask<void> fuse_worker(FuseWorkerCtx ctx, std::size_t w) {
         // A FoldEvent fold gets the parsed stream; a raw fold parses the lines
         // itself. When both are present, keep both.
         sin.fold_intern = ctx.any_wants_fold_event ? &ctx.intern : nullptr;
+        sin.fold_buffer = &fold_buffer;
         sin.fold_needs_args = ctx.any_needs_args;
         sin.fold_keep_raw = ctx.any_wants_raw && ctx.any_wants_fold_event;
         sin.fold_capture_schema = ctx.any_wants_schema;