From d30a6bce3203496cc7a09f62161b1b907c9a457d Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Fri, 13 Nov 2026 01:34:31 -0800 Subject: [PATCH 1/6] docs(itl-1061): WIP counters and first sync job counts Co-Authored-By: Claude Opus 5.5 --- .../plans/2026-11-13-itl-1061-rerun-cost.md | 43 +++ superpowers/specs/itl-1061/counters.py | 246 ++++++++++++++++++ superpowers/specs/itl-1061/rerun_counts.py | 225 ++++++++++++++++ 3 files changed, 514 insertions(+) create mode 100644 superpowers/plans/2026-11-13-itl-1061-rerun-cost.md create mode 100644 superpowers/specs/itl-1061/counters.py create mode 100644 superpowers/specs/itl-1061/rerun_counts.py diff --git a/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md b/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md new file mode 100644 index 000000000..6eba38cf4 --- /dev/null +++ b/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md @@ -0,0 +1,43 @@ +# ITL-1061 re-run cost investigation plan + +> **For agentic workers:** investigation only. No change under `src/` or `tests/`. Scripts go +> under `superpowers/specs/itl-1061/`, the report goes in `superpowers/specs/2026-11-13-itl-1061-rerun-cost.md`. + +**Goal:** Pinpoint, with counters and file:line references, where a second run of an unchanged +pipeline does work again, measured against the developer's model (each node holds a timestamped +in-memory cache; a re-run with no newer upstream is instantaneous). + +**Architecture:** One instrumentation module (`counters.py`) monkeypatches the library at run time +and counts calls per node. One driver (`rerun_counts.py`) builds a workshop-shaped pipeline (two +`ArrowTableSource`s of a few thousand rows, drop_nulls, group_by, map_tags, join, two function pods) +and runs it through each path twice, printing a table of counts per run. + +**Tech stack:** `uv run python`, pyarrow, orcapod at `origin/main` (97263e5b); optionally PR #355 +(963310fb) in a scratch worktree. + +**Constraints:** one python process at a time, small inputs, no test suites, no live Spiral. + +--- + +### Task 1: Read the code paths +- [ ] Orchestrators: `pipeline/sync_orchestrator.py`, `pipeline/async_orchestrator.py`, `pipeline/job.py`, `pipeline/graph.py` +- [ ] Nodes: `core/nodes/source_node.py`, `operator_node.py`, `function_node.py` +- [ ] Streams: `core/streams/base.py` (`is_stale`, `last_modified`), `core/static_output_pod.py`, `core/function_pod.py` +- [ ] Sources: `arrow_table_source.py`, `dict_source.py`, `csv_source.py`, `delta_table_source.py`, Spiral source, polling sources + +### Task 2: Counters and driver +- [ ] `superpowers/specs/itl-1061/counters.py`: patch functions with wrappers that increment `Counter[(label, node)]` +- [ ] `superpowers/specs/itl-1061/rerun_counts.py`: paths (a) lazy streams read twice, (b) `PipelineJob.run()` twice sync and async, (c) new job same store, (d) `Pipeline.run()` +- [ ] Run each once (`uv run python superpowers/specs/itl-1061/rerun_counts.py `), save output under `superpowers/specs/itl-1061/out/` +- [ ] Commit WIP and push + +### Task 3: PR #355 comparison (lazy path only) +- [ ] Scratch worktree at 963310fb, run path (a) there, record commit + +### Task 4: History +- [ ] `git log -S is_stale`, `-S _cached_output_stream`, `--follow` on orchestrators / nodes; v0.1.x tags + +### Task 5: Headline findings to coordinator, then the report (<500 lines), then PR (docs only, Refs ITL-1061) + +## Notes for a successor +(update as work proceeds) diff --git a/superpowers/specs/itl-1061/counters.py b/superpowers/specs/itl-1061/counters.py new file mode 100644 index 000000000..50761115f --- /dev/null +++ b/superpowers/specs/itl-1061/counters.py @@ -0,0 +1,246 @@ +"""Count what a pipeline run does, per node, by monkeypatching orcapod at run time (ITL-1061). + +Investigation aid only: nothing under ``src/`` is changed. ``install()`` wraps library +functions with counting wrappers; every count is attributed to the node whose +``execute`` / ``async_execute`` is running (a ``ContextVar``, so async tasks keep their +own node), or to ``-`` outside any node (lazy streams, the orchestrator itself). + +Metrics (one row each in the report): + +- ``node.execute``: calls of a node's ``execute`` / ``async_execute``. +- ``rows.out``: rows a sync ``execute`` returned (the orchestrator's buffer). +- ``source.iter``: ``iter_data`` calls on a concrete source (a read of the source). +- ``spiral.scan``: scans a ``SpiralDBTableSource`` started (``_batch_streams``). +- ``record_id``: per-row source record ids built (``stream_builder._make_record_id``). +- ``base_entry_id``: per-row function-node entry ids (``compute_base_entry_id``). +- ``hash_table``: Arrow table hashes (``SemanticArrowHasher.hash_table``); per-row + data hashes, entry ids and source table hashes all go through it. +- ``Tag.new`` / ``Data.new``: datagram objects constructed. +- ``ats.new``: ``ArrowTableStream`` objects constructed. +- ``ats.iter.build`` / ``ats.iter.cached``: ``ArrowTableStream.iter_data`` calls that + built per-row Tag/Data objects vs. served its ``_cached_elements``. +- ``op.static_process``: operator computations (``static_process`` of any operator). +- ``op.process``: ``StaticOutputOperatorPod.process`` (a new ``DynamicPodStream``). +- ``rows_to_table`` / ``materialize_to_stream`` / ``hstack_tables``: table rebuilds. +- ``fn.call``: user function bodies run (counted by the driver's functions). +- ``db.read`` / ``db.write`` / ``db.flush``: store calls. +""" + +from __future__ import annotations + +import contextvars +import functools +import inspect +from collections import Counter, defaultdict +from typing import Any, Callable + +NODE: contextvars.ContextVar[str] = contextvars.ContextVar("node", default="-") +COUNTS: defaultdict[str, Counter[str]] = defaultdict(Counter) + + +def bump(metric: str, n: int = 1) -> None: + """Add ``n`` to ``metric`` for the node now running.""" + COUNTS[NODE.get()][metric] += n + + +def reset() -> None: + """Forget every count.""" + COUNTS.clear() + + +def snapshot() -> dict[str, dict[str, int]]: + """Return a copy of the counts, per node.""" + return {node: dict(c) for node, c in COUNTS.items()} + + +def _wrap(owner: Any, name: str, metric: str | Callable[..., str]) -> None: + """Replace ``owner.name`` with a wrapper that counts each call.""" + raw = owner.__dict__[name] + is_static = isinstance(raw, staticmethod) + func = raw.__func__ if is_static else raw + + if inspect.isgeneratorfunction(func): + + @functools.wraps(func) + def gen_wrapper(*args, **kwargs): + bump(metric if isinstance(metric, str) else metric(*args, **kwargs)) + yield from func(*args, **kwargs) + + wrapper: Callable[..., Any] = gen_wrapper + else: + + @functools.wraps(func) + def wrapper(*args, **kwargs): + bump(metric if isinstance(metric, str) else metric(*args, **kwargs)) + return func(*args, **kwargs) + + setattr(owner, name, staticmethod(wrapper) if is_static else wrapper) + + +def _wrap_node(owner: Any, name: str) -> None: + """Count a node's ``execute`` / ``async_execute`` and attribute nested counts to it.""" + func = owner.__dict__[name] + if inspect.iscoroutinefunction(func): + + @functools.wraps(func) + async def async_wrapper(self, *args, **kwargs): + token = NODE.set(self.label) + try: + bump("node.execute") + return await func(self, *args, **kwargs) + finally: + NODE.reset(token) + + setattr(owner, name, async_wrapper) + return + + @functools.wraps(func) + def wrapper(self, *args, **kwargs): + token = NODE.set(self.label) + try: + bump("node.execute") + out = func(self, *args, **kwargs) + if isinstance(out, list): + bump("rows.out", len(out)) + return out + finally: + NODE.reset(token) + + setattr(owner, name, wrapper) + + +def install() -> None: + """Patch the library with the counting wrappers (idempotent per process: call once).""" + from orcapod.core.datagrams.tag_data import Data, Tag + from orcapod.core.nodes import function_node, operator_node, source_node + from orcapod.core.operators import static_output_pod as sop + from orcapod.core.operators.base import ( + BinaryOperator, + NonZeroInputOperator, + UnaryOperator, + ) + from orcapod.core.operators.join import Join + from orcapod.core.sources import stream_builder + from orcapod.core.sources.base import RootSource + from orcapod.core.sources.spiraldb_table_source import SpiralDBTableSource + from orcapod.core.streams.arrow_table_stream import ArrowTableStream + from orcapod.databases.delta_lake_databases import DeltaTableDatabase + from orcapod.databases.in_memory_databases import InMemoryArrowDatabase + from orcapod.hashing import arrow_hashers + from orcapod.utils import arrow_utils + + node_classes = [ + getattr(module, name) + for module in (function_node, operator_node, source_node) + for name in dir(module) + if name.endswith(("Node", "NodeBase")) + and isinstance(getattr(module, name), type) + and getattr(module, name).__module__ == module.__name__ + ] + for cls in node_classes: + for name in ("execute", "async_execute"): + if name in cls.__dict__: + _wrap_node(cls, name) + + _wrap(Tag, "__init__", "Tag.new") + _wrap(Data, "__init__", "Data.new") + _wrap(ArrowTableStream, "__init__", "ats.new") + _wrap( + ArrowTableStream, + "iter_data", + lambda self: "ats.iter.cached" + if self._cached_elements is not None + else "ats.iter.build", + ) + _wrap(RootSource, "iter_data", "source.iter") + _wrap(SpiralDBTableSource, "iter_data", "source.iter") + _wrap(SpiralDBTableSource, "_batch_streams", "spiral.scan") + + original_record_id = stream_builder._make_record_id + + def counted_record_id(*args, **kwargs): + bump("record_id") + return original_record_id(*args, **kwargs) + + stream_builder._make_record_id = counted_record_id + + for cls in node_classes: + if "compute_base_entry_id" in cls.__dict__: + _wrap(cls, "compute_base_entry_id", "base_entry_id") + for cls_name in dir(arrow_hashers): + cls = getattr(arrow_hashers, cls_name) + if isinstance(cls, type) and "hash_table" in cls.__dict__: + _wrap(cls, "hash_table", "hash_table") + + for cls in (UnaryOperator, BinaryOperator, NonZeroInputOperator, Join): + if "static_process" in cls.__dict__: + _wrap(cls, "static_process", "op.static_process") + _wrap(sop.StaticOutputOperatorPod, "process", "op.process") + _wrap(sop.StaticOutputOperatorPod, "_rows_to_table", "rows_to_table") + _wrap(sop.StaticOutputOperatorPod, "_materialize_to_stream", "materialize_to_stream") + + original_hstack = arrow_utils.hstack_tables + + def counted_hstack(*args, **kwargs): + bump("hstack_tables") + return original_hstack(*args, **kwargs) + + arrow_utils.hstack_tables = counted_hstack + + for db in (InMemoryArrowDatabase, DeltaTableDatabase): + for name in ("add_record", "add_records"): + if name in db.__dict__: + _wrap(db, name, "db.write") + for name in ( + "get_all_records", + "get_records_by_ids", + "get_record_by_id", + "get_records_with_column_value", + ): + if name in db.__dict__: + _wrap(db, name, "db.read") + if "flush" in db.__dict__: + _wrap(db, "flush", "db.flush") + + +METRICS = ( + "node.execute", + "rows.out", + "source.iter", + "spiral.scan", + "record_id", + "base_entry_id", + "hash_table", + "Tag.new", + "Data.new", + "ats.new", + "ats.iter.build", + "ats.iter.cached", + "op.process", + "op.static_process", + "rows_to_table", + "materialize_to_stream", + "hstack_tables", + "fn.call", + "db.read", + "db.write", + "db.flush", +) + + +def report(title: str, counts: dict[str, dict[str, int]]) -> str: + """Format ``counts`` as a table: one column per node, one row per metric.""" + nodes = sorted(counts, key=lambda n: (n == "-", n)) + width = max(12, *(len(n) for n in nodes)) if nodes else 12 + lines = [f"### {title}", ""] + header = f"{'metric':<22}" + "".join(f"{n:>{width + 2}}" for n in nodes) + header += f"{'TOTAL':>{width + 2}}" + lines.append(header) + for metric in METRICS: + values = [counts[n].get(metric, 0) for n in nodes] + if not any(values): + continue + row = f"{metric:<22}" + "".join(f"{v:>{width + 2}}" for v in values) + row += f"{sum(values):>{width + 2}}" + lines.append(row) + return "\n".join(lines) + "\n" diff --git a/superpowers/specs/itl-1061/rerun_counts.py b/superpowers/specs/itl-1061/rerun_counts.py new file mode 100644 index 000000000..3cd4c2b36 --- /dev/null +++ b/superpowers/specs/itl-1061/rerun_counts.py @@ -0,0 +1,225 @@ +"""Count the work of a first and a second run of one workshop-shaped pipeline (ITL-1061). + +Usage (one mode per process; run them one after the other, never in parallel): + + uv run python superpowers/specs/itl-1061/rerun_counts.py lazy + uv run python superpowers/specs/itl-1061/rerun_counts.py job-sync + uv run python superpowers/specs/itl-1061/rerun_counts.py job-async + uv run python superpowers/specs/itl-1061/rerun_counts.py spiral-sync + uv run python superpowers/specs/itl-1061/rerun_counts.py spiral-async + uv run python superpowers/specs/itl-1061/rerun_counts.py delta # twice: new process + +The pipeline has the workshop's shape: two sources (sessions: 2,000 rows; experiments: +6,000 rows, some ``total`` null), ``drop_nulls`` -> ``group_by`` -> ``map_tags`` on the +experiments, ``join`` with the sessions, then two function pods. ``ArrowTableSource`` by +default; the ``spiral-*`` modes read the same tables through ``SpiralDBTableSource`` over the +repository's disk-backed pyspiral fake (``tests/test_databases/fake_pyspiral.py``). + +Each run prints a table of counters per node (see ``counters.py``). Nothing under ``src/`` +is changed: the counters are monkeypatched in at start. +""" + +from __future__ import annotations + +import sys +import tempfile +from pathlib import Path + +REPO = Path(__file__).resolve().parents[3] +sys.path.insert(0, str(REPO)) +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +import counters # noqa: E402 +import pyarrow as pa # noqa: E402 + +N_SUBJECTS = 200 +N_SESSIONS = 10 # per subject: 2,000 session rows +N_EXPERIMENTS = 3 # per session: 6,000 experiment rows +PROJECT = "itl1061" + + +def tables() -> tuple[pa.Table, pa.Table]: + """Return the sessions and experiments tables.""" + subj, sess, booth = [], [], [] + e_subj, e_sess, e_idx, correct, total = [], [], [], [], [] + for s in range(N_SUBJECTS): + for k in range(N_SESSIONS): + subj.append(f"m{s:04d}") + sess.append(k) + booth.append(f"b{(s + k) % 7}") + for e in range(N_EXPERIMENTS): + e_subj.append(f"m{s:04d}") + e_sess.append(k) + e_idx.append(e) + correct.append((s + k + e) % 10) + total.append(None if (s + k + e) % 13 == 0 else 10) + sessions = pa.table( + { + "subject_id": pa.array(subj, pa.large_string()), + "session": pa.array(sess, pa.int64()), + "booth": pa.array(booth, pa.large_string()), + } + ) + experiments = pa.table( + { + "subject_id": pa.array(e_subj, pa.large_string()), + "session": pa.array(e_sess, pa.int64()), + "experiment_index": pa.array(e_idx, pa.int64()), + "correct": pa.array(correct, pa.int64()), + "total": pa.array(total, pa.int64()), + } + ) + return sessions, experiments + + +def make_pods(): + """Return the two function pods; each body counts its calls.""" + from orcapod import function_pod + + @function_pod(output_keys="accuracy") + def accuracy(correct: list[int], total: list[int]) -> float: + counters.bump("fn.call") + return sum(correct) / sum(total) + + @function_pod(output_keys="grade") + def grade(accuracy: float) -> str: + counters.bump("fn.call") + return "pass" if accuracy >= 0.5 else "fail" + + return accuracy, grade + + +def arrow_sources(): + """Return the two sources as ``ArrowTableSource``s with fixed ids.""" + from orcapod.sources import ArrowTableSource + + sessions, experiments = tables() + return ( + ArrowTableSource(sessions, tag_columns=["subject_id", "session"], source_id="sessions"), + ArrowTableSource( + experiments, + tag_columns=["subject_id", "session", "experiment_index"], + source_id="experiments", + ), + ) + + +def spiral_sources(root: Path): + """Write both tables to a pyspiral fake under ``root`` and return Spiral sources.""" + from orcapod.sources import SpiralDBTableSource + from tests.test_databases import fake_pyspiral + + sessions, experiments = tables() + project = fake_pyspiral.FakeSpiral().project(PROJECT) + s = project.create_table("default.sessions", key_schema=sessions.select(["subject_id", "session"]).schema) + s.write(sessions) + e = project.create_table( + "default.experiments", + key_schema=experiments.select(["subject_id", "session", "experiment_index"]).schema, + ) + e.write(experiments) + return ( + SpiralDBTableSource(PROJECT, "sessions", source_id="sessions"), + SpiralDBTableSource(PROJECT, "experiments", source_id="experiments"), + ) + + +def build(sessions, experiments, pods): + """Apply the workshop-shaped steps; return the last stream.""" + accuracy, grade = pods + exp = experiments.drop_nulls(["correct", "total"], label="drop_nulls") + grouped = exp.group_by(["subject_id", "session"], label="group_by") + mapped = grouped.map_tags({"experiment_index": "experiment_indices"}, label="map_tags") + joined = sessions.join(mapped, label="join") + acc = accuracy.pod(joined, label="accuracy") + return grade.pod(acc, label="grade") + + +def run_counted(title: str, action) -> None: + """Run ``action`` with fresh counters and print the table.""" + counters.reset() + action() + print(counters.report(title, counters.snapshot()), flush=True) + + +def mode_lazy(sources) -> None: + """Lazy streams, no job: read the last stream twice (as_table, iter_data, head).""" + pods = make_pods() + out = build(*sources, pods) + run_counted("lazy: first as_table()", lambda: out.as_table()) + run_counted("lazy: second as_table()", lambda: out.as_table()) + run_counted("lazy: list(iter_data())", lambda: list(out.iter_data())) + run_counted("lazy: head()", lambda: out.head()) + # A second chain built over the same source objects (what a notebook re-run does). + out2 = build(*sources, pods) + run_counted("lazy: same steps rebuilt, as_table()", lambda: out2.as_table()) + + +def mode_job(sources, orchestrator_factory, store=None, runs: int = 2) -> None: + """PipelineJob.run() ``runs`` times on one job, then once on a new job, same store.""" + from orcapod import PipelineJob + from orcapod.databases import InMemoryArrowDatabase + + store = store if store is not None else InMemoryArrowDatabase() + pods = make_pods() + + def new_job(): + job = PipelineJob(name="ws", store=store) + with job: + build(*sources, pods) + return job + + job = new_job() + for i in range(runs): + run_counted( + f"job.run() #{i + 1}, same job object", + lambda: job.run(orchestrator=orchestrator_factory()), + ) + run_counted( + "reading job.nodes['grade'].as_table() after the runs", + lambda: job.nodes["grade"].as_table(), + ) + job2 = new_job() + run_counted( + "job.run() on a NEW job object, same store", + lambda: job2.run(orchestrator=orchestrator_factory()), + ) + + +def main() -> None: + mode = sys.argv[1] + counters.install() + from orcapod.pipeline.async_orchestrator import AsyncPipelineOrchestrator + from orcapod.pipeline.sync_orchestrator import SyncPipelineOrchestrator + + if mode == "lazy": + mode_lazy(arrow_sources()) + elif mode == "job-sync": + mode_job(arrow_sources(), SyncPipelineOrchestrator) + elif mode == "job-async": + mode_job(arrow_sources(), AsyncPipelineOrchestrator) + elif mode in ("spiral-sync", "spiral-async", "spiral-lazy"): + from tests.test_databases import fake_pyspiral + + with tempfile.TemporaryDirectory() as tmp, fake_pyspiral.install(Path(tmp)): + sources = spiral_sources(Path(tmp)) + if mode == "spiral-lazy": + mode_lazy(sources) + else: + orch = ( + SyncPipelineOrchestrator + if mode == "spiral-sync" + else AsyncPipelineOrchestrator + ) + mode_job(sources, orch) + elif mode == "delta": + from orcapod.databases import DeltaTableDatabase + + store = DeltaTableDatabase(sys.argv[2]) + mode_job(arrow_sources(), SyncPipelineOrchestrator, store=store, runs=1) + else: + raise SystemExit(f"unknown mode {mode!r}") + + +if __name__ == "__main__": + main() From 8cff5eb73e8c602a85ee0c7116d3417b3a609b3c Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Fri, 13 Nov 2026 01:40:39 -0800 Subject: [PATCH 2/6] docs(itl-1061): WIP counts for every run path, PR #355 comparison Co-Authored-By: Claude Opus 5.5 --- superpowers/specs/itl-1061/counters.py | 6 ++- superpowers/specs/itl-1061/rerun_counts.py | 3 ++ .../specs/itl-1061/spiral_hash_callers.py | 54 +++++++++++++++++++ 3 files changed, 62 insertions(+), 1 deletion(-) create mode 100644 superpowers/specs/itl-1061/spiral_hash_callers.py diff --git a/superpowers/specs/itl-1061/counters.py b/superpowers/specs/itl-1061/counters.py index 50761115f..bdb8199f0 100644 --- a/superpowers/specs/itl-1061/counters.py +++ b/superpowers/specs/itl-1061/counters.py @@ -169,7 +169,11 @@ def counted_record_id(*args, **kwargs): _wrap(cls, "compute_base_entry_id", "base_entry_id") for cls_name in dir(arrow_hashers): cls = getattr(arrow_hashers, cls_name) - if isinstance(cls, type) and "hash_table" in cls.__dict__: + if ( + isinstance(cls, type) + and cls.__module__ == arrow_hashers.__name__ # not starfix's digester + and "hash_table" in cls.__dict__ + ): _wrap(cls, "hash_table", "hash_table") for cls in (UnaryOperator, BinaryOperator, NonZeroInputOperator, Join): diff --git a/superpowers/specs/itl-1061/rerun_counts.py b/superpowers/specs/itl-1061/rerun_counts.py index 3cd4c2b36..2b9eed2d6 100644 --- a/superpowers/specs/itl-1061/rerun_counts.py +++ b/superpowers/specs/itl-1061/rerun_counts.py @@ -110,6 +110,9 @@ def spiral_sources(root: Path): from tests.test_databases import fake_pyspiral sessions, experiments = tables() + # The fake hands out 2-row batches by default; SpiralDB's follow its stored + # fragments. 1,024 rows keeps per-batch counts from swamping per-row ones. + fake_pyspiral.scan_batch_rows = 1024 project = fake_pyspiral.FakeSpiral().project(PROJECT) s = project.create_table("default.sessions", key_schema=sessions.select(["subject_id", "session"]).schema) s.write(sessions) diff --git a/superpowers/specs/itl-1061/spiral_hash_callers.py b/superpowers/specs/itl-1061/spiral_hash_callers.py new file mode 100644 index 000000000..6beb78452 --- /dev/null +++ b/superpowers/specs/itl-1061/spiral_hash_callers.py @@ -0,0 +1,54 @@ +"""Name the callers of the Arrow hasher during one read of a SpiralDBTableSource (ITL-1061). + + uv run python superpowers/specs/itl-1061/spiral_hash_callers.py +""" + +from __future__ import annotations + +import sys +import tempfile +import traceback +from collections import Counter +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[3])) +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +import rerun_counts # noqa: E402 + +from orcapod.hashing import arrow_hashers # noqa: E402 +from tests.test_databases import fake_pyspiral # noqa: E402 + +callers: Counter[str] = Counter() +original = arrow_hashers.StarfixArrowHasher.hash_table + + +def counted(self, table): + frames = traceback.extract_stack(limit=6)[:-1] + callers[" <- ".join(f"{Path(f.filename).name}:{f.lineno}:{f.name}" for f in frames[::-1][:3])] += 1 + return original(self, table) + + +arrow_hashers.StarfixArrowHasher.hash_table = counted + +with tempfile.TemporaryDirectory() as tmp, fake_pyspiral.install(Path(tmp)): + sessions, experiments = rerun_counts.spiral_sources(Path(tmp)) + callers.clear() + rows = list(experiments.iter_data()) + print(f"one read of experiments: {len(rows)} rows") + for where, n in callers.most_common(): + print(f"{n:>7} {where}") + + # The same source inside a job: what the source node's execute hashes on a re-run. + from orcapod import PipelineJob + from orcapod.databases import InMemoryArrowDatabase + + job = PipelineJob(name="ws", store=InMemoryArrowDatabase()) + with job: + rerun_counts.build(sessions, experiments, rerun_counts.make_pods()) + job.run() + callers.clear() + job.run() + print("second job.run(): hash_table callers (top 8)") + for where, n in callers.most_common(8): + print(f"{n:>7} {where}") From d1825894a1fe8ed59411095807cf3d0fd8588132 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Fri, 13 Nov 2026 01:59:42 -0800 Subject: [PATCH 3/6] docs(itl-1061): report on where a re-run of an unchanged pipeline does work again Counters per node for lazy streams, PipelineJob.run() sync and async, a new job on the same store and a new process on a Delta store, over an ArrowTableSource and the pyspiral fake; node state and staleness after each run; history of the run path; options for an instantaneous re-run. Refs ITL-1061 Co-Authored-By: Claude Opus 5.5 --- .../plans/2026-11-13-itl-1061-rerun-cost.md | 25 +- .../specs/2026-11-13-itl-1061-rerun-cost.md | 433 ++++++++++++++++++ superpowers/specs/itl-1061/counters.py | 14 +- superpowers/specs/itl-1061/node_state.py | 97 ++++ superpowers/specs/itl-1061/profile_runs.py | 71 +++ superpowers/specs/itl-1061/rerun_counts.py | 24 +- .../specs/itl-1061/spiral_hash_callers.py | 10 +- 7 files changed, 647 insertions(+), 27 deletions(-) create mode 100644 superpowers/specs/2026-11-13-itl-1061-rerun-cost.md create mode 100644 superpowers/specs/itl-1061/node_state.py create mode 100644 superpowers/specs/itl-1061/profile_runs.py diff --git a/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md b/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md index 6eba38cf4..cede048a9 100644 --- a/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md +++ b/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md @@ -20,24 +20,27 @@ and runs it through each path twice, printing a table of counts per run. --- ### Task 1: Read the code paths -- [ ] Orchestrators: `pipeline/sync_orchestrator.py`, `pipeline/async_orchestrator.py`, `pipeline/job.py`, `pipeline/graph.py` -- [ ] Nodes: `core/nodes/source_node.py`, `operator_node.py`, `function_node.py` -- [ ] Streams: `core/streams/base.py` (`is_stale`, `last_modified`), `core/static_output_pod.py`, `core/function_pod.py` -- [ ] Sources: `arrow_table_source.py`, `dict_source.py`, `csv_source.py`, `delta_table_source.py`, Spiral source, polling sources +- [x] Orchestrators: `pipeline/sync_orchestrator.py`, `pipeline/async_orchestrator.py`, `pipeline/job.py`, `pipeline/graph.py` +- [x] Nodes: `core/nodes/source_node.py`, `operator_node.py`, `function_node.py` +- [x] Streams: `core/streams/base.py` (`is_stale`, `last_modified`), `core/static_output_pod.py`, `core/function_pod.py` +- [x] Sources: `arrow_table_source.py`, `dict_source.py`, `csv_source.py`, `delta_table_source.py`, Spiral source, polling sources ### Task 2: Counters and driver -- [ ] `superpowers/specs/itl-1061/counters.py`: patch functions with wrappers that increment `Counter[(label, node)]` -- [ ] `superpowers/specs/itl-1061/rerun_counts.py`: paths (a) lazy streams read twice, (b) `PipelineJob.run()` twice sync and async, (c) new job same store, (d) `Pipeline.run()` -- [ ] Run each once (`uv run python superpowers/specs/itl-1061/rerun_counts.py `), save output under `superpowers/specs/itl-1061/out/` -- [ ] Commit WIP and push +- [x] `superpowers/specs/itl-1061/counters.py`: patch functions with wrappers that increment `Counter[(label, node)]` +- [x] `superpowers/specs/itl-1061/rerun_counts.py`: paths (a) lazy streams read twice, (b) `PipelineJob.run()` twice sync and async, (c) new job same store, (d) `Pipeline.run()` +- [x] Run each once (`uv run python superpowers/specs/itl-1061/rerun_counts.py `), save output under `superpowers/specs/itl-1061/out/` +- [x] Commit WIP and push ### Task 3: PR #355 comparison (lazy path only) -- [ ] Scratch worktree at 963310fb, run path (a) there, record commit +- [x] Scratch worktree at 963310fb, run path (a) there, record commit ### Task 4: History -- [ ] `git log -S is_stale`, `-S _cached_output_stream`, `--follow` on orchestrators / nodes; v0.1.x tags +- [x] `git log -S is_stale`, `-S _cached_output_stream`, `--follow` on orchestrators / nodes; v0.1.x tags ### Task 5: Headline findings to coordinator, then the report (<500 lines), then PR (docs only, Refs ITL-1061) ## Notes for a successor -(update as work proceeds) +- Done 2026-11-13: report at `superpowers/specs/2026-11-13-itl-1061-rerun-cost.md`, raw output in + `superpowers/specs/itl-1061/out/`. Branch merged with origin/main 89160c47 (PR #355 included). +- Headline findings sent to the coordinator (orchestration status message). +- The developer decided the job-path fix lands after the v0.3.0 tag. diff --git a/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md b/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md new file mode 100644 index 000000000..37fa6df2f --- /dev/null +++ b/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md @@ -0,0 +1,433 @@ +# ITL-1061: why re-running an unchanged pipeline is not instantaneous + +Investigation only; no library change. Code references are to `main` at `89160c47`, which +includes PR #355 (ITL-1042/1052) and #352 (ITL-1043). Counts were taken on `97263e5b`, on PR +#355's head `963310fb`, and again on `89160c47`. The job-path counts are identical on all three +builds. The scripts and their raw output are in `superpowers/specs/itl-1061/` (see +[Reproducing](#reproducing)). + +## Summary + +**The developer's model** (ITL-1061): every node or stream keeps a timestamped in-memory cache +of its results. A newer upstream timestamp invalidates the cache, and the node recomputes or +reloads from the store. So after the first run, a re-run of an unchanged pipeline costs almost +nothing. + +**Is it implemented?** + +| Way of running | Implemented? | Where it stops holding | +|---|---|---| +| (a) Lazy streams read twice (`as_table`, `iter_data`, `head`) | **Yes on `main` since PR #355** (merged today). Every re-read costs 0. On `97263e5b`, `iter_data()` after `as_table()` re-ran the last pod (2,000 calls) because a chained pod stream was falsely stale. | Holds. Rebuilding the same steps as new stream objects recomputes everything, which is expected: new objects hold no cache. | +| (b) `PipelineJob.run()` twice on the same job, sync and async | **No.** Run #2 repeats everything except the function calls and the store writes. | The orchestrators never ask a node whether it is current: a **bypass**, not a bust. | +| (c) A new `PipelineJob` on the same store | **No.** It costs the same as (b) run #2, plus 4 store reads. | Same bypass. In-memory caches belong to node objects, so a new job has none to reuse; only the store can serve it. | +| (d) `Pipeline.run()` | `Pipeline` has no `run()` since PR #138 (ENG-456, 2026-05-20). The developer's "pipeline.run" is `PipelineJob.run()` today, which is row (b). | — | + +**What run #2 of an unchanged job does** (sync, same job object, workshop-shaped pipeline of +2,000 + 6,000 rows; full tables in [A](#a-per-path-counts)): +- all 9 nodes execute again; +- 5 operator computations; +- 25,543 rows materialized into Python lists; +- 17,543 `Tag` and 17,543 `Data` objects built; +- 13 table rebuilds from rows; +- 4,000 function-node entry ids and 8,000 Arrow hashes; +- 0 function calls and 0 store writes. + +With `SpiralDBTableSource`, add per run: 2 new scans, 8,000 record ids, 8,000 per-row key +hashes, and 8,000 more `Tag` and `Data` objects. + +**Bypasses** (a cache exists and is not consulted): +1. **B1** `SyncPipelineOrchestrator.run` (`pipeline/sync_orchestrator.py:86-122`) and + `AsyncPipelineOrchestrator` (`async_orchestrator.py:247-296`) start each run with empty + buffers and call `execute()` / `async_execute()` on every node. Nothing under + `src/orcapod/pipeline` reads `is_stale` or `last_modified`. After run #1 every node reports + `is_stale == False` and holds a full result (`out/node_state.txt`). The information to skip + is there; nobody asks. +2. **B2** `OperatorJobNode.execute` (`core/nodes/operator_node.py:1282-1341`) never reads its + own `_cached_output_stream`. It checks only the store, in REPLAY mode (`:1310`), then always + runs `self._operator.process(*input_streams)` (`:1317`). Only `run()` (`:1390-1406`) checks + `is_stale` and the in-memory stream, and the orchestrators never call `run()`. +3. **B3** `FunctionJobNode.execute` (`core/nodes/function_node.py:1839-1980`) does keep its + results (`_cached_output_datas`, 2,000 entries after run #1). But it can reach them only + through the per-row key `compute_base_entry_id(tag, data)` (`:1892-1896`). That needs every + input row as a `Tag`/`Data` pair with its data hash, so everything upstream must run first. +4. **B4** `SourceNodeBase.execute` (`core/nodes/source_node.py:366-389`) lists + `iter_data()` again (`:386`). + - `ArrowTableSource` and the sources that wrap it serve that read from their stream's + `_cached_elements`: 0 new objects. + - `SpiralDBTableSource` keeps nothing between reads: a new scan, a key hash and a record id + per row, and new `Tag`/`Data` objects every run (`spiraldb_table_source.py:484`, + `stream_builder.py:334`). +5. **B5** Between nodes, the sync orchestrator rebuilds an Arrow table from the previous + node's list of rows (`_materialize_as_stream` → `_rows_to_table`, + `sync_orchestrator.py:226`): 8 rebuilds per run. The new `ArrowTableStream` has no element + cache, so the next node builds every `Tag`/`Data` again. Each operator node also rebuilds a + table from its own output rows to keep it (`operator_node.py:1324`): 5 more rebuilds. The + async path does the same at its barriers. + +**Busts** (a timestamp moved although the content did not): +1. **T1** Every re-run stamps every operator and function node with a new `last_modified` + (`operator_node.py:1330`, `function_node.py:1979`; async `operator_node.py:1755`, + `function_node.py:3559`), even though the output is identical. Nothing reads these stamps on + the job path today, so the bust costs nothing yet. It will once anything does: a skipping + orchestrator would itself have to avoid restamping, and any stream that reads a job node + lazily sees it change after every no-op run. +2. No other bust on the job path. `SpiralDBTableSource` and every `RootSource` keep their + construction time (`core/base.py:300-326`), so a source never presents a newer timestamp. + The lazy-path bust (a chained pod stream stamped before its input finished, ITL-1052) is + fixed on `main` by PR #355. + +**Missing invalidation** (the opposite of a bust; this blocks the simple fix): +- **M1** `SourceJobNode.last_modified` is the node's own construction time. It does not follow + its bound source. +- `job.bind(sources={"experiments": })` leaves every downstream node + `is_stale == False` (`out/node_state.txt`), so a skip based on `is_stale` alone would serve + the old results. Today's run notices the change only because it recomputes everything. + +**History in three lines.** The sync `Pipeline.run()` followed the model on `dev` from +2026-03-02 to 2026-03-14: `for node in topo order: node.run()`, and `OperatorNode.run` skipped a +non-stale node that held a cached stream. PR #85 (PLT-921, 2026-03-14) and PR #86 (PLT-922) +replaced that with orchestrators calling `execute()` for per-row observer hooks, with reuse +meant to come from the store alone. No tagged release ever had the skip, and the async path +never did. Details are in [C](#c-history). + +**Recommended fix** (detail in [D](#d-making-a-second-run-instantaneous)): +1. One staleness gate, in `execute()`: return the node's kept result when the node is current + and its result is complete. +2. The orchestrators pass upstream results as the upstream node's kept stream instead of + rebuilding rows into a table. +3. `SourceJobNode.last_modified` follows its bound source, and binding stamps the node. +4. Skipping does not restamp a node. + +On the measured pipeline, run #2 then does 0 computations, 0 per-row objects and 0 table +rebuilds. A new job object (c) still needs the store and is a separate, larger change. + +Timing: the developer has decided that the job-path fix lands **after the v0.3.0 tag** +(coordinator, 2026-11-13). Nothing here is needed for the workshop. The lazy path is already +fixed on `main` (PR #355). + +## Method + +- **Pipeline** (`rerun_counts.py`), shaped like the workshop's: + - `sessions`: `ArrowTableSource`, 2,000 rows, tags `subject_id` and `session`. + - `experiments`: 6,000 rows, a few `total` values null. + - Steps: `experiments.drop_nulls(["correct", "total"])` → `group_by(["subject_id", "session"])` + → `map_tags({"experiment_index": "experiment_indices"})` → `sessions.join(...)` → + `accuracy.pod(...)` (Orcapod inserts a `SelectDataColumns` node to drop `booth`) → + `grade.pod(...)`. + - That makes 9 job nodes. The store is `InMemoryArrowDatabase`; one mode also uses + `DeltaTableDatabase`. + - The `spiral-*` modes read the same tables through `SpiralDBTableSource` over the + repository's disk-backed pyspiral fake, with batches of 1,024 rows (the fake's default + is 2). +- **Counters** (`counters.py`) are monkeypatched in at start. Each count is attributed to the + node whose `execute` / `async_execute` is running, via a `ContextVar`. The metrics are listed + in the module docstring. +- One process at a time, small inputs, no live Spiral, no test suites. One timing figure + (`profile_runs.py`) was taken under `cProfile` at load average 3.1–3.3 on 10 cores. + +## A. Per-path counts + +### (b) `PipelineJob.run()`, sync, same job object, and (c) a new job object on the same store + +Totals over the 9 nodes. Per-node tables are in `out/job-sync.txt` and +`out/spiral-sync.main-89160c47.txt`. + +| metric | run #1 | run #2 | new job (c) | Spiral run #1 | Spiral run #2 | Spiral (c) | +|---|---:|---:|---:|---:|---:|---:| +| `node.execute` | 9 | 9 | 9 | 9 | 9 | 9 | +| rows materialized (`execute` lists) | 25,543 | 25,543 | 25,543 | 25,543 | 25,543 | 25,543 | +| source reads / Spiral scans | 2 / – | 2 / – | 2 / – | 2 / 2 | 2 / 2 | 2 / 2 | +| source record ids (`_make_record_id`) | 0¹ | 0¹ | 0¹ | 8,000 | 8,000 | 8,000 | +| function-node entry ids | 4,000 | 4,000 | 4,000 | 4,000 | 4,000 | 4,000 | +| Arrow `hash_table` calls | 16,000 | 8,000 | 8,000 | 24,000 | 16,000 | 16,000 | +| `Tag` built | 25,543 | 17,543 | 21,543 | 25,543 | 25,543 | 29,543 | +| `Data` built | 29,543 | 17,543 | 21,543 | 29,543 | 25,543 | 29,543 | +| operator `static_process` | 5 | 5 | 5 | 5 | 5 | 5 | +| `_rows_to_table` (orchestrator + operator nodes) | 8 + 5 | 8 + 5 | 8 + 5 | 8 + 5 | 8 + 5 | 8 + 5 | +| `hstack_tables` | 192,510 | 156,363 | 156,363 | 192,510 | 156,363 | 156,363 | +| function calls | 49² | **0** | **0** | 49 | **0** | **0** | +| store reads / writes | 8,002 / 8,098 | **0 / 0** | 4 / 0 | 8,002 / 8,098 | 0 / 0 | 4 / 0 | + +¹ An `ArrowTableSource` computes its record ids once, at construction. +² Results are memoized by input data hash, and the 2,000 rows have only 30 + 19 distinct +inputs. + +- **Run #2 on the same job saves only the function calls and the store traffic.** Every + computation and every per-row object between nodes is repeated. +- **The sources are the only nodes whose re-read is free**, and only for `ArrowTableSource`: + - its `ArrowTableStream._cached_elements` serves the same `Tag`/`Data` objects again; + - `Tag`/`Data` are 0 under `sessions` and `experiments` in run #2. +- **A new job object on the same store (c)** misses the source node's element cache too: the + `Tag`/`Data` count rises to 21,543. Its function nodes read their results back from the + store (4 reads), then build a `Tag` and a `Data` for each of those rows. +- **A new process on a `DeltaTableDatabase`** (`out/delta-process2.txt`) behaves like (c): + - 0 function calls; + - every node executes; + - 4,000 entry ids; + - 5 operator computations. +- **The coordinator's own probe** on `97263e5b` (DictSource → `drop_data_columns` → pod, 3,000 + rows) gives the same picture: 0 calls on re-run, every `execute` called, 6,000 `Tag` + 6,000 + `Data` per run. + +### (b) async (`AsyncPipelineOrchestrator`) + +`out/job-async.main-89160c47.txt`; run #2 totals: +- 9 `async_execute` calls; +- 4,000 entry ids; +- 8,000 hashes; +- 13,543 `Tag` + 13,543 `Data` (the streaming operators pass most objects through); +- 6 `_rows_to_table`; +- 1 `static_process` (`GroupBy`, a barrier); +- the other operators run their row-streaming `async_execute` again; +- 0 function calls, 0 writes. + +Same bypass, same conclusion. + +### (a) Lazy streams, no job + +Pipeline built with plain operator and pod calls; reads of the last stream (`out/lazy*.txt`): + +| read | `97263e5b` | PR #355 `963310fb` and `main` `89160c47` | +|---|---|---| +| 1st `as_table()` | 5 `static_process`, 4,000 calls, 2,000 Tag, 6,000 Data | same | +| 2nd `as_table()` | 0 | 0 | +| `list(iter_data())` after it | **2,000 calls, 2,000 Data** (`grade` falsely stale) | **0** | +| `head()` | 0 calls (21 `hstack_tables`) | 0 | +| same steps rebuilt as new streams, `as_table()` | everything again (new objects) | same | + +- On `main` the lazy path implements the developer's model exactly. `DynamicPodStream` keeps a + `_cached_stream` with a `_cached_time` and invalidates it when an upstream is newer + (`core/operators/static_output_pod.py:469-503`). +- `FunctionPodStream` stamps itself when its input has been read to the end (PR #355). + +## B. Per node kind: cache, timestamp, invalidation, and whether `execute()` consults it + +| | In-memory result after a run | Timestamp | What invalidates it | Does `execute()` consult it? | +|---|---|---|---|---| +| `SourceJobNode` | None of its own. The bound source may keep one: an `ArrowTableSource` keeps its `ArrowTableStream._cached_elements` (`arrow_table_stream.py:319-374`); a `SpiralDBTableSource` keeps nothing. | Node construction time (`TemporalMixin`). Does **not** follow the bound source (M1). | Nothing (`bind` only clears hash caches, `source_node.py:584-589`). | Re-reads the source every run (B4). | +| `OperatorJobNode` | `_cached_output_stream`, an `ArrowTableStream` rebuilt from the output rows (`operator_node.py:1324`). | Stamped at the end of every `execute` (`:1330`, T1). | `is_stale` → `clear_cache()`, only in `run()` (`:1403`). | **No** (B2). REPLAY reads the store, and a job sets OFF (`pipeline/job.py:504`). | +| `FunctionJobNode` | `_cached_output_datas`: per-row `(tag, data)` keyed by base entry id, plus `_cached_output_table`. | Stamped at the end of every `execute` (`function_node.py:1979`, T1). | `is_stale` → `clear_cache()` in `run` / `iter_data` (`:3200`, `:3239`), not in `execute`. | **Per row only** (B3). Needs every input row and its hash. | +| `DynamicPodStream` (lazy operator) | `_cached_stream` | `_cached_time` = when computed | Upstream or pod newer (`static_output_pod.py:474-492`) | Yes: `run()` on every read. | +| `FunctionPodStream` (lazy pod) | `_cached_output_datas`, `_cached_output_table` | Stamped when its input has been read to the end (PR #355) | `is_stale` in `iter_data` | Yes, see O2 below for `as_table`. | +| `ArrowTableStream` | `_cached_elements` | Construction | Never (immutable) | Yes | +| sources (`RootSource`) | the inner `ArrowTableStream`, or nothing (Spiral) | Construction time; `PollingSource` moves it from its cursor (`polling_source.py:867`) | — | — | + +## C. History + +Commits were found with `git log -S` and `--follow`. The local SHAs differ from those `gh` +lists for PRs #85 and #86 because history was rewritten; commits were matched by subject, date +and issue id. + +- **2026-02-27, `df6787d8`.** Adds `is_stale`, `clear_cache` and the modified-time machinery. +- **2026-03-02, `ed757cdf`.** Persistent function and operator nodes (direct to `dev`). + `OperatorNode.run`: "Execute the operator if stale or not yet computed"; `if self.is_stale: + self.clear_cache()`; `if self._cached_output_stream is not None: return`. +- **2026-03-03, `1f2c529b` / `5cb96702`.** `CacheMode`, with OFF as the operator default. The + reason, still in `orcapod-design.md:370`: the operator store "is a **historical record** … It + must never be silently substituted for fresh computation." + - This rule is about the **stored** operator cache. It does not cover a node's in-memory + result for unchanged inputs. +- **2026-03-04, `0943ecf8`.** First node-graph `Pipeline.run`: + `for node in topological_sort(...): node.run()`. + - Just before the orchestrator (`5476902c~1:src/orcapod/pipeline/graph.py:414-417`) the sync + path was still exactly this loop. + - `OperatorNode.run` skipped current nodes (`5476902c~1:…/operator_node.py:528-532`). + - `FunctionNode.run` replayed `_cached_output_packets` from its "complete cache" branch, with + no per-row hashing. + - `SourceNode.run` was a no-op. + - **This is the developer's model.** + - The async path (`a06c718d`, PR #71) always ran every node's `async_execute`. +- **2026-03-14, `db024aad`.** The sync orchestrator design spec. The orchestrator "drives + execution externally (rather than relying on pull-based iteration)" with "per-packet + observability hooks". Reuse becomes `get_cached_results(entry_ids) ← DB read` and + `get_cached_output() ← DB read (REPLAY mode)`. +- **2026-03-14/15, PR #85 (PLT-921: `4b5b67a8`, `5476902c`) and PR #86 (PLT-922: `96ac45ef`).** + `Pipeline.run()` uses `SyncPipelineOrchestrator`. + - Nodes get `execute()`. Per the PR body, `OperatorNode.execute` "gains REPLAY cache check" + only, and "orchestrators are pure topology schedulers". + - **The in-memory skip ends here.** The PR #86 test plan checks only "second run with DB + reports `cached=True`", that is, store reuse. +- **2026-04-08, PR #134, tag `v0.1.0rc1`.** The same orchestrator path, no staleness check. It + is unchanged through **`v0.1.4`** (`v0.1.4:src/orcapod/pipeline/job.py:821`, + `sync_orchestrator.py:78-99`). +- **2026-05-20, PR #138 (ENG-456).** `Pipeline.run()` removed, `PipelineJob.run()` added. + - Until 2026-05-26 each run cloned fresh nodes ("Build a fresh execution-ready graph"), so + in-memory caches were dropped on purpose. + - The spec says reuse comes "automatically via content-addressed storage". +- **2026-05-22, `2704d854` (ENG-493, PR #141).** `_distribute_databases` sets operators to + `CacheMode.OFF`. It gives no new reason; it carries over the March default. +- **2026-05-26, `3d5b3303` (ENG-517, PRs #143/#146).** Copy-on-run removed: nodes now persist + across runs, but `execute()` still ignores their in-memory state. +- **Since then** (#302 ITL-896, #334 ITL-991, #355 ITL-1042/1052): nodes keep their output so + that **reads** after a run work, and are not stale after a run. Nothing adds a skip. + +## D. Making a second run instantaneous + +### What must hold + +- Same rows, hashes, record ids and stored tables as a full re-run. +- A changed source is always noticed. +- The rows a skip must **not** cover: + - rows whose function failed (`_cached_output_datas` has no entry for them, so they must be + retried); + - a store attached or replaced after the run, which must receive its writes; + - writes still pending from a failed commit; + - a side-effecting node (`SideEffectJobNode`, or a pod with `ctx_arg`), whose delivery rules + in `contexts/stored.account_for_stale_tables` run at the start of every run (`_begin_run`). + +### Where the check belongs + +**Option 1: in `execute()` (recommended).** At the top of each job node's `execute` / +`async_execute`, return the kept result, without reading the input, when all of these hold: +1. the node holds a **complete** result from a finished run: a new flag set at the end of a + run with no failed rows, cleared by `clear_cache`; +2. `not self.is_stale`, with M1 fixed; +3. its store binding is the one that result was written under; +4. it is not side-effecting. + +- Each node decides for itself, as in the March `run()`. +- Both orchestrators get it at once. +- Observers still see `on_node_start` / `on_node_end`; the per-row hooks would report nothing, + or report "cached" per row without the per-row work. That needs deciding, because PR #85 + introduced the orchestrator precisely for per-row hooks. + +**Option 2: in the orchestrator only.** Skip a node when it is current, and hand its kept +stream downstream. +- Simpler to read, but it duplicates node knowledge (completeness, side effects, store + binding) in two orchestrators. +- It still needs `execute()` to accept "no input" for a skipped upstream. + +**Option 3: both.** The node decides (Option 1). The orchestrator stops rebuilding tables from +row lists (B5): it passes the upstream node itself, or its `_cached_output_stream`, as the input +stream, instead of `_materialize_as_stream(list_of_rows)`. +- Without this, a node that does have work (because one upstream changed) still pays for + rebuilding every unchanged upstream's rows. +- **Recommended: Option 1 plus the B5 part of Option 3.** + +### What each node kind must keep + +- **Operator node.** Keep `_cached_output_stream` (already kept) and its computed rows. Return + `list(self._cached_output_stream.iter_data())`; the stream's `_cached_elements` makes that + free on the second call. Better still, return the stream itself (B5). +- **Function node.** Keep `_cached_output_datas` in input order (already kept), plus the + completeness flag. Return the kept pairs without computing entry ids. +- **Source node.** + - Fix M1: `last_modified` = the max of the node's own time and the bound source's + `last_modified`, and `bind` stamps the node. + - Keep the materialized list (or rely on the source's own element cache), so that a Spiral + source is not scanned again while its object is unchanged. +- **Restamping (T1).** A skipped node must not stamp itself. Otherwise every downstream reader + of a job node sees a change after each no-op run. + +### What "modified" means per source + +- **`ArrowTableSource`, `DictSource`, `ListSource`, `DataFrameSource`, `CSVSource`, + `DeltaTableSource`, SQLite / PostgreSQL table sources.** + - All read their data at construction into an `ArrowTableStream`, so the content is fixed + per object and its construction time is a correct `last_modified`. + - A changed file or table is noticed only through a new source object (rebind or a new job). + That is today's behaviour for these sources as well. +- **`SpiralDBTableSource`.** + - Pins one table version per object (`asof`, or the table's version taken at construction, + `spiraldb_table_source.py:299-304`), so its rows are immutable for that object, and the + construction time is correct. + - It must keep its rows (B4) to make the second read free. The memory is that of one + materialized table, which a job already holds in `_cached_output_stream` downstream. +- **`PollingSource`.** + - Moves `last_modified` from its cursor (`polling_source.py:867-872`): already a correct + signal. + - The node must not keep a "complete" flag across new data, which the timestamp provides. +- **`DerivedSource`** over a job node. + - Construction time today. It does not follow the origin node's re-runs. Once the origin + stops restamping (T1), it should report the origin's `last_modified`. +- **`CachedSource`.** Already compares its inner source's time (`cached_source.py:376-394`). + +### Risks + +- **Correctness under source change.** + - M1 must land first, or together with the skip. + - A source mutated in place (a user editing the `pa.Table` behind an `ArrowTableSource`) is + not noticed. Orcapod forbids mutating inputs, so this is the user's error and is as + undetected as it is today on the lazy path. +- **Memory.** A job already keeps every node's full output after a run (operator + `_cached_output_stream`, function `_cached_output_datas`, orchestrator buffers while it + runs). The fix keeps the same objects longer, with no new copies; option B5 removes copies. + Keeping a Spiral source's rows adds one table per source. +- **Async.** + - The async orchestrator gives each node channels. A skipped node must still send its kept + rows and close its output channel. + - A skipped function node must not start its executor. + - Equivalence tests between sync and async (`test_async_sync_equivalence.py`) must cover a + skipped run. +- **Observers and `RunSummary`.** A skipped node reports its rows as read from cache. + `RunSummary` counts must stay meaningful. `PipelineJob.run` (`job.py` `_finish_run`) reads + per-node counts from the run observer. +- **A new job object or process (c)** cannot use in-memory caches. Making it cheap needs a + per-node memo key stored with the results: the input's identity plus the source versions and + `where`/`limit`. That is the run-level memo the issue's Goals describe, and it is separate + from this fix. + +## E. Cost inside a first run + +The ITL-1055 claim was that per-row `Tag`/`Data` construction and per-row record ids +dominate. The counters and the one profile (`out/profile_runs.txt`, Spiral fake, sync, +8,000 source rows, load 3.1) **confirm it in part**: + +| item (run #1, under `cProfile`; total 25.5 s) | calls | cumulative s | removed on a re-run by the model? | +|---|---:|---:|---| +| function nodes' per-row store work (`_process_data_internal`: about 2 reads and 2 writes per row; 8,002 reads, 8,098 writes in all) | 4,000 | 12.0 | already absent on run #2 | +| `Tag`/`Data` construction | 25,543 + 29,543 | 4.4 + 2.6 | yes | +| function-node entry ids (`compute_base_entry_id`) | 4,000 | 3.6 | yes | +| `_rows_to_table` (orchestrator + operator nodes) | 13 | 2.2 | yes | +| Spiral per-row key hash (`_key_tokens`) + record id | 8,000 | 1.4 | yes, if the source keeps its rows | +| `hstack_tables` (inside `Tag.as_table` / `Data.as_table` per row) | 192,510 | 1.4 | yes | + +- **Run #2 under the same profile:** 13.2 s, about half of run #1. All of it is the "yes" rows: + - `Tag`/`Data` construction, 5.3 s; + - entry ids, 3.5 s; + - row-to-table rebuilds, 2.2 s; + - Spiral key hashes, 1.4 s. +- **On the workshop pipeline** (92k-row Spiral tables, ITL-1055) the per-row key hash is the + largest single item (45 s). There the function nodes see far fewer rows than the sources, so + run #2 is close to run #1 (109 s against 123 s). +- **Correction to ITL-1055:** with a store, the first run's largest per-row cost on this + pipeline is the function nodes' per-row store bookkeeping. It is not datagram construction. +- **What the model removes on a re-run:** everything in the "yes" rows. What remains inside a + first run (vectorized record ids and key tokens, per-row store writes, building datagrams + only where a function needs them) is ITL-1055 / ITL-1056 work. + +## Out-of-scope findings (not fixed, not filed) + +- **O1. Async calls functions more than sync for duplicate inputs.** On the same first run, the + async function nodes call the function 94 + 64 times against 30 + 19 for sync. They write + 8,316 store rows against 8,098 (`out/job-async*.txt`). The likely cause, from reading and + not traced: rows with equal input hashes are computed concurrently before the first result + is stored, so the result memo does not deduplicate them. Stored results are still correct: equal inputs give equal outputs. The + cost is extra function calls and writes, which matters for expensive or side-effecting + functions. +- **O2. `FunctionPodStream.as_table()` returns `_cached_output_table` without the staleness + check that `iter_data()` makes** (`core/function_pod.py:1338`). By reading only, not + measured: over a `PollingSource` with new rows, `as_table()` would return the old table while + `iter_data()` recomputes. +- **O3. The pyspiral fake hands out 2-row batches by default** + (`tests/test_databases/fake_pyspiral.py:86`). Per-batch costs in tests over the fake are + therefore about 4,000 times what they are on SpiralDB. + +## Reproducing + +All from the repository root, one process at a time: + +``` +uv run python superpowers/specs/itl-1061/rerun_counts.py lazy # (a) +uv run python superpowers/specs/itl-1061/rerun_counts.py job-sync # (b) + (c) +uv run python superpowers/specs/itl-1061/rerun_counts.py job-async +uv run python superpowers/specs/itl-1061/rerun_counts.py spiral-sync # pyspiral fake +uv run python superpowers/specs/itl-1061/rerun_counts.py spiral-async +uv run python superpowers/specs/itl-1061/rerun_counts.py delta # run twice: new process +uv run python superpowers/specs/itl-1061/node_state.py # B, M1, T1 +uv run python superpowers/specs/itl-1061/profile_runs.py # E (one timing) +uv run python superpowers/specs/itl-1061/spiral_hash_callers.py # who hashes in a Spiral read +``` + +To run against another build, put that build's `src` first on `PYTHONPATH`, for example +`PYTHONPATH=/src uv run python …`. That is how `out/*-pr355-963310fb.txt` was taken. diff --git a/superpowers/specs/itl-1061/counters.py b/superpowers/specs/itl-1061/counters.py index bdb8199f0..5c1dbba68 100644 --- a/superpowers/specs/itl-1061/counters.py +++ b/superpowers/specs/itl-1061/counters.py @@ -70,10 +70,12 @@ def gen_wrapper(*args, **kwargs): else: @functools.wraps(func) - def wrapper(*args, **kwargs): + def call_wrapper(*args, **kwargs): bump(metric if isinstance(metric, str) else metric(*args, **kwargs)) return func(*args, **kwargs) + wrapper = call_wrapper + setattr(owner, name, staticmethod(wrapper) if is_static else wrapper) @@ -148,9 +150,9 @@ def install() -> None: _wrap( ArrowTableStream, "iter_data", - lambda self: "ats.iter.cached" - if self._cached_elements is not None - else "ats.iter.build", + lambda self: ( + "ats.iter.cached" if self._cached_elements is not None else "ats.iter.build" + ), ) _wrap(RootSource, "iter_data", "source.iter") _wrap(SpiralDBTableSource, "iter_data", "source.iter") @@ -181,7 +183,9 @@ def counted_record_id(*args, **kwargs): _wrap(cls, "static_process", "op.static_process") _wrap(sop.StaticOutputOperatorPod, "process", "op.process") _wrap(sop.StaticOutputOperatorPod, "_rows_to_table", "rows_to_table") - _wrap(sop.StaticOutputOperatorPod, "_materialize_to_stream", "materialize_to_stream") + _wrap( + sop.StaticOutputOperatorPod, "_materialize_to_stream", "materialize_to_stream" + ) original_hstack = arrow_utils.hstack_tables diff --git a/superpowers/specs/itl-1061/node_state.py b/superpowers/specs/itl-1061/node_state.py new file mode 100644 index 000000000..dc2d0fb0b --- /dev/null +++ b/superpowers/specs/itl-1061/node_state.py @@ -0,0 +1,97 @@ +"""Show each job node's in-memory state and staleness after one and two runs (ITL-1061). + + uv run python superpowers/specs/itl-1061/node_state.py + +For each node: its kind, ``last_modified``, ``is_stale``, its upstreams (the objects its +staleness is computed against), and the in-memory result it keeps (operator +``_cached_output_stream`` rows, function ``_cached_output_datas`` entries). Also shows what a +re-bound source does to the source node's modified time. Private attributes are read here +only because what they hold is the subject of the investigation. +""" + +from __future__ import annotations + +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[3])) +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +import rerun_counts # noqa: E402 # pyright: ignore[reportImplicitRelativeImport] # a sibling script, run from this folder's path + +from orcapod import PipelineJob # noqa: E402 +from orcapod.databases import InMemoryArrowDatabase # noqa: E402 + + +def describe(job: PipelineJob, title: str) -> None: + print(f"### {title}") + for label in ( + "sessions", + "experiments", + "drop_nulls", + "group_by", + "map_tags", + "join", + "accuracy", + "grade", + ): + node = job.nodes[label] + kept = "" + if hasattr(node, "_cached_output_stream"): + s = node._cached_output_stream + kept = f"_cached_output_stream={'None' if s is None else type(s).__name__}" + if hasattr(node, "_cached_output_datas"): + kept = f"_cached_output_datas={len(node._cached_output_datas)}" + if hasattr(node, "bound_source"): + kept = f"bound_source={type(node.bound_source).__name__} (src last_modified {node.bound_source.last_modified:%H:%M:%S.%f})" + ups = ",".join(type(u).__name__ for u in node.upstreams) + lm = node.last_modified + print( + f"{label:<12} {type(node).__name__:<16} last_modified=" + f"{'None' if lm is None else format(lm, '%H:%M:%S.%f')} is_stale={getattr(node, 'is_stale', 'n/a')!s:<5} " + f"upstreams=[{ups}] {kept}" + ) + print() + + +sources = rerun_counts.arrow_sources() +job = PipelineJob(name="ws", store=InMemoryArrowDatabase()) +with job: + rerun_counts.build(sources[0], sources[1], rerun_counts.make_pods()) +describe(job, "after compile, before any run") +job.run() +describe(job, "after job.run() #1") +job.run() +describe(job, "after job.run() #2") +# A source whose data really changed: experiments with different ``correct`` values. +import pyarrow as pa # noqa: E402 +import pyarrow.compute as pc # noqa: E402 + +from orcapod.sources import ArrowTableSource # noqa: E402 + +_, experiments = rerun_counts.tables() +changed = experiments.set_column( + experiments.schema.get_field_index("correct"), + "correct", + pc.subtract(pa.scalar(10, pa.int64()), experiments["correct"]), +) +before = job.nodes["accuracy"].as_table()["accuracy"].to_pylist() +job.bind( + sources={ + "experiments": ArrowTableSource( + changed, + tag_columns=["subject_id", "session", "experiment_index"], + source_id="experiments", + ) + } +) +describe(job, "after job.bind(sources={'experiments': same id, CHANGED rows})") +would_skip = [ + label + for label in ("drop_nulls", "group_by", "map_tags", "join", "accuracy", "grade") + if not job.nodes[label].is_stale +] +print("a skip on 'not is_stale and holds a result' would skip:", would_skip) +job.run() +after = job.nodes["accuracy"].as_table()["accuracy"].to_pylist() +print("today's run #3 picked up the change:", before != after) diff --git a/superpowers/specs/itl-1061/profile_runs.py b/superpowers/specs/itl-1061/profile_runs.py new file mode 100644 index 000000000..6292545c3 --- /dev/null +++ b/superpowers/specs/itl-1061/profile_runs.py @@ -0,0 +1,71 @@ +"""Profile a first and a second sync job.run() over the Spiral fake (ITL-1061). + + uv run python superpowers/specs/itl-1061/profile_runs.py + +Prints, per run, the wall time and the cumulative time of the functions the counters +point at (no counters installed here, so the times are not inflated by them). Take the +times as shares, not absolutes: the machine is shared. +""" + +from __future__ import annotations + +import cProfile +import os +import pstats +import sys +import tempfile +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[3])) +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +import rerun_counts # noqa: E402 # pyright: ignore[reportImplicitRelativeImport] # a sibling script, run from this folder's path + +from orcapod import PipelineJob # noqa: E402 +from orcapod.databases import InMemoryArrowDatabase # noqa: E402 +from tests.test_databases import fake_pyspiral # noqa: E402 + +WATCH = ( + ("sync_orchestrator.py", "run"), + ("source_node.py", "execute"), + ("spiraldb_table_source.py", "_key_tokens"), + ("stream_builder.py", "attach_provenance"), + ("arrow_table_stream.py", "iter_data"), + ("tag_data.py", "__init__"), + ("operator_node.py", "execute"), + ("static_output_pod.py", "_rows_to_table"), + ("static_output_pod.py", "_materialize_to_stream"), + ("function_node.py", "execute"), + ("function_node.py", "compute_base_entry_id"), + ("function_node.py", "get_cached_results"), + ("function_node.py", "_process_data_internal"), + ("arrow_utils.py", "hstack_tables"), +) + + +def show(profile: cProfile.Profile, title: str, wall: float) -> None: + stats = pstats.Stats(profile) + print(f"### {title}: wall {wall:.2f} s, load {os.getloadavg()[0]:.1f}") + rows = [] + for (path, _line, name), (_cc, nc, _tt, ct, _callers) in stats.stats.items(): # pyright: ignore[reportAttributeAccessIssue] # pstats keeps its table in an undeclared attribute + for file, func in WATCH: + if path.endswith(file) and name == func: + rows.append((ct, nc, f"{file}:{func}")) + for ct, nc, where in sorted(rows, reverse=True): + print(f"{ct:8.2f} s cum {nc:>8} calls {where}") + print() + + +with tempfile.TemporaryDirectory() as tmp, fake_pyspiral.install(Path(tmp)): + sources = rerun_counts.spiral_sources(Path(tmp)) + job = PipelineJob(name="ws", store=InMemoryArrowDatabase()) + with job: + rerun_counts.build(sources[0], sources[1], rerun_counts.make_pods()) + for i in (1, 2): + profile = cProfile.Profile() + start = time.perf_counter() + profile.enable() + job.run() + profile.disable() + show(profile, f"job.run() #{i}", time.perf_counter() - start) diff --git a/superpowers/specs/itl-1061/rerun_counts.py b/superpowers/specs/itl-1061/rerun_counts.py index 2b9eed2d6..7233fc895 100644 --- a/superpowers/specs/itl-1061/rerun_counts.py +++ b/superpowers/specs/itl-1061/rerun_counts.py @@ -29,7 +29,7 @@ sys.path.insert(0, str(REPO)) sys.path.insert(0, str(Path(__file__).resolve().parent)) -import counters # noqa: E402 +import counters # noqa: E402 # pyright: ignore[reportImplicitRelativeImport] # a sibling script, run from this folder's path import pyarrow as pa # noqa: E402 N_SUBJECTS = 200 @@ -95,7 +95,9 @@ def arrow_sources(): sessions, experiments = tables() return ( - ArrowTableSource(sessions, tag_columns=["subject_id", "session"], source_id="sessions"), + ArrowTableSource( + sessions, tag_columns=["subject_id", "session"], source_id="sessions" + ), ArrowTableSource( experiments, tag_columns=["subject_id", "session", "experiment_index"], @@ -114,11 +116,15 @@ def spiral_sources(root: Path): # fragments. 1,024 rows keeps per-batch counts from swamping per-row ones. fake_pyspiral.scan_batch_rows = 1024 project = fake_pyspiral.FakeSpiral().project(PROJECT) - s = project.create_table("default.sessions", key_schema=sessions.select(["subject_id", "session"]).schema) + s = project.create_table( + "default.sessions", key_schema=sessions.select(["subject_id", "session"]).schema + ) s.write(sessions) e = project.create_table( "default.experiments", - key_schema=experiments.select(["subject_id", "session", "experiment_index"]).schema, + key_schema=experiments.select( + ["subject_id", "session", "experiment_index"] + ).schema, ) e.write(experiments) return ( @@ -132,7 +138,9 @@ def build(sessions, experiments, pods): accuracy, grade = pods exp = experiments.drop_nulls(["correct", "total"], label="drop_nulls") grouped = exp.group_by(["subject_id", "session"], label="group_by") - mapped = grouped.map_tags({"experiment_index": "experiment_indices"}, label="map_tags") + mapped = grouped.map_tags( + {"experiment_index": "experiment_indices"}, label="map_tags" + ) joined = sessions.join(mapped, label="join") acc = accuracy.pod(joined, label="accuracy") return grade.pod(acc, label="grade") @@ -148,13 +156,13 @@ def run_counted(title: str, action) -> None: def mode_lazy(sources) -> None: """Lazy streams, no job: read the last stream twice (as_table, iter_data, head).""" pods = make_pods() - out = build(*sources, pods) + out = build(sources[0], sources[1], pods) run_counted("lazy: first as_table()", lambda: out.as_table()) run_counted("lazy: second as_table()", lambda: out.as_table()) run_counted("lazy: list(iter_data())", lambda: list(out.iter_data())) run_counted("lazy: head()", lambda: out.head()) # A second chain built over the same source objects (what a notebook re-run does). - out2 = build(*sources, pods) + out2 = build(sources[0], sources[1], pods) run_counted("lazy: same steps rebuilt, as_table()", lambda: out2.as_table()) @@ -169,7 +177,7 @@ def mode_job(sources, orchestrator_factory, store=None, runs: int = 2) -> None: def new_job(): job = PipelineJob(name="ws", store=store) with job: - build(*sources, pods) + build(sources[0], sources[1], pods) return job job = new_job() diff --git a/superpowers/specs/itl-1061/spiral_hash_callers.py b/superpowers/specs/itl-1061/spiral_hash_callers.py index 6beb78452..667f8830a 100644 --- a/superpowers/specs/itl-1061/spiral_hash_callers.py +++ b/superpowers/specs/itl-1061/spiral_hash_callers.py @@ -1,6 +1,6 @@ """Name the callers of the Arrow hasher during one read of a SpiralDBTableSource (ITL-1061). - uv run python superpowers/specs/itl-1061/spiral_hash_callers.py +uv run python superpowers/specs/itl-1061/spiral_hash_callers.py """ from __future__ import annotations @@ -14,7 +14,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[3])) sys.path.insert(0, str(Path(__file__).resolve().parent)) -import rerun_counts # noqa: E402 +import rerun_counts # noqa: E402 # pyright: ignore[reportImplicitRelativeImport] # a sibling script, run from this folder's path from orcapod.hashing import arrow_hashers # noqa: E402 from tests.test_databases import fake_pyspiral # noqa: E402 @@ -25,7 +25,11 @@ def counted(self, table): frames = traceback.extract_stack(limit=6)[:-1] - callers[" <- ".join(f"{Path(f.filename).name}:{f.lineno}:{f.name}" for f in frames[::-1][:3])] += 1 + callers[ + " <- ".join( + f"{Path(f.filename).name}:{f.lineno}:{f.name}" for f in frames[::-1][:3] + ) + ] += 1 return original(self, table) From a8212552b28d7ee2b05957132dc3bc94f29ff784 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Fri, 13 Nov 2026 01:59:56 -0800 Subject: [PATCH 4/6] docs(itl-1061): add the raw counter output the report cites Co-Authored-By: Claude Opus 5.5 --- superpowers/specs/itl-1061/out/README.md | 12 + .../specs/itl-1061/out/delta-process1.txt | 444 ++++++++++++++++++ .../specs/itl-1061/out/delta-process2.txt | 46 ++ .../itl-1061/out/job-async.main-89160c47.txt | 63 +++ superpowers/specs/itl-1061/out/job-async.txt | 63 +++ .../itl-1061/out/job-sync-pr355-963310fb.txt | 68 +++ .../itl-1061/out/job-sync.main-89160c47.txt | 68 +++ superpowers/specs/itl-1061/out/job-sync.txt | 68 +++ .../itl-1061/out/lazy-pr355-963310fb.txt | 34 ++ .../specs/itl-1061/out/lazy.main-89160c47.txt | 34 ++ superpowers/specs/itl-1061/out/lazy.txt | 37 ++ superpowers/specs/itl-1061/out/node_state.txt | 42 ++ .../specs/itl-1061/out/profile_runs.txt | 33 ++ .../specs/itl-1061/out/spiral-async.txt | 64 +++ .../out/spiral-sync.main-89160c47.txt | 72 +++ .../specs/itl-1061/out/spiral-sync.txt | 72 +++ 16 files changed, 1220 insertions(+) create mode 100644 superpowers/specs/itl-1061/out/README.md create mode 100644 superpowers/specs/itl-1061/out/delta-process1.txt create mode 100644 superpowers/specs/itl-1061/out/delta-process2.txt create mode 100644 superpowers/specs/itl-1061/out/job-async.main-89160c47.txt create mode 100644 superpowers/specs/itl-1061/out/job-async.txt create mode 100644 superpowers/specs/itl-1061/out/job-sync-pr355-963310fb.txt create mode 100644 superpowers/specs/itl-1061/out/job-sync.main-89160c47.txt create mode 100644 superpowers/specs/itl-1061/out/job-sync.txt create mode 100644 superpowers/specs/itl-1061/out/lazy-pr355-963310fb.txt create mode 100644 superpowers/specs/itl-1061/out/lazy.main-89160c47.txt create mode 100644 superpowers/specs/itl-1061/out/lazy.txt create mode 100644 superpowers/specs/itl-1061/out/node_state.txt create mode 100644 superpowers/specs/itl-1061/out/profile_runs.txt create mode 100644 superpowers/specs/itl-1061/out/spiral-async.txt create mode 100644 superpowers/specs/itl-1061/out/spiral-sync.main-89160c47.txt create mode 100644 superpowers/specs/itl-1061/out/spiral-sync.txt diff --git a/superpowers/specs/itl-1061/out/README.md b/superpowers/specs/itl-1061/out/README.md new file mode 100644 index 000000000..395b3c0f0 --- /dev/null +++ b/superpowers/specs/itl-1061/out/README.md @@ -0,0 +1,12 @@ +# Raw output of the ITL-1061 scripts + +`*.txt` is gitignored in this repository; these files are force-added as the evidence the +report cites. Builds: + +- no suffix: `main` at `97263e5b`, except `node_state.txt` and `profile_runs.txt`, taken after + merging `main` at `89160c47`. +- `*.main-89160c47.txt`: `main` at `89160c47` (PR #355 merged). +- `*-pr355-963310fb.txt`: PR #355's head `963310fb`, run with that build's `src` first on + `PYTHONPATH`. +- `delta-process1.txt` / `delta-process2.txt`: two processes, one after the other, on one + `DeltaTableDatabase` (`97263e5b`). diff --git a/superpowers/specs/itl-1061/out/delta-process1.txt b/superpowers/specs/itl-1061/out/delta-process1.txt new file mode 100644 index 000000000..1eaccd26e --- /dev/null +++ b/superpowers/specs/itl-1061/out/delta-process1.txt @@ -0,0 +1,444 @@ +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:55Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:56Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:57Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:58Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:42:59Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_signature_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pf_var_function_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:00Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __record_id because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::eb321f48fd884c57bc8e1fd23214759c6b77e27e03bf8226c346ea9f0c34b0fa::e8865957d9aed3e8de4cc143830b7cb588bec6f04ac4b6ee977616cef1071376::2cac8e561cbe8321762946be803c01f9b2b4d93212d23d12fc39b69605746e0f:0 because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column _tag_record_id::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53::4343f0d5374f3f40bf9b23da0f79407297452e3ab5a0b93f10d9a9859921ee53:1 because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __data_id because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __node_content_hash because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __input_data_hash because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __output_data_hash because it's a binary field. +[2026-11-13T09:43:01Z WARN deltalake_core::writer::stats] Skipping column __pipeline_base_entry_id because it's a binary field. +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 8000 0 0 8000 0 0 0 0 0 16000 +Tag.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +Data.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +ats.new 2 0 2 0 0 2 2 2 0 8 18 +ats.iter.build 1 1 1 1 1 1 1 1 1 0 9 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 22090 22174 0 22057 8002 8003 8002 0 94180 192510 +fn.call 0 30 0 0 19 0 0 0 0 0 49 +db.read 0 4001 0 0 4001 0 0 0 0 0 8002 +db.write 0 4060 0 0 4038 0 0 0 0 0 8098 +db.flush 0 21 0 0 21 0 0 0 0 3 45 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +Data.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +ats.new 2 1 2 0 1 2 2 2 0 8 20 +ats.iter.build 1 2 1 0 2 1 1 1 0 0 9 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 3 5 + diff --git a/superpowers/specs/itl-1061/out/delta-process2.txt b/superpowers/specs/itl-1061/out/delta-process2.txt new file mode 100644 index 000000000..6130ff633 --- /dev/null +++ b/superpowers/specs/itl-1061/out/delta-process2.txt @@ -0,0 +1,46 @@ +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +Data.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +ats.new 2 1 2 0 1 2 2 2 0 8 20 +ats.iter.build 1 2 1 1 2 1 1 1 1 0 11 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 3 5 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +Data.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +ats.new 2 1 2 0 1 2 2 2 0 8 20 +ats.iter.build 1 2 1 0 2 1 1 1 0 0 9 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 3 5 + diff --git a/superpowers/specs/itl-1061/out/job-async.main-89160c47.txt b/superpowers/specs/itl-1061/out/job-async.main-89160c47.txt new file mode 100644 index 000000000..75b1eb768 --- /dev/null +++ b/superpowers/specs/itl-1061/out/job-async.main-89160c47.txt @@ -0,0 +1,63 @@ +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 8000 0 0 6000 0 0 0 0 0 14000 +Tag.new 0 0 5543 6000 0 2000 2000 0 2000 0 17543 +Data.new 0 2000 5543 6000 2000 2000 2000 0 2000 0 21543 +ats.new 1 0 1 0 0 3 1 1 0 0 7 +ats.iter.build 0 0 0 1 0 1 0 0 1 0 3 +op.static_process 0 0 0 0 0 1 0 0 0 0 1 +rows_to_table 1 0 1 0 0 2 1 1 0 0 6 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8001 24282 46173 0 24192 30175 18001 8001 0 0 158825 +fn.call 0 94 0 0 64 0 0 0 0 0 158 +db.read 0 4001 0 0 4001 0 0 0 0 0 8002 +db.write 0 4188 0 0 4128 0 0 0 0 0 8316 +db.flush 0 21 0 0 21 0 0 0 0 2 44 + +### job.run() #2, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 0 2000 5543 0 2000 2000 2000 0 0 0 13543 +Data.new 0 2000 5543 0 2000 2000 2000 0 0 0 13543 +ats.new 1 1 1 0 1 3 1 1 0 0 9 +ats.iter.build 0 1 0 0 1 1 0 0 0 0 3 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.static_process 0 0 0 0 0 1 0 0 0 0 1 +rows_to_table 1 0 1 0 0 2 1 1 0 0 6 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8001 4000 46173 0 4000 30175 18001 8001 0 0 118351 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 0 2000 5543 0 2000 2000 2000 0 0 0 13543 +Data.new 0 2000 5543 0 2000 2000 2000 0 0 0 13543 +ats.new 1 1 1 0 1 3 1 1 0 0 9 +ats.iter.build 0 1 0 0 1 1 0 0 0 0 3 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.static_process 0 0 0 0 0 1 0 0 0 0 1 +rows_to_table 1 0 1 0 0 2 1 1 0 0 6 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8001 4000 46173 0 4000 30175 18001 8001 0 0 118351 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + diff --git a/superpowers/specs/itl-1061/out/job-async.txt b/superpowers/specs/itl-1061/out/job-async.txt new file mode 100644 index 000000000..75b1eb768 --- /dev/null +++ b/superpowers/specs/itl-1061/out/job-async.txt @@ -0,0 +1,63 @@ +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 8000 0 0 6000 0 0 0 0 0 14000 +Tag.new 0 0 5543 6000 0 2000 2000 0 2000 0 17543 +Data.new 0 2000 5543 6000 2000 2000 2000 0 2000 0 21543 +ats.new 1 0 1 0 0 3 1 1 0 0 7 +ats.iter.build 0 0 0 1 0 1 0 0 1 0 3 +op.static_process 0 0 0 0 0 1 0 0 0 0 1 +rows_to_table 1 0 1 0 0 2 1 1 0 0 6 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8001 24282 46173 0 24192 30175 18001 8001 0 0 158825 +fn.call 0 94 0 0 64 0 0 0 0 0 158 +db.read 0 4001 0 0 4001 0 0 0 0 0 8002 +db.write 0 4188 0 0 4128 0 0 0 0 0 8316 +db.flush 0 21 0 0 21 0 0 0 0 2 44 + +### job.run() #2, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 0 2000 5543 0 2000 2000 2000 0 0 0 13543 +Data.new 0 2000 5543 0 2000 2000 2000 0 0 0 13543 +ats.new 1 1 1 0 1 3 1 1 0 0 9 +ats.iter.build 0 1 0 0 1 1 0 0 0 0 3 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.static_process 0 0 0 0 0 1 0 0 0 0 1 +rows_to_table 1 0 1 0 0 2 1 1 0 0 6 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8001 4000 46173 0 4000 30175 18001 8001 0 0 118351 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 0 2000 5543 0 2000 2000 2000 0 0 0 13543 +Data.new 0 2000 5543 0 2000 2000 2000 0 0 0 13543 +ats.new 1 1 1 0 1 3 1 1 0 0 9 +ats.iter.build 0 1 0 0 1 1 0 0 0 0 3 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.static_process 0 0 0 0 0 1 0 0 0 0 1 +rows_to_table 1 0 1 0 0 2 1 1 0 0 6 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8001 4000 46173 0 4000 30175 18001 8001 0 0 118351 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + diff --git a/superpowers/specs/itl-1061/out/job-sync-pr355-963310fb.txt b/superpowers/specs/itl-1061/out/job-sync-pr355-963310fb.txt new file mode 100644 index 000000000..cbf717f40 --- /dev/null +++ b/superpowers/specs/itl-1061/out/job-sync-pr355-963310fb.txt @@ -0,0 +1,68 @@ +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 8000 0 0 8000 0 0 0 0 0 16000 +Tag.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +Data.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +ats.new 2 0 2 0 0 2 2 2 0 8 18 +ats.iter.build 1 1 1 1 1 1 1 1 1 0 9 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 22090 22174 0 22057 8002 8003 8002 0 94180 192510 +fn.call 0 30 0 0 19 0 0 0 0 0 49 +db.read 0 4001 0 0 4001 0 0 0 0 0 8002 +db.write 0 4060 0 0 4038 0 0 0 0 0 8098 +db.flush 0 21 0 0 21 0 0 0 0 2 44 + +### job.run() #2, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 2000 2000 5543 0 2000 2000 2000 2000 0 0 17543 +Data.new 2000 2000 5543 0 2000 2000 2000 2000 0 0 17543 +ats.new 2 0 2 0 0 2 2 2 0 8 18 +ats.iter.build 1 1 1 0 1 1 1 1 0 0 7 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +Data.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +ats.new 2 1 2 0 1 2 2 2 0 8 20 +ats.iter.build 1 2 1 0 2 1 1 1 0 0 9 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + diff --git a/superpowers/specs/itl-1061/out/job-sync.main-89160c47.txt b/superpowers/specs/itl-1061/out/job-sync.main-89160c47.txt new file mode 100644 index 000000000..cbf717f40 --- /dev/null +++ b/superpowers/specs/itl-1061/out/job-sync.main-89160c47.txt @@ -0,0 +1,68 @@ +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 8000 0 0 8000 0 0 0 0 0 16000 +Tag.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +Data.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +ats.new 2 0 2 0 0 2 2 2 0 8 18 +ats.iter.build 1 1 1 1 1 1 1 1 1 0 9 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 22090 22174 0 22057 8002 8003 8002 0 94180 192510 +fn.call 0 30 0 0 19 0 0 0 0 0 49 +db.read 0 4001 0 0 4001 0 0 0 0 0 8002 +db.write 0 4060 0 0 4038 0 0 0 0 0 8098 +db.flush 0 21 0 0 21 0 0 0 0 2 44 + +### job.run() #2, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 2000 2000 5543 0 2000 2000 2000 2000 0 0 17543 +Data.new 2000 2000 5543 0 2000 2000 2000 2000 0 0 17543 +ats.new 2 0 2 0 0 2 2 2 0 8 18 +ats.iter.build 1 1 1 0 1 1 1 1 0 0 7 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +Data.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +ats.new 2 1 2 0 1 2 2 2 0 8 20 +ats.iter.build 1 2 1 0 2 1 1 1 0 0 9 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + diff --git a/superpowers/specs/itl-1061/out/job-sync.txt b/superpowers/specs/itl-1061/out/job-sync.txt new file mode 100644 index 000000000..cbf717f40 --- /dev/null +++ b/superpowers/specs/itl-1061/out/job-sync.txt @@ -0,0 +1,68 @@ +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 8000 0 0 8000 0 0 0 0 0 16000 +Tag.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +Data.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +ats.new 2 0 2 0 0 2 2 2 0 8 18 +ats.iter.build 1 1 1 1 1 1 1 1 1 0 9 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 22090 22174 0 22057 8002 8003 8002 0 94180 192510 +fn.call 0 30 0 0 19 0 0 0 0 0 49 +db.read 0 4001 0 0 4001 0 0 0 0 0 8002 +db.write 0 4060 0 0 4038 0 0 0 0 0 8098 +db.flush 0 21 0 0 21 0 0 0 0 2 44 + +### job.run() #2, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 2000 2000 5543 0 2000 2000 2000 2000 0 0 17543 +Data.new 2000 2000 5543 0 2000 2000 2000 2000 0 0 17543 +ats.new 2 0 2 0 0 2 2 2 0 8 18 +ats.iter.build 1 1 1 0 1 1 1 1 0 0 7 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 0 4000 0 0 0 0 0 8000 +Tag.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +Data.new 2000 4000 5543 0 4000 2000 2000 2000 0 0 21543 +ats.new 2 1 2 0 1 2 2 2 0 8 20 +ats.iter.build 1 2 1 0 2 1 1 1 0 0 9 +ats.iter.cached 0 0 0 1 0 0 0 0 1 0 2 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + diff --git a/superpowers/specs/itl-1061/out/lazy-pr355-963310fb.txt b/superpowers/specs/itl-1061/out/lazy-pr355-963310fb.txt new file mode 100644 index 000000000..026137103 --- /dev/null +++ b/superpowers/specs/itl-1061/out/lazy-pr355-963310fb.txt @@ -0,0 +1,34 @@ +### lazy: first as_table() + +metric - TOTAL +Tag.new 2000 2000 +Data.new 6000 6000 +ats.new 5 5 +ats.iter.build 1 1 +op.static_process 5 5 +hstack_tables 4007 4007 +fn.call 4000 4000 + +### lazy: second as_table() + +metric TOTAL + +### lazy: list(iter_data()) + +metric TOTAL + +### lazy: head() + +metric TOTAL + +### lazy: same steps rebuilt, as_table() + +metric - TOTAL +Tag.new 2000 2000 +Data.new 6000 6000 +ats.new 5 5 +ats.iter.build 1 1 +op.static_process 5 5 +hstack_tables 4007 4007 +fn.call 4000 4000 + diff --git a/superpowers/specs/itl-1061/out/lazy.main-89160c47.txt b/superpowers/specs/itl-1061/out/lazy.main-89160c47.txt new file mode 100644 index 000000000..026137103 --- /dev/null +++ b/superpowers/specs/itl-1061/out/lazy.main-89160c47.txt @@ -0,0 +1,34 @@ +### lazy: first as_table() + +metric - TOTAL +Tag.new 2000 2000 +Data.new 6000 6000 +ats.new 5 5 +ats.iter.build 1 1 +op.static_process 5 5 +hstack_tables 4007 4007 +fn.call 4000 4000 + +### lazy: second as_table() + +metric TOTAL + +### lazy: list(iter_data()) + +metric TOTAL + +### lazy: head() + +metric TOTAL + +### lazy: same steps rebuilt, as_table() + +metric - TOTAL +Tag.new 2000 2000 +Data.new 6000 6000 +ats.new 5 5 +ats.iter.build 1 1 +op.static_process 5 5 +hstack_tables 4007 4007 +fn.call 4000 4000 + diff --git a/superpowers/specs/itl-1061/out/lazy.txt b/superpowers/specs/itl-1061/out/lazy.txt new file mode 100644 index 000000000..67a9f554f --- /dev/null +++ b/superpowers/specs/itl-1061/out/lazy.txt @@ -0,0 +1,37 @@ +### lazy: first as_table() + +metric - TOTAL +Tag.new 2000 2000 +Data.new 6000 6000 +ats.new 5 5 +ats.iter.build 1 1 +op.static_process 5 5 +hstack_tables 4007 4007 +fn.call 4000 4000 + +### lazy: second as_table() + +metric TOTAL + +### lazy: list(iter_data()) + +metric - TOTAL +Data.new 2000 2000 +fn.call 2000 2000 + +### lazy: head() + +metric - TOTAL +hstack_tables 21 21 + +### lazy: same steps rebuilt, as_table() + +metric - TOTAL +Tag.new 2000 2000 +Data.new 6000 6000 +ats.new 5 5 +ats.iter.build 1 1 +op.static_process 5 5 +hstack_tables 4007 4007 +fn.call 4000 4000 + diff --git a/superpowers/specs/itl-1061/out/node_state.txt b/superpowers/specs/itl-1061/out/node_state.txt new file mode 100644 index 000000000..6630be892 --- /dev/null +++ b/superpowers/specs/itl-1061/out/node_state.txt @@ -0,0 +1,42 @@ +### after compile, before any run +sessions SourceJobNode last_modified=09:45:07.059182 is_stale=n/a upstreams=[] bound_source=ArrowTableSource (src last_modified 09:45:06.735372) +experiments SourceJobNode last_modified=09:45:07.059171 is_stale=n/a upstreams=[] bound_source=ArrowTableSource (src last_modified 09:45:06.742802) +drop_nulls OperatorJobNode last_modified=09:45:07.061037 is_stale=False upstreams=[SourceJobNode] _cached_output_stream=None +group_by OperatorJobNode last_modified=09:45:07.061039 is_stale=False upstreams=[OperatorJobNode] _cached_output_stream=None +map_tags OperatorJobNode last_modified=09:45:07.061041 is_stale=False upstreams=[OperatorJobNode] _cached_output_stream=None +join OperatorJobNode last_modified=09:45:07.061042 is_stale=False upstreams=[SourceJobNode,OperatorJobNode] _cached_output_stream=None +accuracy FunctionJobNode last_modified=09:45:07.061094 is_stale=False upstreams=[OperatorJobNode] _cached_output_datas=0 +grade FunctionJobNode last_modified=09:45:07.061106 is_stale=False upstreams=[FunctionJobNode] _cached_output_datas=0 + +### after job.run() #1 +sessions SourceJobNode last_modified=09:45:07.059182 is_stale=n/a upstreams=[] bound_source=ArrowTableSource (src last_modified 09:45:06.735372) +experiments SourceJobNode last_modified=09:45:07.059171 is_stale=n/a upstreams=[] bound_source=ArrowTableSource (src last_modified 09:45:06.742802) +drop_nulls OperatorJobNode last_modified=09:45:08.989579 is_stale=False upstreams=[SourceJobNode] _cached_output_stream=ArrowTableStream +group_by OperatorJobNode last_modified=09:45:09.475440 is_stale=False upstreams=[OperatorJobNode] _cached_output_stream=ArrowTableStream +map_tags OperatorJobNode last_modified=09:45:09.874456 is_stale=False upstreams=[OperatorJobNode] _cached_output_stream=ArrowTableStream +join OperatorJobNode last_modified=09:45:10.497800 is_stale=False upstreams=[SourceJobNode,OperatorJobNode] _cached_output_stream=ArrowTableStream +accuracy FunctionJobNode last_modified=09:45:19.540156 is_stale=False upstreams=[OperatorJobNode] _cached_output_datas=2000 +grade FunctionJobNode last_modified=09:45:24.334861 is_stale=False upstreams=[FunctionJobNode] _cached_output_datas=2000 + +### after job.run() #2 +sessions SourceJobNode last_modified=09:45:07.059182 is_stale=n/a upstreams=[] bound_source=ArrowTableSource (src last_modified 09:45:06.735372) +experiments SourceJobNode last_modified=09:45:07.059171 is_stale=n/a upstreams=[] bound_source=ArrowTableSource (src last_modified 09:45:06.742802) +drop_nulls OperatorJobNode last_modified=09:45:25.401508 is_stale=False upstreams=[SourceJobNode] _cached_output_stream=ArrowTableStream +group_by OperatorJobNode last_modified=09:45:25.902525 is_stale=False upstreams=[OperatorJobNode] _cached_output_stream=ArrowTableStream +map_tags OperatorJobNode last_modified=09:45:26.280794 is_stale=False upstreams=[OperatorJobNode] _cached_output_stream=ArrowTableStream +join OperatorJobNode last_modified=09:45:26.910001 is_stale=False upstreams=[SourceJobNode,OperatorJobNode] _cached_output_stream=ArrowTableStream +accuracy FunctionJobNode last_modified=09:45:28.446010 is_stale=False upstreams=[OperatorJobNode] _cached_output_datas=2000 +grade FunctionJobNode last_modified=09:45:29.302966 is_stale=False upstreams=[FunctionJobNode] _cached_output_datas=2000 + +### after job.bind(sources={'experiments': same id, CHANGED rows}) +sessions SourceJobNode last_modified=09:45:07.059182 is_stale=n/a upstreams=[] bound_source=ArrowTableSource (src last_modified 09:45:06.735372) +experiments SourceJobNode last_modified=09:45:07.059171 is_stale=n/a upstreams=[] bound_source=ArrowTableSource (src last_modified 09:45:29.530882) +drop_nulls OperatorJobNode last_modified=09:45:25.401508 is_stale=False upstreams=[SourceJobNode] _cached_output_stream=ArrowTableStream +group_by OperatorJobNode last_modified=09:45:25.902525 is_stale=False upstreams=[OperatorJobNode] _cached_output_stream=ArrowTableStream +map_tags OperatorJobNode last_modified=09:45:26.280794 is_stale=False upstreams=[OperatorJobNode] _cached_output_stream=ArrowTableStream +join OperatorJobNode last_modified=09:45:26.910001 is_stale=False upstreams=[SourceJobNode,OperatorJobNode] _cached_output_stream=ArrowTableStream +accuracy FunctionJobNode last_modified=09:45:28.446010 is_stale=False upstreams=[OperatorJobNode] _cached_output_datas=2000 +grade FunctionJobNode last_modified=09:45:29.302966 is_stale=False upstreams=[FunctionJobNode] _cached_output_datas=2000 + +a skip on 'not is_stale and holds a result' would skip: ['drop_nulls', 'group_by', 'map_tags', 'join', 'accuracy', 'grade'] +today's run #3 picked up the change: True diff --git a/superpowers/specs/itl-1061/out/profile_runs.txt b/superpowers/specs/itl-1061/out/profile_runs.txt new file mode 100644 index 000000000..220271122 --- /dev/null +++ b/superpowers/specs/itl-1061/out/profile_runs.txt @@ -0,0 +1,33 @@ +### job.run() #1: wall 25.50 s, load 3.1 + 25.37 s cum 1 calls sync_orchestrator.py:run + 16.84 s cum 2 calls function_node.py:execute + 12.02 s cum 4000 calls function_node.py:_process_data_internal + 5.48 s cum 25558 calls arrow_table_stream.py:iter_data + 4.54 s cum 5 calls operator_node.py:execute + 4.38 s cum 29543 calls tag_data.py:__init__ + 3.62 s cum 4000 calls function_node.py:compute_base_entry_id + 2.77 s cum 2 calls source_node.py:execute + 2.64 s cum 25543 calls tag_data.py:__init__ + 2.21 s cum 13 calls static_output_pod.py:_rows_to_table + 1.38 s cum 8 calls spiraldb_table_source.py:_key_tokens + 1.38 s cum 192510 calls arrow_utils.py:hstack_tables + 1.15 s cum 5 calls static_output_pod.py:_materialize_to_stream + 0.03 s cum 8 calls stream_builder.py:attach_provenance + 0.00 s cum 2 calls function_node.py:get_cached_results + +### job.run() #2: wall 13.17 s, load 3.3 + 13.07 s cum 1 calls sync_orchestrator.py:run + 5.43 s cum 25558 calls arrow_table_stream.py:iter_data + 4.58 s cum 5 calls operator_node.py:execute + 4.48 s cum 2 calls function_node.py:execute + 3.45 s cum 4000 calls function_node.py:compute_base_entry_id + 2.83 s cum 2 calls source_node.py:execute + 2.64 s cum 25543 calls tag_data.py:__init__ + 2.61 s cum 25543 calls tag_data.py:__init__ + 2.19 s cum 13 calls static_output_pod.py:_rows_to_table + 1.43 s cum 8 calls spiraldb_table_source.py:_key_tokens + 1.15 s cum 5 calls static_output_pod.py:_materialize_to_stream + 0.92 s cum 156363 calls arrow_utils.py:hstack_tables + 0.03 s cum 8 calls stream_builder.py:attach_provenance + 0.00 s cum 2 calls function_node.py:get_cached_results + diff --git a/superpowers/specs/itl-1061/out/spiral-async.txt b/superpowers/specs/itl-1061/out/spiral-async.txt new file mode 100644 index 000000000..8a31178bf --- /dev/null +++ b/superpowers/specs/itl-1061/out/spiral-async.txt @@ -0,0 +1,64 @@ +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +spiral.scan 0 0 0 1 0 0 0 0 1 0 2 +record_id 0 0 0 6000 0 0 0 0 2000 0 8000 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 8000 0 6000 6000 0 0 0 2000 0 22000 +Tag.new 0 0 5543 6000 0 2000 2000 0 2000 0 17543 +Data.new 0 2000 5543 6000 2000 2000 2000 0 2000 0 21543 +ats.new 1 0 1 6 0 3 1 1 2 0 15 +ats.iter.build 0 0 0 6 0 1 0 0 2 0 9 +op.static_process 0 0 0 0 0 1 0 0 0 0 1 +rows_to_table 1 0 1 0 0 2 1 1 0 0 6 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8001 24282 46173 0 24192 30175 18001 8001 0 0 158825 +fn.call 0 94 0 0 64 0 0 0 0 0 158 +db.read 0 4001 0 0 4001 0 0 0 0 0 8002 +db.write 0 4188 0 0 4128 0 0 0 0 0 8316 +db.flush 0 21 0 0 21 0 0 0 0 2 44 + +### job.run() #2, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +spiral.scan 0 0 0 1 0 0 0 0 1 0 2 +record_id 0 0 0 6000 0 0 0 0 2000 0 8000 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 6000 4000 0 0 0 2000 0 16000 +Tag.new 0 2000 5543 6000 2000 2000 2000 0 2000 0 21543 +Data.new 0 2000 5543 6000 2000 2000 2000 0 2000 0 21543 +ats.new 1 1 1 6 1 3 1 1 2 0 17 +ats.iter.build 0 1 0 6 1 1 0 0 2 0 11 +op.static_process 0 0 0 0 0 1 0 0 0 0 1 +rows_to_table 1 0 1 0 0 2 1 1 0 0 6 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8001 4000 46173 0 4000 30175 18001 8001 0 0 118351 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +spiral.scan 0 0 0 1 0 0 0 0 1 0 2 +record_id 0 0 0 6000 0 0 0 0 2000 0 8000 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 6000 4000 0 0 0 2000 0 16000 +Tag.new 0 2000 5543 6000 2000 2000 2000 0 2000 0 21543 +Data.new 0 2000 5543 6000 2000 2000 2000 0 2000 0 21543 +ats.new 1 1 1 6 1 3 1 1 2 0 17 +ats.iter.build 0 1 0 6 1 1 0 0 2 0 11 +op.static_process 0 0 0 0 0 1 0 0 0 0 1 +rows_to_table 1 0 1 0 0 2 1 1 0 0 6 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8001 4000 46173 0 4000 30175 18001 8001 0 0 118351 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + diff --git a/superpowers/specs/itl-1061/out/spiral-sync.main-89160c47.txt b/superpowers/specs/itl-1061/out/spiral-sync.main-89160c47.txt new file mode 100644 index 000000000..33d0d815c --- /dev/null +++ b/superpowers/specs/itl-1061/out/spiral-sync.main-89160c47.txt @@ -0,0 +1,72 @@ +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +spiral.scan 0 0 0 1 0 0 0 0 1 0 2 +record_id 0 0 0 6000 0 0 0 0 2000 0 8000 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 8000 0 6000 8000 0 0 0 2000 0 24000 +Tag.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +Data.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +ats.new 2 0 2 6 0 2 2 2 2 8 26 +ats.iter.build 1 1 1 6 1 1 1 1 2 0 15 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 22090 22174 0 22057 8002 8003 8002 0 94180 192510 +fn.call 0 30 0 0 19 0 0 0 0 0 49 +db.read 0 4001 0 0 4001 0 0 0 0 0 8002 +db.write 0 4060 0 0 4038 0 0 0 0 0 8098 +db.flush 0 21 0 0 21 0 0 0 0 2 44 + +### job.run() #2, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +spiral.scan 0 0 0 1 0 0 0 0 1 0 2 +record_id 0 0 0 6000 0 0 0 0 2000 0 8000 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 6000 4000 0 0 0 2000 0 16000 +Tag.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +Data.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +ats.new 2 0 2 6 0 2 2 2 2 8 26 +ats.iter.build 1 1 1 6 1 1 1 1 2 0 15 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +spiral.scan 0 0 0 1 0 0 0 0 1 0 2 +record_id 0 0 0 6000 0 0 0 0 2000 0 8000 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 6000 4000 0 0 0 2000 0 16000 +Tag.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +Data.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +ats.new 2 1 2 6 1 2 2 2 2 8 28 +ats.iter.build 1 2 1 6 2 1 1 1 2 0 17 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + diff --git a/superpowers/specs/itl-1061/out/spiral-sync.txt b/superpowers/specs/itl-1061/out/spiral-sync.txt new file mode 100644 index 000000000..33d0d815c --- /dev/null +++ b/superpowers/specs/itl-1061/out/spiral-sync.txt @@ -0,0 +1,72 @@ +### job.run() #1, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +spiral.scan 0 0 0 1 0 0 0 0 1 0 2 +record_id 0 0 0 6000 0 0 0 0 2000 0 8000 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 8000 0 6000 8000 0 0 0 2000 0 24000 +Tag.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +Data.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +ats.new 2 0 2 6 0 2 2 2 2 8 26 +ats.iter.build 1 1 1 6 1 1 1 1 2 0 15 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 22090 22174 0 22057 8002 8003 8002 0 94180 192510 +fn.call 0 30 0 0 19 0 0 0 0 0 49 +db.read 0 4001 0 0 4001 0 0 0 0 0 8002 +db.write 0 4060 0 0 4038 0 0 0 0 0 8098 +db.flush 0 21 0 0 21 0 0 0 0 2 44 + +### job.run() #2, same job object + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +spiral.scan 0 0 0 1 0 0 0 0 1 0 2 +record_id 0 0 0 6000 0 0 0 0 2000 0 8000 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 6000 4000 0 0 0 2000 0 16000 +Tag.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +Data.new 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +ats.new 2 0 2 6 0 2 2 2 2 8 26 +ats.iter.build 1 1 1 6 1 1 1 1 2 0 15 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + +### reading job.nodes['grade'].as_table() after the runs + +metric - TOTAL +hstack_tables 8001 8001 + +### job.run() on a NEW job object, same store + +metric SelectDataColumns accuracy drop_nulls experiments grade group_by join map_tags sessions - TOTAL +node.execute 1 1 1 1 1 1 1 1 1 0 9 +rows.out 2000 2000 5543 6000 2000 2000 2000 2000 2000 0 25543 +source.iter 0 0 0 1 0 0 0 0 1 0 2 +spiral.scan 0 0 0 1 0 0 0 0 1 0 2 +record_id 0 0 0 6000 0 0 0 0 2000 0 8000 +base_entry_id 0 2000 0 0 2000 0 0 0 0 0 4000 +hash_table 0 4000 0 6000 4000 0 0 0 2000 0 16000 +Tag.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +Data.new 2000 4000 5543 6000 4000 2000 2000 2000 2000 0 29543 +ats.new 2 1 2 6 1 2 2 2 2 8 28 +ats.iter.build 1 2 1 6 2 1 1 1 2 0 17 +op.process 1 0 1 0 0 1 1 1 0 0 5 +op.static_process 1 0 1 0 0 1 1 1 0 0 5 +rows_to_table 1 0 1 0 0 1 1 1 0 8 13 +materialize_to_stream 1 0 1 0 0 1 1 1 0 0 5 +hstack_tables 8002 4000 22174 0 4000 8002 8003 8002 0 94180 156363 +db.read 0 2 0 0 2 0 0 0 0 0 4 +db.flush 0 1 0 0 1 0 0 0 0 2 4 + From b7a2b929325d6dec6490566b92f5ef68045cd910 Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Fri, 13 Nov 2026 03:07:14 -0800 Subject: [PATCH 5/6] docs(itl-1061): address CodeRabbit round 1 (new-job source caches, async skip drain, rerun target) Co-Authored-By: Claude Opus 5.5 --- .../plans/2026-11-13-itl-1061-rerun-cost.md | 10 +++--- .../specs/2026-11-13-itl-1061-rerun-cost.md | 34 +++++++++++++++---- 2 files changed, 33 insertions(+), 11 deletions(-) diff --git a/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md b/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md index cede048a9..afe57fd69 100644 --- a/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md +++ b/superpowers/plans/2026-11-13-itl-1061-rerun-cost.md @@ -19,25 +19,25 @@ and runs it through each path twice, printing a table of counts per run. --- -### Task 1: Read the code paths +## Task 1: Read the code paths - [x] Orchestrators: `pipeline/sync_orchestrator.py`, `pipeline/async_orchestrator.py`, `pipeline/job.py`, `pipeline/graph.py` - [x] Nodes: `core/nodes/source_node.py`, `operator_node.py`, `function_node.py` - [x] Streams: `core/streams/base.py` (`is_stale`, `last_modified`), `core/static_output_pod.py`, `core/function_pod.py` - [x] Sources: `arrow_table_source.py`, `dict_source.py`, `csv_source.py`, `delta_table_source.py`, Spiral source, polling sources -### Task 2: Counters and driver +## Task 2: Counters and driver - [x] `superpowers/specs/itl-1061/counters.py`: patch functions with wrappers that increment `Counter[(label, node)]` - [x] `superpowers/specs/itl-1061/rerun_counts.py`: paths (a) lazy streams read twice, (b) `PipelineJob.run()` twice sync and async, (c) new job same store, (d) `Pipeline.run()` - [x] Run each once (`uv run python superpowers/specs/itl-1061/rerun_counts.py `), save output under `superpowers/specs/itl-1061/out/` - [x] Commit WIP and push -### Task 3: PR #355 comparison (lazy path only) +## Task 3: PR #355 comparison (lazy path only) - [x] Scratch worktree at 963310fb, run path (a) there, record commit -### Task 4: History +## Task 4: History - [x] `git log -S is_stale`, `-S _cached_output_stream`, `--follow` on orchestrators / nodes; v0.1.x tags -### Task 5: Headline findings to coordinator, then the report (<500 lines), then PR (docs only, Refs ITL-1061) +## Task 5: Headline findings to coordinator, then the report (<500 lines), then PR (docs only, Refs ITL-1061) ## Notes for a successor - Done 2026-11-13: report at `superpowers/specs/2026-11-13-itl-1061-rerun-cost.md`, raw output in diff --git a/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md b/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md index 37fa6df2f..0ac28d4e8 100644 --- a/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md +++ b/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md @@ -101,6 +101,13 @@ never did. Details are in [C](#c-history). On the measured pipeline, run #2 then does 0 computations, 0 per-row objects and 0 table rebuilds. A new job object (c) still needs the store and is a separate, larger change. +This note sets no elapsed-time target: ITL-1055 leaves that number to the developer. What the +target should be measured on: the workshop pipeline (92k-row Spiral tables, notebook section +4) on the build the workshop uses, on an unloaded machine, as run #2 of the same job object +(today about 109 s against 123 s for run #1, at load about 18). The counter goals above are +the acceptance criteria this investigation can state. Section E's figures come from the small +fixture under `cProfile` and are not that baseline. + Timing: the developer has decided that the job-path fix lands **after the v0.3.0 tag** (coordinator, 2026-11-13). Nothing here is needed for the workshop. The lazy path is already fixed on `main` (PR #355). @@ -157,9 +164,12 @@ inputs. - **The sources are the only nodes whose re-read is free**, and only for `ArrowTableSource`: - its `ArrowTableStream._cached_elements` serves the same `Tag`/`Data` objects again; - `Tag`/`Data` are 0 under `sessions` and `experiments` in run #2. -- **A new job object on the same store (c)** misses the source node's element cache too: the - `Tag`/`Data` count rises to 21,543. Its function nodes read their results back from the - store (4 reads), then build a `Tag` and a `Data` for each of those rows. +- **A new job object on the same store (c)** still hits the sources' element caches, because + the script binds the same `experiments` and `sessions` source objects to both jobs (0 + `Tag`/`Data` under them). The `Tag`/`Data` count rises to 21,543 because `accuracy` and + `grade` read their results back from the store (4 reads), then build a `Tag` and a `Data` + for each of those rows. A new job over new source objects, or a new process, misses the + source caches as well. - **A new process on a `DeltaTableDatabase`** (`out/delta-process2.txt`) behaves like (c): - 0 function calls; - every node executes; @@ -286,7 +296,8 @@ and issue id. 4. it is not side-effecting. - Each node decides for itself, as in the March `run()`. -- Both orchestrators get it at once. +- Both orchestrators get it at once, with one constraint on the async one (below): a node may + skip only when every upstream node of this run also skipped. - Observers still see `on_node_start` / `on_node_end`; the per-row hooks would report nothing, or report "cached" per row without the per-row work. That needs deciding, because PR #85 introduced the orchestrator precisely for per-row hooks. @@ -354,8 +365,19 @@ stream, instead of `_materialize_as_stream(list_of_rows)`. runs). The fix keeps the same objects longer, with no new copies; option B5 removes copies. Keeping a Spiral source's rows adds one table per source. - **Async.** - - The async orchestrator gives each node channels. A skipped node must still send its kept - rows and close its output channel. + - The async orchestrator starts every node's task at once over bounded channels (64 items, + `pipeline/async_orchestrator.py:196-211`). A node that decides to skip at its start may + do so before an upstream node, which does run, has restamped itself. The skipped node then + never reads its input. That upstream blocks in `send` (`channels.py:144-147`) once its + channel is full, and the run never ends. Closing the skipped node's own output does not + release it (`_ChannelWriter.close`, `channels.py:149-163`). + - So the async skip decision must be made **before the tasks start**, by the orchestrator, + in topological order: a node skips only if it is current and every upstream node skips + too. A node that skips does not read its input channels, and its upstream nodes' tasks are + never started. Otherwise every input edge of a skipped node must be drained. This is an + argument for Option 3, where the orchestrator holds the per-run decision and the node + holds the "complete and current" test. + - A skipped node must still send its kept rows and close its output channel. - A skipped function node must not start its executor. - Equivalence tests between sync and async (`test_async_sync_equivalence.py`) must cover a skipped run. From 0a26ac75a6315607e85f94bcd1521769c4151b1b Mon Sep 17 00:00:00 2001 From: "Edgar Y. Walker" <> Date: Fri, 13 Nov 2026 03:07:21 -0800 Subject: [PATCH 6/6] docs(itl-1061): attribute the workshop timings to ITL-1055 Co-Authored-By: Claude Opus 5.5 --- superpowers/specs/2026-11-13-itl-1061-rerun-cost.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md b/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md index 0ac28d4e8..7da96017e 100644 --- a/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md +++ b/superpowers/specs/2026-11-13-itl-1061-rerun-cost.md @@ -104,7 +104,7 @@ rebuilds. A new job object (c) still needs the store and is a separate, larger c This note sets no elapsed-time target: ITL-1055 leaves that number to the developer. What the target should be measured on: the workshop pipeline (92k-row Spiral tables, notebook section 4) on the build the workshop uses, on an unloaded machine, as run #2 of the same job object -(today about 109 s against 123 s for run #1, at load about 18). The counter goals above are +(today about 109 s against 123 s for run #1, on a heavily loaded machine; ITL-1055). The counter goals above are the acceptance criteria this investigation can state. Section E's figures come from the small fixture under `cProfile` and are not that baseline.