Scale a Grid Fire-Spread Simulation Past What Fits in Memory

A terrain simulation models wildfire spread on a grid of cells, each either burning (1) or clear (0). Every generation updates all cells simultaneously from the previous one, using a fixed local rule based on each cell's eight neighbors (horizontal, vertical, and diagonal).

You're given working code for a small grid, built around an in-memory 2D list:

import itertools
import random

_NEIGHBOR_OFFSETS = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]

class FireGrid:
    def __init__(self, rows, cols, p):
        self.rows, self.cols = rows, cols
        self.grid = [random.choices([1, 0], weights=[p, 1 - p], k=cols) for _ in range(rows)]

    def step(self):
        updated = [[0] * self.cols for _ in itertools.repeat(None, self.rows)]
        for row, col in itertools.product(range(self.rows), range(self.cols)):
            self._ignite_if_needed(self.grid, updated, row, col)
        self.grid = updated

    def _ignite_if_needed(self, old, new_grid, row, col):
        in_bounds = lambda rr, cc: 0 <= rr < len(old) and 0 <= cc < len(old[rr])
        lit = sum(old[row + dr][col + dc] for dr, dc in _NEIGHBOR_OFFSETS if in_bounds(row + dr, col + dc))
        already_burning = old[row][col] == 1
        new_grid[row][col] = 1 if already_burning or lit >= 3 else 0

Scale this to a grid of 2,000,000 rows by 2,000,000 columns. The ignition probability p could be set close to 1, which means you cannot assume the grid is sparse, so tracking only the handful of burning coordinates is off the table as a shortcut. Leave the logic inside _ignite_if_needed untouched; what needs to change is purely where the grid lives and how one generation gets produced once it no longer fits in RAM.

What to work out

• Estimate the memory a 2,000,000 × 2,000,000 dense grid would need under a few different cell encodings (a Python int per cell, a byte per cell, a packed bit per cell), and show why the in-memory design above can't survive this scale under any of them without other changes.
• Propose storing each row as a line in a file, so the grid lives on disk instead of in memory.
• Design a step that reads generation N from one file and writes generation N+1 to another file, using only a small, fixed amount of memory regardless of grid size — specifically, a sliding window of at most three rows at a time, since that's all _ignite_if_needed ever looks at for any one output row.

Constraints

• Treat reading and writing one line at a time from a file as the available primitive; don't assume the whole file can be loaded into memory at once.
• The simulation must still produce the exact same next generation as the original in-memory version would, for the same input grid.
• State what happens to memory usage as the number of rows grows, holding row width fixed.