pgn2 1.5.0 → 2.0.1

data/bench/profile_moves.rb

@@ -50,4 +50,97 @@ Benchmark.ips do |x|
   end
 end
 
+# --- 5. FEN generation (target of the direct-0x88 FEN builder) -------------
+positions = GAME.first.positions
+
+fen_report = MemoryProfiler.report do
+  positions.each { |p| p.to_fen.to_s }
+end
+
+puts "\n=== 5. FEN generation x#{positions.length} (target of direct-0x88 FEN) ==="
+puts "total_allocated objects: #{fen_report.total_allocated}"
+puts "total_allocated bytes:   #{fen_report.total_allocated_memsize}"
+
+puts "\n=== 6. FEN throughput (ips) ==="
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 1)
+  x.report('fen immortal') do
+    positions.each { |p| p.to_fen.to_s }
+  end
+end
+
+# --- 7. Last-position-only: lazy each_position vs eager positions ---------
+# Both paths build a fresh PGN::Game so the Game construction cost cancels;
+# the difference is building the full positions array (eager) vs not (lazy).
+lazy_report = MemoryProfiler.report do
+  game = PGN::Game.new(SAN, GAME.first.tags, GAME.first.result)
+  last = nil
+  game.each_position { |p| last = p }
+  last
+end
+
+eager_report = MemoryProfiler.report do
+  PGN::Game.new(SAN, GAME.first.tags, GAME.first.result).positions.last
+end
+
+puts "\n=== 7. Last-position-only (#{PLY} plies): lazy vs eager ==="
+puts "lazy  total_allocated objects: #{lazy_report.total_allocated}"
+puts "lazy  total_allocated bytes:   #{lazy_report.total_allocated_memsize}"
+puts "eager total_allocated objects: #{eager_report.total_allocated}"
+puts "eager total_allocated bytes:   #{eager_report.total_allocated_memsize}"
+
+# --- 8. SAN generation (Notation.san reconstruction from coords) -----------
+# Precompute one (position, from, to, promotion) tuple per ply outside the
+# measured block, so only Notation.san (reaches?/attacked?/disambiguation)
+# is measured — the path the knight/king attack masks target.
+san_inputs = []
+begin
+  pos = GAME.first.starting_position
+  SAN.each do |m|
+    mv = PGN::Move.new(m, pos.player)
+    calc = PGN::MoveCalculator.new(pos.board, mv)
+    san_inputs << [pos, calc.origin, mv.destination, mv.promotion]
+    pos = pos.move(m)
+  end
+end
+
+san_report = MemoryProfiler.report do
+  san_inputs.each { |pos, from, to, promo| PGN::Notation.san(pos, from, to, promo) }
+end
+
+puts "\n=== 8. SAN generation x#{san_inputs.length} (target of attack masks) ==="
+puts "total_allocated objects: #{san_report.total_allocated}"
+puts "total_allocated bytes:   #{san_report.total_allocated_memsize}"
+
+puts "\n=== 8b. SAN throughput (ips) ==="
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 1)
+  x.report('san immortal') do
+    san_inputs.each { |pos, from, to, promo| PGN::Notation.san(pos, from, to, promo) }
+  end
+end
+
+# --- 9. Retained memory: lazy each_position vs eager positions ------------
+# Objects allocated during the report that are STILL ALIVE at its end.
+# Both reports keep the Game alive in an outer var so the difference is
+# purely what the API memoizes: lazy streams without memoizing the array;
+# eager memoizes the full positions array on the Game.
+lazy_game = nil
+lazy_retained = MemoryProfiler.report do
+  lazy_game = PGN::Game.new(SAN, GAME.first.tags, GAME.first.result)
+  lazy_game.each_position { |_| } # stream; do NOT memoize the array
+end
+
+eager_game = nil
+eager_retained = MemoryProfiler.report do
+  eager_game = PGN::Game.new(SAN, GAME.first.tags, GAME.first.result)
+  eager_game.positions # memoize the full array on the Game
+end
+
+puts "\n=== 9. Retained memory (#{PLY} plies): lazy vs eager ==="
+puts "lazy  total_retained objects: #{lazy_retained.total_retained}"
+puts "lazy  total_retained bytes:   #{lazy_retained.total_retained_memsize}"
+puts "eager total_retained objects: #{eager_retained.total_retained}"
+puts "eager total_retained bytes:   #{eager_retained.total_retained_memsize}"
+
 puts "\nDone. Compare this file against bench/baseline_moves.txt after optimizations."

data/docs/superpowers/plans/2026-08-13-attack-masks-plan.md

@@ -0,0 +1,51 @@
+# Attack Masks + Retention Benchmark — Plan
+
+TDD, inline execution. Commit per task. Honest benchmark reporting.
+
+## Task 1 — `PGN::Board` attack-mask tables (TDD)
+
+Add `KNIGHT_ATTACKS` / `KING_ATTACKS` frozen 128-entry Arrays to `Board`,
+entry `idx` = frozen `Array` of on-board 0x88 targets from `idx`. Build
+from `Notation::KNIGHT_OFFS`/`KING_OFFS`, filtering `(t & 0x88).zero?`.
+
+Spec (`spec/board_spec.rb`): mask entries equal the on-board squares the
+offsets reach; corner squares have 2 knight / 3 king targets; centre e4
+(0x54) has 8 knight / 8 king. E.g. `KNIGHT_ATTACKS[0] == [33, 18]`,
+`KING_ATTACKS[0] == [1, 16, 17]`, `KNIGHT_ATTACKS[0x54].length == 8`.
+
+## Task 2 — `Notation` uses the masks
+
+`reaches?` N/K → `Board::KNIGHT_ATTACKS[from].include?(to)` /
+`KING_ATTACKS`. `knight_attacked?`/`king_attacked?` → iterate the mask.
+`leaper_moves?` N/K → iterate the mask (pass mask instead of `OFFS`).
+
+Spec: existing `notation_spec` + round-trip stay green (byte-identical
+SAN). Add a focused test: a knight on e4 reaches d6/f6/etc.; a king on e1
+reaches d1/d2/e2/f2/f1.
+
+## Task 3 — `MoveCalculator` K/N origins via the mask
+
+Add `leaper_origins(mask)` iterating pre-filtered on-board targets;
+`compute_origin` K/N branch calls
+`leaper_origins(Board::KNIGHT_ATTACKS[dest_idx] ...)`; pawn path keeps
+`move_origins(offsets)`.
+
+Spec: existing `move_calculator_spec` + full round-trip stay green.
+
+## Task 4 — SAN-generation benchmark section
+
+Add `bench/profile_moves.rb` section 8: reconstruct `Notation.san` for
+every move of the immortal game from coordinate from/to (precomputed
+once), allocation + throughput. Regenerate baseline; report whether the
+mask change moved the SAN and replay (section 1/4) needles.
+
+## Task 5 — Retained-memory benchmark section
+
+Add section 9: `MemoryProfiler` **retained** objects/memsize for
+last-position-only, lazy (`each_position`) vs eager (`positions`). Fresh
+`PGN::Game` per path. Regenerate baseline.
+
+## Task 6 — Final verification + CHANGELOG/README
+
+Full suite, RuboCop (no new offenses on touched files), `rake bench`,
+CHANGELOG + README update.