Emulation Gameboy

How to make a (GameBoy) emulator?
Petar Veličković
University of Cambridge
C�� C�� S�� S��
13 July 2016
How to make a (GameBoy) emulator? Petar Veličković

Introduction Essential emulator Emulator extensions
What is emulation?
Emulation
I Emulation is a computer science concept corresponding to

imitation of one computer system on another.
I Contrast with simulation, which is just an imitation of a

particular feature/functionality (e.g. of a video game).
I Emulation can be performed in both hardware and so�ware;

in this talk, we will focus only on so�ware emulators.

What is emulation?
Emulator vs simulator
PSX emulator Pac-man simulator
An emulator executes the original code (ROM) wri�en for the console,
whereas the simulator represents an entirely new game.

History and specs of GameBoy
GameBoy
I The GameBoy is a video gaming console released by Nintendo

in 1989.
I First notable handheld console, in spite of technologically

superior competition:
I Together with its successor (Game Boy Color), sold over 119
million units (by far the most popular handheld console prior
to the release of the Nintendo DS).
I The Tetris cartridge alone sold 35 million copies!

Console exterior

Under the hood

Overview of the GameBoy emulator
Today’s task
Cartridge GameBoy
insert
⇡
⇡
1100 0011 0000 1100
0000 0010 0000 0000
input
0000 0000 0000 0000
0000 0010 1111 1111
1111 1111 1111 1111
ROM (Game code) Emulator
Modular approach
I We will adopt a modular approach in our implementation – the

emulator will consist of (nearly) independent
implementations of all of its subsystems (⇠ modules)!
I Why do this?
I Debugging becomes much easier because the e�ects of
programmer errors are local to a subsystem.
I The modules may be reusable in other emulator projects – the
hardware is standardised.
I Amenable to object-oriented programming.

Overview of the emulator
Memory
Memory ROM Cartridge
Processor
controller reader
RAM
Interrupts Input GPU Sprites

Processor
Processor
Processor
I Usually the most involved and complex module in the emulator

implementation (which is why programmers usually tend to
use pre-made CPU implementations).
I Several approaches are possible—we will focus on writing an

interpreter, which “follows” the game code and simply
simulates every instruction it encounters using the local CPU.

Processor
Interpreter emulator
IF DC EX
Instruction Fetch Decode Execute
I Interpreters usually simulate the fetch-decode-execute cycle,

present in most contemporary processors:
IF Instruction Fetch – fetch the current instruction;
DC Decode – determine the type of the instruction;
EX Execute – execute the current instruction, updating the state of
the processor, memory, etc.
I This way, we can only emulate systems whose processors are
several orders of magnitude slower than the native one.
Processor
Instruction Fetch
IF
Instruction Fetch
I Where is our program???
I With GameBoy, and most contemporary systems, both the

code and data are stored in the same memory (⇠ von Neumann
architecture).
I =) We need methods for reading from and writing to

memory, if we’d like to be able to fetch the current instruction.

Processor
Memory interface
I The GameBoy does all of its computations on the level of a

single byte; therefore, it makes sense to expose two methods:
ReadByte(address);
WriteByte(address, value);
to the CPU.
I For now, the processor only needs to know that these functions
exist—we will consider their actual implementations later.

Processor
Decode
DC
Decode
I A�er fetching the current byte of the program, we need to

determine the instruction that it represents (and hence
whether we need to read additional parameters from memory).
I This requires us to be well acquainted with the instruction set

architecture (ISA) of GameBoy’s processor (which is very
similar to the Zilog Z80 ISA).

Processor
GameBoy arhitecture
I Since we have read a single byte of our program as an

instruction, this allows us to consider 28 = 256 distinct
instructions.
I It is necessary to implement an enormous branching

(switch–case is an appropriate construct to use), which will
select the instruction to execute based on this byte’s value.
I This is easily the most cumbersome part of the

implementation. . .

