Emulation accuracy: Difference between revisions

*'''Emulation''' endeavors to recreate an entire historical architecture. This digital reconstruction seeks to faithfully capture the instruction set, timing behaviors, hardware features and even peripheral nuances of a bygone hardware platform. Unlike compatibility layers, which translate software instructions to a native format, emulation builds a virtual stage upon which the software itself can perform authentically. Emulation's intricate tapestry sometimes intertwines with threads of other technologies though. Notably, certain emulators leverage VM or hypervisor features for a more efficient handling of resource allocation and isolation such as Device Mapping & SMMU.[https://forums.pcsx2.net/Thread-Does-CPU-virtualization-feature-have-anything-to-do-with-PCSX2?pid=583191#pid583191][https://yuzu-mirror.github.io/entry/yuzu-progress-report-jan-2024/#device-mapping-and-smmu] Additionally, some emulators employ compatibility layers as subcomponents, acting as translators for specific libraries or APIs that might otherwise be incompatible with the host environment. Think of these layers as linguistic bridges, allowing the emulated software to converse fluently with the modern system hardware. By strategically merging these techniques including the help of skilled use of [[High/Low_level_emulation|HLE and LLE or Hybrid methods]], [https://github.com/xenia-project/xenia/wiki/ROV code paths for rendering output] and [[High/Low_level_emulation#Future_outlook|compute shader renderers]], [[Dynamic_recompilation|compiler techniques]], popular features such as Fast Memory Access[https://github.com/PCSX2/pcsx2/pull/5821][https://github.com/PCSX2/pcsx2/pull/7295][https://yuzu-emu.org/entry/yuzu-fastmem/#what-is-fastmem][https://dolphin-emu.org/blog/2016/09/06/booting-the-final-gc-game/], instruction set support (such as [https://whatcookie.github.io/posts/why-is-avx-512-useful-for-rpcs3/ AVX-512 for RPCS3]) and other various optimizations which may be platform specific ([https://web.archive.org/web/20240110213529/https://yunzu-emu.org/entry/yuzu-progress-report-dec-2023#android-adventures-and-kernels-with-benefits MADV_REMOVE] and context switches in SysV ABI used in *nix, [https://yuzu-mirror.github.io/entry/yuzu-progress-report-nov-2023/#project-nice Native Code Execution] instead of [[Dynamic_recompilation#See_also|JIT]] if ISA is appropriate, [https://github.com/RPCS3/rpcs3/pull/16692 link-time optimisations], [https://community.amd.com/t5/opengl-vulkan/vulkan-poor-performance-due-to-barrier-region-bit-being-ignored/td-p/501962 VK_DEPENDENCY_BY_REGION_BIT], [https://github.com/GPUOpen-Drivers/AMDVLK/issues/108 VK_EXT_fragment_shader_interlock] etc), certain emulators achieve impressive levels of performance and compatibility, further unlocking the doors to historical software [[Preservation_projects|preservation]].[https://youtu.be/cCXri4yDHmU]

Emulators tend to favor [[High/Low level emulation|High-Level Emulation (HLE) as opposed to Low-Level Emulation (LLE)]] for hardware demanding systems to emulate, <abbr title="This shouldn't be confused with compatibility though.">which results in lower accuracy</abbr> because instead of mimicking the hardware these games were released on, High-Level emulators mimic how the games themselves behaved on the desired system. While emulators like [[Dolphin]] favor accuracy but still retain HLE for performance and have [[High/Low_level_emulation#Examples|successfully used it to an advantage]], these types of exceptions are uncommon, and it can still hinder accuracy.

An emulator isn't accurate when it has a large amount of visual and audio glitches and favors performance as much as possible. To work around these glitches, emulator developers typically include game-specific hacks (and prioritize popular games) to skip over problems, such as compatibility issues that can cause games to break. Many times, these emulators will be deemed incompatible with the less popular (obscure) games. As Near (then known as byuu) explains in a 2011 Ars Technica article linked below, ''Speedy Gonzales: Los Gatos Bandidos'' will soft lock towards the end due to a specific hardware edge case that isn't emulated in [[ZSNES]] or [https://github.com/snes9xgit/snes9x/issues/280 Snes9x], but is properly dealt with in his own emulator [[higan]] due to his documentation of the system. This can also become very problematic when ROM hacks abuse software errors (emulator oversights) to create otherwise impossible behaviors to achieve what they can. When a ROM hack can only be used in that one specific emulator, he explains, it becomes incompatible with real hardware (either through a flash cart or printed), and that such an issue has occurred with [[ZSNES]] before and continues to occur with Nintendo 64 ROM hacks.

In summary, we can talk about three types of cycle emulation: "partial cycle-accuracy", "cycle-based accuracy" and "full cycle-accuracy". These can be considered as subsets of "cycle accuracy." Due to technical challenges and performance considerations, emulators often employ either "partial cycle-accuracy" or "cycle-based accuracy" depending on the specific requirements.

This focuses on replicating the timing of instructions and key internal operations, while simplifying or skipping over some less critical details. This can lower the performance requirements compared to full cycle accuracy. Remember, just because an emulator is partially cycle-accurate doesn't necessarily make it more precise than a highly accurate emulator. For example, CEN64 only emulates the CPU pipeline cycle-accurately and that's all, on the other hand Simple64 is more accurate in terms of timing for specific tasks like certain DMA transfers, even though it doesn't achieve partially cycle-accurate emulation.

Gate-level accuracy focuses on operating at the level of logical gates within a digital circuit. In this approach, the focus is to replicate the behavior of the system by emulating the interactions and operations of logic gates. This level of abstraction allows for a more efficient imitation of digital circuits, as it does not delve into the intricacies of individual transistors. This level of system emulation is suitable for scenarios where a higher-level understanding of circuit behavior is sufficient. This method of hardware imitation should not be recommended for general purposes (for example, casual gaming), because of its rather poor performance as a result of the emulator mimicking the desired machine at a very low level, and as such, requires loads of computational power to function.

Transistor-level accuracy represents a more granular emulation accuracy level that delves into the behavior of individual transistors within a digital circuit. This approach aims to replicate the electrical characteristics and interactions of transistors, offering a higher degree of accuracy at the cost of increased computational complexity, way more than that of gate-level accuracy. This method is the most accurate representation of the electrical characteristics and interactions within a machine's circuit, but due to its extremely demanding nature, it should not be recommended for most people looking to play their childhood video games not only because of its abysmal performance, but also because it requires way too much computational power to execute. This type of hardware emulation is great for hardware enthusiasts and homebrew developers who want to get a deep understanding of the functionality and behavior of the hardware in question at a very detailed level.

This type is unique in that its method, [[DICE]], emulates arcade machines from the early 1970s. The architecture of these systems is different from a modern architecture, mostly because they don't have a CPU. DICE emulates the discrete logic components of the machines at a circuit level and, although the results are accurate, you need a fast 64-bit CPU (for single thread performance) to run these arcade games at full speed. It's not as deep as gate or transistor-level emulation for other systems because chips are still treated as black boxes, though.