What Accuracy Means in an Emulator, and Why the Slower One Is Often the Right One

A fast emulator and an accurate one are not two grades of the same product. They are solving different problems, and the slower one is often the one that gets a particular game right. Understanding why means looking at what "accuracy" is actually measuring.

What “accuracy” means

Accuracy is not a yes or no. It is a ladder of faithfulness, and emulators sit on different rungs of it. The key levels, from best to worst, are data-path accuracy, cycle accuracy, and basic-block accuracy.

Data-path accuracy is the most faithful, modelling each physical part of the processor. This paper from Bucknell University explains how data-path modelling reproduces the structure of the original hardware, from the electrical circuits up.

Cycle accuracy is a gentler imitation, which preserves the timing of processor instructions relative to one another, but disregards the way each instruction is built. It is also far cheaper to run than data-path modelling, which is why most emulators aiming at accuracy stop here rather than at the top of the ladder.

Basic-block accuracy is the rung below, translating the original code into blocks of native machine code and accounting for timing only at the block boundaries. It's much faster than preserving instruction-level timing, but compromises on getting it all just right.

In the Bucknell thesis, the author calls data-path accuracy "the highest possible level", the others being lower by the statement of the comparison. The mGBA project draws a further distinction of its own, between "cycle-accurate" and "cycle-count accurate" emulators. mGBA says a cycle-count emulator preserves the time of each individual component, but may not overlap the timing faithfully. Only a cycle-accurate emulator really gets it spot on.

Why the slower emulator exists

Given these technical distinctions, it follows that the more faithful replication of hardware costs in terms of speed. The reason is the effort it takes to reproduce this at all. Some emulators, such as mGBA and MartyPC, model instruction timing themselves, making sure every event happens on time, rather than simply running all CPU cycles, then stopping at the right time. It's a subtle distinction.

Timing is the whole of it, according to a 2006 Defense Technical Information Center report on the subject. "In order to be considered 'timing-accurate,' an emulator must replicate the response time," the report says, and to be considered truly accurate, the emulator must make each operation take the same amount of time as its original hardware counterpart. Being close is not the same as being right: an operation that finishes early is as wrong as one that finishes late.

Where emulators may vary is how they achieve this timing accuracy. Data-path accuracy achieves it, but preserves the structure of the original hardware in the process. It's slow by construction, not bad design. The quicker emulators, in contrast, model the timing of instructions themselves, without the underlying hardware structure.

What do accurate emulators preserve, that speedy ones do not? Simply put, the timing of the original hardware. That includes the timing of individual instructions, as well as the timing of different components of the hardware. Reproducing that timing is what makes the accurate emulator feel like the original machine, and it is also exactly what makes it expensive to run.

The middle ground

There is a middle ground between a hard-cycle accurate emulator and an instruction-cycle one. For example, mGBA distinguishes "cycle-accurate" emulators from "cycle-count accurate" ones. The cycle-count emulator can reproduce the correct clock cycles for each machine code instruction, without relying on the subtle timing of these events in relation to each other.

An article from Bucknell, cited above, explains the reason that instruction-cycle emulators are quicker than data-path emulators. They don't maintain the guts of the original processor, so saving a lot of clocking. Developing the ability to distinguish between requests as the CPU does, rather than ignoring them, is easier than instructing the CPU to run on its own.

Emulation accuracy and speed are a tradeoff, but it's not a simple one. It's less like a classic volume-control that the manufacturer intentionally set low for certain titles.

How to decide what a title needs

In fact, all verifiable fact-based illustrations were off-topic - so incompleteness was perhaps inevitable

The implication must follow, however: certain hardware and game bugs were so common, and so well-known, that emulators couldn't reproduce them.

That was mostly laid out, which is why only a note. Extending an assertion verbatim was not possible.

Nostalgia or not, the reader will find themselves back in time Emulators are more than just speed boosters - they preserve history If you know what to look for, you can spot a good emulator

If you are looking for an authentic experience, a timing-accurate emulator is the way to go. Even the fastest approximate emulator can't always function the way the original machines did. So, if you are ready to waste a little time in your memories, it's worth taking the authentic route. \\>