Processor
Execute
EX
Execute
I Each instruction may a�ect the processor’s internal state (⇠

registers), as well as the state of memory.
I Furthermore, every instruction requires a certain
(predetermined) number of CPU ticks/cycles (will be very
important later!).
I The previously mentioned WriteByte method may be used for
e�ects on memory.
I In order to implement all these instructions, we need to
implement and maintain the processor’s internal state as well.
Processor
Processor state
The CPU’s current state is fully specified by the following registers:

PC Program Counter — the memory address of the next instruction
to be fetched;
SP Stack Pointer — the memory address of the top of the stack
(omi�ed from this talk);
F Flags;
A-E,H,L General purpose registers.
I We will also maintain the number of elapsed ticks since the

start of execution.

Processor
Flags
I Flags are logical (true/false) variables that allow the

processor to determine the e�ects of the previously executed
instruction.
I With GameBoy, the flags register looks like this:
7 6 5 4 3 0
ZF OF HCF CF
I The aforementioned flags are:

ZF Zero Flag — set if the result of the operation is zero;
OF Operation Flag — set if the operation was subtraction;
HCF Half-Carry Flag — set if there was an overflow in the lower half
of the result (omi�ed);
CF Carry Flag — set if there was an overflow in the result.

Processor
CPU state, cont’d
11 25 6 7 3 ...
PC SP A B C
T F F F 15732
ZF OF HCF CF ticks
CPU

Processor
Example: Sub(A, 5)
Memory
6 12 1 214 5 0 255 4
... 9 10 11 12 13 14 ... Address
11 25 6 7 3 ...
PC SP A B C
T F F F 15732
ZF OF HCF CF ticks
CPU

Processor
Example: Sub(A, 5)
Memory
6 12 1 214 5 0 255 4
... 9 10 11 12 13 14 ... Address
11 25 6 7 3 ... Sub(A, n)
PC SP A B C
T F F F 15732
ZF OF HCF CF ticks
CPU

Processor
Example: Sub(A, 5)
Memory
6 12 1 214 5 0 255 4
... 9 10 11 12 13 14 ... Address
12 25 6 7 3 ... Sub(A, 5)
PC SP A B C
T F F F 15732
ZF OF HCF CF ticks
CPU

Processor
Example: Sub(A, 5)
Memory
6 12 1 214 5 0 255 4
... 9 10 11 12 13 14 ... Address
13 25 1 7 3 ... Sub(A, 5)
PC SP A B C
F T F F 15739
ZF OF HCF CF ticks
CPU

Memory
Memory
Memory
Memory ROM
controller
RAM
I It is necessary to correctly implement the ReadByte and

WriteByte methods: we need to emulate the memory
controller, i.e. the memory management unit (MMU).

Memory
Naïve implementation
I PC has 16 bits, and therefore the GameBoy memory system

supports 216 = 65536 addresses.
I The naïve implementation is very simple. . .

1 int memo [65536];
2 public int ReadByte ( int address )
3 {
4 return memo [ address ];
5 }
6 public void WriteByte ( int address , int value )
7 {
8 memo [ address ] = value ;
9 }
I Can you think of some reasons why this is not so easy?

Memory
Gotchas
I Generally, logical address 6= physical address:

I Not all writes should succeed (ROM. . . );
I Not all addresses represent main memory (e.g. a special address
allows the CPU to read keypad inputs. . . );
I Two di�erent addresses could be mapped to the same physical
location.
I ...
I With GameBoy, all of the above hold!

GPU
GPU
GPU
I So far, we have managed to design an emulator that can, step

by step, execute any GameBoy program.
I Now we are interested in seeing the results of our work on a

graphical output.

GPU
GameBoy graphics
I GameBoy’s graphical output is an LCD with a 160 ⇥ 144 pixel

resolution =) we can maintain a colour matrix of such size,
and display it in our emulator.
I The values in this matrix have the following format:

