Bench run: fix3 dirty propagation, main vs eng-10095

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01G8cXh3TUbNtbjm2ERqE62X

Author: claude

benchmarks_scratch/bench_fix3_dirty_propagation.py

@@ -0,0 +1,85 @@
+"""Micro-benchmark for ENG-10095: dirty-propagation runs in full on every mutation.
+
+Measures per-mutation cost with computed vars defined:
+  1. Proxied list append (each triggers _mark_dirty -> _mark_dirty_computed_vars).
+  2. Plain int setattr in a loop.
+  3. Raw list append baseline (no state involved).
+"""
+
+import cProfile
+import io
+import pstats
+import time
+
+
+def build_state():
+    import reflex as rx
+
+    class BenchFix3State(rx.State):
+        items: list[int] = []
+        other: int = 0
+
+        @rx.var(cache=True)
+        def total(self) -> int:
+            return len(self.items)
+
+        @rx.var(cache=True)
+        def other_doubled(self) -> int:
+            return self.other * 2
+
+    return BenchFix3State(_reflex_internal_init=True)  # pyright: ignore [reportCallIssue]
+
+
+def bench_append(state, n: int = 10000) -> float:
+    proxy = state.items
+    start = time.perf_counter()
+    for i in range(n):
+        proxy.append(i)
+    return (time.perf_counter() - start) / n * 1_000_000
+
+
+def bench_setattr(state, n: int = 10000) -> float:
+    start = time.perf_counter()
+    for i in range(n):
+        state.other = i
+    return (time.perf_counter() - start) / n * 1_000_000
+
+
+def bench_raw_append(n: int = 100000) -> float:
+    raw = []
+    start = time.perf_counter()
+    for i in range(n):
+        raw.append(i)
+    return (time.perf_counter() - start) / n * 1_000_000
+
+
+def main():
+    state = build_state()
+
+    append_us = bench_append(state)
+    setattr_us = bench_setattr(state)
+    raw_us = bench_raw_append()
+    print(f"proxied list append:  {append_us:8.3f} us/op")
+    print(f"int var setattr:      {setattr_us:8.3f} us/op")
+    print(f"raw list append:      {raw_us:8.4f} us/op")
+
+    # Correctness spot-check: computed vars still update after the loop.
+    state._clean()
+    state.items = [1, 2, 3]
+    assert state.total == 3
+    state.other = 21
+    assert state.other_doubled == 42
+    print("correctness spot-check passed")
+
+    profiler = cProfile.Profile()
+    profiler.enable()
+    bench_append(state, n=2000)
+    profiler.disable()
+    stream = io.StringIO()
+    pstats.Stats(profiler, stream=stream).sort_stats("cumulative").print_stats(12)
+    print("cProfile (2000 proxied appends):")
+    print(stream.getvalue())
+
+
+if __name__ == "__main__":
+    main()

benchmarks_scratch/bench_fix4_getattribute.py

@@ -0,0 +1,86 @@
+"""Micro-benchmark for ENG-10096: __getattribute__ slow path and get_delta caches.
+
+Measures:
+  1. Framework bookkeeping attribute reads (dirty_vars, parent_state, substates,
+     _backend_vars) through the state instance.
+  2. An event-processing-shaped loop: mutate, get_delta, clean.
+  3. get_skip_vars() throughput.
+"""
+
+import cProfile
+import io
+import pstats
+import time
+
+
+def build_state():
+    import reflex as rx
+
+    class BenchFix4State(rx.State):
+        items: list[int] = []
+        count: int = 0
+
+        @rx.var(cache=True)
+        def doubled(self) -> int:
+            return self.count * 2
+
+        @rx.var(cache=True, backend=True)
+        def _hidden(self) -> int:
+            return self.count + 1
+
+    class BenchFix4Child(BenchFix4State):
+        child_val: int = 0
+
+    return BenchFix4State(_reflex_internal_init=True)  # pyright: ignore [reportCallIssue]
+
+
+def bench_bookkeeping_reads(state, n: int = 50000) -> float:
+    start = time.perf_counter()
+    for _ in range(n):
+        _ = state.dirty_vars
+        _ = state.parent_state
+        _ = state.substates
+        _ = state._backend_vars
+    return (time.perf_counter() - start) / n * 1_000_000
+
+
+def bench_event_cycle(state, n: int = 2000) -> float:
+    start = time.perf_counter()
+    for i in range(n):
+        state.count = i
+        state.get_delta()
+        state._clean()
+    return (time.perf_counter() - start) / n * 1_000_000
+
+
+def bench_skip_vars(state, n: int = 50000) -> float:
+    cls = type(state)
+    start = time.perf_counter()
+    for _ in range(n):
+        cls.get_skip_vars()
+    return (time.perf_counter() - start) / n * 1_000_000
+
+
+def main():
+    state = build_state()
+
+    reads_us = bench_bookkeeping_reads(state)
+    cycle_us = bench_event_cycle(state)
+    skip_us = bench_skip_vars(state)
+    print(f"4 bookkeeping attr reads:   {reads_us:8.3f} us/op")
+    print(f"setattr+get_delta+_clean:   {cycle_us:8.3f} us/op")
+    print(f"get_skip_vars():            {skip_us:8.4f} us/op")
+
+    profiler = cProfile.Profile()
+    profiler.enable()
+    bench_bookkeeping_reads(state, n=5000)
+    bench_event_cycle(state, n=500)
+    profiler.disable()
+    stream = io.StringIO()
+    pstats.Stats(profiler, stream=stream).sort_stats("cumulative").print_stats(14)
+    print("cProfile (5000 bookkeeping reads + 500 event cycles):")
+    print(stream.getvalue())
+
+
+if __name__ == "__main__":
+    main()

benchmarks_scratch/run.json

@@ -1,5 +1,5 @@
 {
   "base_ref": "main",
-  "head_ref": "claude/reflex-perf-optimizations-01l7a3-eng-10094",
-  "bench_script": "benchmarks_scratch/bench_fix2_mutable_proxy.py"
+  "head_ref": "claude/reflex-perf-optimizations-01l7a3-eng-10095",
+  "bench_script": "benchmarks_scratch/bench_fix3_dirty_propagation.py"
 }