Day 25: Cache by blocks of ints

block size 128 (0.size (8) * 16) gave good results on one computer...

block size | hits | misses | miss rate | runtime / original
----|---------|-----|----------|------
8   | 1073198 | 64  | 0.000061 | 1.33
16  | 533709  | 102 | 0.00019  | 0.67
32  | 263990  | 120 | 0.00045  | 0.4
64  | 129163  | 169 | 0.0013   | 0.25
128 | 61726   | 280 | 0.0045   | 0.22
256 | 27929   | 494 | 0.017    | 0.8

However, on a different computer, 8 * 7 = 56 was the best.
Haven't investigated why.

Previously I had tried the individual approaches (may still be available
on branches unless I decide to delete them):

* Pack N bits into blocks without running multiple iterations at once:
  Slowdown by about 1.5x
* Run fixed N iterations without packing bits into blocks:
  Slowdown by about 2x because we do 2N-1 reads for every N iterations.
* Run for every N distance without packing bits into blocks:
  Slowdown by about 1.2x because we tend to take fewer than 2N-1 cycles
  to move N distance.

Need to combine the first and last bullet points, plus add a cache.

Author: petertseng

25_turing_machine.rb

@@ -36,18 +36,59 @@ def parse_state(line)
 end
 STATES = parse_input(ARGF)
 
-ticker = [0] * (check_after ** 0.5).ceil * 2
+# Experimentally, this gave a good runtime,
+# but didn't investigate to explain why this is good.
+# I suppose performance gets worse at 63 because some numbers become bigints,
+# such as new_bit << block_pos
+BLOCK_SIZE = 62
+
+CACHE = {}
+def run_block(left, right, state, steps_left)
+  pos = BLOCK_SIZE
+  steps_taken = 0
+  # Leftmost bit of left doesn't matter.
+  left &= ~1
+  cache_key = [left, right, state].freeze
+  if (cached = CACHE[cache_key]) && cached[-1] <= steps_left
+    return cached
+  end
+
+  while steps_taken < steps_left && (1...(2 * BLOCK_SIZE)).cover?(pos)
+    block_i, block_pos = pos.divmod(BLOCK_SIZE)
+    current_bit = (block_i == 0 ? left : right)[block_pos]
+    new_bit, where_to_go, state = STATES[state][current_bit]
+    if current_bit != new_bit
+      mask = ~(1 << block_pos)
+      if block_i == 0
+        left = (left & mask) | (new_bit << block_pos)
+      else
+        right = (right & mask) | (new_bit << block_pos)
+      end
+    end
+    pos += where_to_go
+    steps_taken += 1
+  end
+  CACHE[cache_key] = [left, right, state, pos == 0 ? -1 : 1, steps_taken].freeze
+end
+
+ticker = [0] * [(check_after ** 0.5) * 4 / BLOCK_SIZE, 2].max
 pos = ticker.size / 2
+steps_left = check_after
 
-check_after.times {
-  ticker[pos], where_to_go, state = STATES[state][
-    ticker[pos] || 0.tap { ticker.concat([0] * ticker.size) }
-  ]
+while steps_left > 0
+  new_left, new_right, state, where_to_go, steps_taken = run_block(
+    ticker[pos - 1],
+    ticker[pos] || 0.tap { ticker.concat([0] * ticker.size) },
+    state, steps_left,
+  )
+  steps_left -= steps_taken
+  ticker[pos - 1] = (ticker[pos - 1] & 1) | (new_left & ~1)
+  ticker[pos] = new_right
   pos += where_to_go
   if pos < 0
     pos += ticker.size
     ticker.unshift(*[0] * ticker.size)
   end
-}
+end
 
-puts ticker.sum
+puts ticker.sum { |t| t.to_s(2).count(?1) }

README.md

@@ -66,6 +66,8 @@ Solutions with interesting algorithmic choices:
   A few ideas can be found in the [can it be done more efficiently?](https://www.reddit.com/r/adventofcode/comments/7lunzu/2017_day_24_so_can_it_be_done_more_efficiently/) thread.
   The only one I needed to use was the one that optimises out any `[X, X]` dominoes.
   There are only 6 `[X, X]` dominoes in my input of 57, but this decreases the number of bridges found from 288414 to 21783.
+* 25 (Turing Machine):
+  Pack into blocks of N bits (experimentally determined that 128 is good), and cache what happens every time the head moves N steps away as seen in [askalski's solutions](https://www.reddit.com/r/adventofcode/comments/7q6s80/2017_optimized_solutions_in_c_195_ms_total/).
 
 Solutions notable for good leaderboard-related reasons: