Memory Management Unit (MMU) and Basic Memory Access

The CPU you started building in the last chapter is blind without memory. It can execute instructions, but it can’t load programs, store data, or interact with any of the Game Boy’s peripherals like the screen or sound chip. This is where the Memory Management Unit (MMU) comes in.

This chapter guides you through creating the Game Boy’s core memory system, the Memory Management Unit (MMU). You’ll learn about the Game Boy’s memory map, how to model different memory regions, and implement the fundamental readByte and writeByte operations crucial for any emulator. By the end, your emulator will be able to load a Game Boy ROM into its virtual memory, a significant step towards running actual games.

Introduction

In any computer system, the CPU doesn’t directly access every component. Instead, it interacts with a unified address space, and a component called the MMU translates those addresses to the correct physical memory location or hardware register. For the Game Boy, this system is relatively simple but absolutely critical.

This milestone focuses on building a functional Memory module that encapsulates the Game Boy’s 64KB (0x0000-0xFFFF) address space. You’ll define the different memory regions, implement logic to handle reads and writes to these regions, and crucially, enable loading a cartridge ROM into the system.

By the end of this chapter, your emulator will:

Have a structured representation of the Game Boy’s memory.
Be able to load a Game Boy ROM file into the designated memory region.
Support basic readByte and writeByte operations across various memory areas, allowing the CPU to fetch instructions and interact with RAM.

Planning & Design

The Game Boy’s CPU (a custom Sharp SM83) has a 16-bit address bus, meaning it can address 2^16 = 65,536 bytes (64KB) of memory. This 64KB is divided into distinct regions, each serving a specific purpose:

Game Boy Memory Map (Simplified Overview):

Address Range	Size	Description	Access
`0x0000` - `0x7FFF`	32KB	Cartridge ROM (Bank 0 and Switchable Banks)	Read Only
`0x8000` - `0x9FFF`	8KB	VRAM (Video RAM)	Read/Write
`0xA000` - `0xBFFF`	8KB	External RAM (Cartridge RAM, if present)	Read/Write
`0xC000` - `0xDFFF`	8KB	WRAM (Work RAM)	Read/Write
`0xE000` - `0xFDFF`	7.5KB	Echo RAM (Mirror of `0xC000`-`0xDFFF`)	Read/Write
`0xFE00` - `0xFE9F`	160 bytes	OAM (Object Attribute Memory, for sprites)	Read/Write
`0xFEA0` - `0xFEFF`	96 bytes	Unusable/Forbidden	No Access
`0xFF00` - `0xFF7F`	128 bytes	I/O Registers (LCD, Joypad, Sound, Timers)	Read/Write
`0xFF80` - `0xFFFE`	127 bytes	HRAM (High RAM)	Read/Write
`0xFFFF`	1 byte	Interrupt Enable Register	Read/Write

📌 Key Idea: The MMU’s job is to act as a switchboard. When the CPU asks for data at address 0x1000, the MMU knows to fetch it from the cartridge ROM. If it asks for 0xD000, it goes to WRAM.

Designing the `Memory` Module

We’ll model the MMU as an F# record type holding byte arrays for each distinct, addressable memory region. This approach offers clear separation and allows us to use F#’s powerful pattern matching for efficient address decoding.

File Structure

We’ll create a new file, Mmu.fs, to house our memory logic. We might also create a MemoryMap.fs for constants, though for now, we can keep constants within Mmu.fs for simplicity.

GameboyEmulator/
├── src/
│   ├── GameboyEmulator/
│   │   ├── Cpu.fs
│   │   ├── Mmu.fs         <-- New file for Memory Management Unit
│   │   ├── Program.fs
│   │   └── GameboyEmulator.fsproj

Step-by-Step Implementation

1. Define Memory Constants

First, let’s define the memory region boundaries as constants. These will be crucial for dispatching read/write operations.

Create a new file src/GameboyEmulator/Mmu.fs and add the following:

// src/GameboyEmulator/Mmu.fs

module Mmu

/// Defines the Game Boy's memory map boundaries and sizes.
module MemoryMap =
    let RomStart      = 0x0000u
    let RomEnd        = 0x7FFFu // 32KB
    let VramStart     = 0x8000u
    let VramEnd       = 0x9FFFu // 8KB
    let ExtRamStart   = 0xA000u
    let ExtRamEnd     = 0xBFFFu // 8KB
    let WramStart     = 0xC000u
    let WramEnd       = 0xDFFFu // 8KB
    let EchoRamStart  = 0xE000u
    let EchoRamEnd    = 0xFDFFu // 7.5KB - mirror of WRAM
    let OamStart      = 0xFE00u
    let OamEnd        = 0xFE9Fu // 160 bytes
    let UnusableStart = 0xFEA0u
    let UnusableEnd   = 0xFEFFu // 96 bytes - should not be accessed
    let IoStart       = 0xFF00u
    let IoEnd         = 0xFF7Fu // 128 bytes
    let HramStart     = 0xFF80u
    let HramEnd       = 0xFFFEu // 127 bytes
    let IeRegister    = 0xFFFFu // 1 byte

    let WramSize      = (WramEnd - WramStart + 1u) |> int
    let VramSize      = (VramEnd - VramStart + 1u) |> int
    let OamSize       = (OamEnd - OamStart + 1u) |> int
    let IoSize        = (IoEnd - IoStart + 1u) |> int
    let HramSize      = (HramEnd - HramStart + 1u) |> int
    // Note: ROM size varies based on cartridge. We'll handle a default 32KB for now.
    // External RAM also varies. We'll reserve 8KB for now.
    let ExtRamSize    = (ExtRamEnd - ExtRamStart + 1u) |> int

Explanation:

module Mmu and module MemoryMap: We’re using nested modules to organize our code, keeping memory-related constants within MemoryMap for clarity.
u suffix: Denotes an unsigned 16-bit integer (uint16), which is appropriate for Game Boy addresses.
int conversion: Used when calculating array sizes, as F# arrays expect int for their length.

2. Define the `Memory` Record

Now, let’s define the Memory record type. This record will hold the byte arrays representing our different memory regions.