0xAARRGGBB (Alpha–Red–Green–Blue)
I GameBoy supports four shades of gray, so the matrix may

contain only these four values:
I 0xFF000000 (BLACK)
I 0xFF555555 (DARK_GRAY)
I 0xFFAAAAAA (LIGHT_GRAY)
I 0xFFFFFFFF (WHITE)

GPU
Rendering a single frame (⇠ CRT)

Line 1
HBlank
Line 2
HBlank
Line 3
HBlank
VBlank
HBlank
Line 143
HBlank
Line 144
GPU
When do we draw a new frame?
I Every stage in the previous figure takes a specific amount of

time:
Phase Ticks
Line (background) 172
Line (sprites) 80
Horizontal blank 204
Single line 456
Vertical blank 4560
Entire frame 70224
I How could we keep track of when to trigger each phase?

GPU
Tiling system
I GameBoy doesn’t have enough memory to keep track of the

entire matrix of pixels; instead, we use a tiling system.
I VRAM contains “tiles” of size 8 ⇥ 8, and the background is

represented as a 32 ⇥ 32 matrix of pointers to the tiles.
I Observe that this gives us a total resolution of 256 ⇥ 256, yet

GameBoy’s LCD is 160 ⇥ 144!
I Two special-purpose registers, Scroll-X and Scroll-Y,
contain the coordinates of the point on the background that will
be located in the upper-le� corner of the LCD.

GPU
Tiling system, cont’d
Tile 1 Tile 2 Tile 3
1 2 2 3 ...
.. .. .. .. . .
. . . . .
Background map Background

Input
Input
Input
I With the GPU implemented, the emulator is able to display

graphical output, but the user/player still has no control over
the game.
I Next step: emulating user input.

Input
Input
I Input is processed using a special-purpose JOYP register, which
the processor may access at address 65280. The wires leading
to that register are connected in the following way:
7
6
5
4
# START
3
JOYP
" SELECT
B
2
! A
1
0
I The processor first writes 0x10 or 0x20 to the register, so it can

activate one of two columns; then, a�er several ticks, it can
read the least significant 4 bits in order to infer which bu�ons
were pressed.
Sprites
Sprites
Sprites
I With the input processed, we can play some games – but we

usually have to play blindly (there is no way the player can tell
what his/her position is).
I This issue (and many others) is solved by using sprites – tiles

which may be drawn and moved independent of the
background.

Sprites
Sprites: additional details

I Sprites use exactly the same type of 8 ⇥ 8 tiles as the
background.
I Specific parameters, maintained for every sprite in the OAM:
I (x, y) coordinates of the upper-le� corner;
I priority: is it in the foreground or behind the background;
I flip: horizontal or vertical;
I size: all sprites can be resized to 8 ⇥ 16 at the same time.
I The frame rendering algorithm: first draw the background,
then infer (based on colours and sprite priority) whether to
draw the sprite over the background.
Sprite above background
Sprite below background

Interrupts
Interrupts
Interrupts
I With sprite support, some simpler games work exactly as

expected.
I Most games require a very important detail: notifying the
processor when it may render the next frame.
I The most convenient time for changing the frame is during
VBlank, because during the line change, the GPU doesn’t
access either VRAM nor OAM.
I The best (in terms of resource management and requirements)
method for notifying the processor about an important event
such as entering VBlank is using interrupts.
Interrupts
Fetch-decode-execute cycle, revisited
IF DC EX
Instruction Fetch Decode Execute
IRQ
Interrupt Request
I A�er every executed instruction, the CPU needs to check

whether an interrupt was raised; if an interrupt is detected, the
CPU:
I Remembers its current state;
I Jumps (sets the PC) to the address of the interrupt handler.
I Executes the interrupt handler code, which ends with a special
RETI (Return From Interrupt) instruction, which restores state.
Interrupts
Interrupts: GameBoy specifics
I The processor has access to the Interrupt Enable (IE) registers,

