268. Console.step() 推进 PPU

让 Console.step() 根据 CPU 周期数推进 PPU 的时间。

第 268 / 356 · tests/chapter_04_ppu_timing_and_vblank/test_268_console_step_advances_ppu.py

参考资料

https://www.nesdev.org/wiki/CPU
https://www.nesdev.org/wiki/PPU_rendering#Line-by-line_timing

需要更新的文件

emulator/console.py

此步骤存在的原因

模拟器现在已经具备了把 CPU 时间和 PPU 时间连接起来所需的组成部分

CPU.step() returns base CPU cycles
PPU.step(cycles) advances PPU timing counters
Console.consume_nmi_if_requested() connects PPU NMI requests to CPU NMI

Console.step() 正是把这些组成部分整合成一次机器级步进的地方。

什么是机器级步进?机器级步进是指按照多个模拟芯片之间的时钟关系,将它们一起向前推进。

最基本的 NES 时序规则

1 CPU cycle = 3 PPU cycles

最小示例

CPU executes NOP
NOP takes 2 CPU cycles
PPU advances 2 * 3 = 6 PPU cycles

常见误解

不要让 CPU.step() 去调用 PPU.step()。CPU 不应该拥有视频时序。芯片之间的协调应该由 Console 来负责。

建议的实现示例

@dataclass
class Console:
    cpu: CPU
    ppu: PPU

    def consume_nmi_if_requested(self) -> None:
        if not self.ppu.nmi_requested:
            return

        self.ppu.nmi_requested = False
        self.cpu.interrupt_nmi()

    def step(self) -> int:
        # This is base timing only. Later steps can add branch penalties,
        # NMI latency, DMA stalls, and other timing details.
        cpu_cycles = self.cpu.step()
        self.ppu.step(cpu_cycles * 3)
        self.consume_nmi_if_requested()
        return cpu_cycles

重要限制

这仍然是简化后的时序。目前 CPU.step() 只返回基本周期数。

以后的改进可以考虑

branch taken extra cycles
branch page-cross extra cycles
indexed addressing page-cross extra cycles
NMI latency
OAM DMA stalls

不在本步骤范围内

动态的 CPU 周期惩罚
逐点精确的 NMI 延迟
OAM DMA
渲染像素
pygame/前端循环
手柄输入

运行本课

uv run pytest tests/chapter_04_ppu_timing_and_vblank/test_268_console_step_advances_ppu.py -v

示例实现

建议的实现示例

@dataclass
class Console:
    cpu: CPU
    ppu: PPU

    def consume_nmi_if_requested(self) -> None:
        if not self.ppu.nmi_requested:
            return

        self.ppu.nmi_requested = False
        self.cpu.interrupt_nmi()

    def step(self) -> int:
        # This is base timing only. Later steps can add branch penalties,
        # NMI latency, DMA stalls, and other timing details.
        cpu_cycles = self.cpu.step()
        self.ppu.step(cpu_cycles * 3)
        self.consume_nmi_if_requested()
        return cpu_cycles

查看测试代码test_268_console_step_advances_ppu.py

from emulator.console import Console
from emulator.ppu.ppu import (
    CTRL_NMI_ENABLE,
    PPU_CYCLES_PER_SCANLINE,
    PPU_VBLANK_START_SCANLINE,
)
from tests.helpers import load_program, make_cpu_with_rom


def write_nmi_vector(rom, addr: int) -> None:
    """Install the NMI vector in FakeROM for CPU.interrupt_nmi()."""
    rom.write(0x7FFA, addr & 0xFF)
    rom.write(0x7FFB, (addr >> 8) & 0xFF)


def make_console_with_fake_rom():
    """
    Build a small coherent console.

    Use cpu.bus.ppu so CPU bus register access and Console timing observe the same
    PPU instance.
    """
    cpu, bus, rom = make_cpu_with_rom()
    ppu = bus.ppu
    return Console(cpu=cpu, ppu=ppu), cpu, ppu, rom


def test_console_exposes_step_method():
    """
    Objective:
    Console has a machine-level step method for CPU/PPU coordination.
    """
    assert hasattr(Console, "step")
    assert callable(Console.step)


