When it comes to emulators and emulation software, most people automatically think about the software which makes running old games on new hardware possible. While this is true, and most emulators are built to do just that, it’s important to keep in mind that the topic of emulation is a lot wider than that.
Any typical emulator can be seen as a combination of modules that are build to roughly mimic the specific parts of system, or subsystems of the computer system we are trying to emulate. Usually, an emulator will be made of the following modules:
- a CPU emulator. Also called a processor simulator, it’s main goal is to closely mimic the operation modes and subroutines of the original systems processor.
- a module dedicated to emulating the memory subsystems of the original machine. Of course, where the original computer had chips, in emulation we use code to achieve the same results and behavior
- the third module is not really an unified system like the previous two. It’s goal is to mimic the various input and output devices from the original computer that we are trying to emulate.
Most often, emulating the front end bus and other buses from the original machine is not really practical in terms of simplicity, robustness or performance. To achieve the same effect, the virtual peripheral devices in the emulation environment communicate with the memory or the CPU directly, without going through an emulated bus.
Most often, emulators are built to emulate just the hardware architecture of the original machine. In case an OS, specific firmware or software is required, it must be delivered through other means, and in turn can be emulated as well. Both the operating system and the software that runs atop of the OS will be interpreted by the emulator in the next step, and not be run by native hardware as one would expect.
All other hardware, such as IO devices (but not the interpreter for the binary machine language we are attempting to emulate) must be visualized as well. If we would to take this to the extreme levels, we could argue that the emulation should and could be done all the way down to the atomic level.
Fortunately, most agree that this would be taking things to the extreme. Typically speaking ,emulators do their job down to the hardware specification and accurate digital logics. Once those tasks are accurately simulated, the emulator is considered complete and ready to be shipped. To emulate some hardware platforms sufficiently enough that they can be considered usable, it is sometimes necessary to be extremely precise – all the way down to the often undocumented features, analog components that are out of the manufacturing process for decades, individual clock cycles and even specific bugs that got implemented in the original hardware. All of this makes emulation a challenging goal for every developer, and it’s especially true when it comes to attempting to emulate classic home computer systems from the eighties like Commodore 64 and 128.