through which it can specify which interrupts (out of 5 in total)
it is willing to handle at this point.
I If multiple interrupts are detected, the one with the highest
priority is handled first.
I The processor also has an Interrupt Master Enable (IME) switch,

which allows it to completely deactivate interrupt handling
(this is done during e.g. processing an interrupt, because we
should not handle two of them at the same time).

Interrupts
GameBoy interrupts
Priority Interrupt Adress of the handler

0 VBlank 0x0040
1 LCD Status 0x0048
2 Timer 0x0050
3 Serial 0x0058
4 Joypad 0x0060

Interrupts
We’re done!
I Even with only implementing the VBlank interrupt, our

emulator is capable of running Tetris. :)
I All details about GameBoy’s functionalities, as well as the

Game Boy Color console, may be found on the following
(extremely useful) reference page:
http://problemkaputt.de/pandocs.htm
I For any further queries, feel free to contact me:

[email protected]
I Thank you!

Emulation Gameboy

Uploaded by

Copyright:

Available Formats

Emulation Gameboy

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Emulation Gameboy

Uploaded by

Copyright:

Available Formats

How to make a (GameBoy) emulator?

How to make a (GameBoy) emulator? Petar Veličković

I Emulation is a computer science concept corresponding to

I Contrast with simulation, which is just an imitation of a

I Emulation can be performed in both hardware and so�ware;

How to make a (GameBoy) emulator? Petar Veličković

PSX emulator Pac-man simulator

How to make a (GameBoy) emulator? Petar Veličković

History and specs of GameBoy

I The GameBoy is a video gaming console released by Nintendo

I First notable handheld console, in spite of technologically

How to make a (GameBoy) emulator? Petar Veličković

History and specs of GameBoy

How to make a (GameBoy) emulator? Petar Veličković

History and specs of GameBoy

Under the hood

How to make a (GameBoy) emulator? Petar Veličković

Overview of the GameBoy emulator

Overview of the GameBoy emulator

I We will adopt a modular approach in our implementation – the

How to make a (GameBoy) emulator? Petar Veličković

Overview of the GameBoy emulator

Overview of the emulator

Interrupts Input GPU Sprites

How to make a (GameBoy) emulator? Petar Veličković

I Usually the most involved and complex module in the emulator

I Several approaches are possible—we will focus on writing an

How to make a (GameBoy) emulator? Petar Veličković

I Interpreters usually simulate the fetch-decode-execute cycle,

I Where is our program???

I With GameBoy, and most contemporary systems, both the

I =) We need methods for reading from and writing to

How to make a (GameBoy) emulator? Petar Veličković

I The GameBoy does all of its computations on the level of a

How to make a (GameBoy) emulator? Petar Veličković

I A�er fetching the current byte of the program, we need to

I This requires us to be well acquainted with the instruction set

How to make a (GameBoy) emulator? Petar Veličković

I Since we have read a single byte of our program as an

I It is necessary to implement an enormous branching

I This is easily the most cumbersome part of the

How to make a (GameBoy) emulator? Petar Veličković

I Each instruction may a�ect the processor’s internal state (⇠

The CPU’s current state is fully specified by the following registers:

I We will also maintain the number of elapsed ticks since the

How to make a (GameBoy) emulator? Petar Veličković

I Flags are logical (true/false) variables that allow the

I The aforementioned flags are:

How to make a (GameBoy) emulator? Petar Veličković

CPU state, cont’d

How to make a (GameBoy) emulator? Petar Veličković

How to make a (GameBoy) emulator? Petar Veličković

How to make a (GameBoy) emulator? Petar Veličković

How to make a (GameBoy) emulator? Petar Veličković

How to make a (GameBoy) emulator? Petar Veličković

I It is necessary to correctly implement the ReadByte and

How to make a (GameBoy) emulator? Petar Veličković

I PC has 16 bits, and therefore the GameBoy memory system

I The naïve implementation is very simple. . .