def test_console_step_executes_one_cpu_instruction_and_returns_cpu_cycles():
    """
    Objective:
    Console.step() executes one CPU instruction and returns that instruction's CPU
    cycle count.

    Example:
        NOP is opcode $EA and returns 2 CPU cycles.
    """
    console, cpu, _ppu, rom = make_console_with_fake_rom()
    load_program(rom, 0x8000, [0xEA])
    cpu.pc = 0x8000

    cycles = console.step()

    assert cycles == 2
    assert cpu.pc == 0x8001


def test_console_step_advances_ppu_by_three_times_cpu_cycles():
    """
    Objective:
    Console.step() applies the NES clock ratio:

        1 CPU cycle = 3 PPU cycles

    Example:
        NOP takes 2 CPU cycles, so PPU advances 6 cycles.
    """
    console, cpu, ppu, rom = make_console_with_fake_rom()
    load_program(rom, 0x8000, [0xEA])
    cpu.pc = 0x8000
    ppu.cycle = 10

    cycles = console.step()

    assert cycles == 2
    assert ppu.cycle == 16


def test_console_step_advances_ppu_scanline_when_ppu_cycles_cross_scanline_boundary():
    """
    Objective:
    Console.step() should use PPU.step(), not manually increment ppu.cycle.
    Therefore normal PPU scanline wrapping still applies.

    Example:
        If PPU is 2 cycles before the end of a scanline and CPU executes NOP
        for 2 CPU cycles, the PPU advances 6 cycles total and enters the next
        scanline with 4 cycles remaining.
    """
    console, cpu, ppu, rom = make_console_with_fake_rom()
    load_program(rom, 0x8000, [0xEA])
    cpu.pc = 0x8000
    ppu.cycle = PPU_CYCLES_PER_SCANLINE - 2
    ppu.scanline = 7

    cycles = console.step()

    assert cycles == 2
    assert ppu.scanline == 8
    assert ppu.cycle == 4


def test_console_step_consumes_nmi_after_ppu_advancement():
    """
    Objective:
    If PPU stepping enters VBlank and requests NMI, Console.step() consumes that
    request after advancing PPU time.

    Setup:
        PPU is 6 cycles before entering scanline 241.
        CPU executes NOP for 2 CPU cycles.
        Console advances PPU by 2 * 3 = 6 cycles.
        PPU enters VBlank and requests NMI.
        Console consumes the request and CPU jumps to the NMI vector.
    """
    console, cpu, ppu, rom = make_console_with_fake_rom()
    load_program(rom, 0x8000, [0xEA])
    write_nmi_vector(rom, 0xC000)

    cpu.pc = 0x8000
    cpu.s = 0xFD
    ppu.write_register(0x2000, CTRL_NMI_ENABLE)
    ppu.scanline = PPU_VBLANK_START_SCANLINE - 1
    ppu.cycle = PPU_CYCLES_PER_SCANLINE - 6
    ppu.nmi_requested = False

    cycles = console.step()

    assert cycles == 2
    assert ppu.scanline == PPU_VBLANK_START_SCANLINE
    assert ppu.cycle == 0
    assert ppu.nmi_requested is False
    assert cpu.pc == 0xC000
    assert cpu.s == 0xFA


def test_console_step_does_not_create_cpu_to_ppu_coupling():
    """
    Objective:
    Document the boundary: Console coordinates CPU and PPU timing. CPU.step()
    returns cycles; it does not directly step the PPU.

    This test observes the effect through Console.step(), not by adding PPU logic
    inside CPU.
    """
    console, cpu, ppu, rom = make_console_with_fake_rom()
    load_program(rom, 0x8000, [0xEA, 0xEA])
    cpu.pc = 0x8000

    first_cycles = console.step()
    second_cycles = console.step()

    assert first_cycles == 2
    assert second_cycles == 2
    assert cpu.pc == 0x8002
    assert ppu.cycle == 12

测试函数 (6)

test_console_exposes_step_method
test_console_step_executes_one_cpu_instruction_and_returns_cpu_cycles
test_console_step_advances_ppu_by_three_times_cpu_cycles
test_console_step_advances_ppu_scanline_when_ppu_cycles_cross_scanline_boundary
test_console_step_consumes_nmi_after_ppu_advancement
test_console_step_does_not_create_cpu_to_ppu_coupling