Hacker News Reader

Comment by Koshkin | Hacker News Reader

FPGAs are fun, for sure, but I still have never felt the flair of “authenticity” from the use of FPGA as opposed to software emulation on a microcontroller or the PC. In fact, software emulation is so much more practical, and you can simulate pretty much any aspect of it that you wish, not just the CPU and some peripherals. A modern flight simulator is another example of using software to bring the user’s experience close to what it would be in reality (especially with the VR gear).

View on HN

Often times it's not flair but latency! I have yet to find a handheld that plays my GBA titles with the same feel as my actual SP, save my Analogue Pocket which has an FPGA.

Um, I don’t understand how you might feel software emulation has more “flair of authenticity” than a MISTer rig. FPGAs don’t emulate hardware, they are hardware. They are almost exactly like the original.

I wonder how much the misapprehension that FPGAs somehow emulate is due to the fact that the way we configure them looks so much like code. VHDL is ghastly, but I prefer it over verilog bc verilog seems to actually try to look like C. I think especially for beginners it's too easy to lose sight of the fact that while you may "read through" your VHDL/verilog, that when it hits the FPGA fabric it's all going to happen in parallel. Maybe if the source matter were made to resemble data more than code, we could simultaneously ditch the verbosity of VHDL and the imperative algorithm appearances of verilog. I'm thinking maybe JSON at the moment. =P

They're hardware, but not the same set of logic as the original systems. They still rely on reverse engineering efforts that occur when developing software-based emulators. They produce the end results that were measured from the original system, but not the exact behavior. As a result, they're not naturally more exact than a software emulator.

Where the FPGA comes in handy is in concurrent logic and a fixed clock. This makes synchronization easy, and that is what makes software emulators much more demanding.

Some chips are well documented and some actually get decapped. There are cases where retro console cores really can be the same logic as the original. It's a lofty goal and we're certainly not there currently. Often software emulation is content to mimic the inputs and outputs and complete the task as observed. There can (and often are) strange corner cases or subtleties that are difficult to catch. Is it a big deal? Not usually, but it's an interesting challenge to pursue a perfect logical re-implementation that can survive longer than we will.

https://www.retrorgb.com/furrtek-maps-the-pc-engine-huc6270-...

The most important thing is that many emulators are not modeled in such a way as to offer cycle-accurate results, whereas this is easier to achieve with FPGA implementations of devices. You can see evidence of syncing issues from emulators just from reading things like the Dolphin emulator's update blog and how many times they're dealing with them [1]. This is a double-edged sword of course, as a cycle-accurate reproduction of the original hardware doesn't give the same opportunities to offer modern improvements like arbitrary scaling, updating textures, and makes state saving more of a challenge.

  1: https://dolphin-emu.org/blog/2022/09/13/dolphin-progress-report-july-and-august-2022/#50-16901-flush-command-buffers-after-multiple-efb-copies-by-tellowkrinkle

(the linked example also highlights how variations in hardware memory architecture present real hard challenges for software emulation, which would be simple to overcome in an FPGA)

In many cases they are the same set of logic as the original systems. That’s the point. Some are reverse-engineered guesses but the vast majority are tick for tick identical. How could a software emulation be more authentic?

They can both be equally authentic, there's nothing preventing either from doing the exact same thing as the other. But the software based one will have a lot more overhead keeping track of cycles and making sure things interact at the right time.

As willis936 points out, decapping can let us see the exact logic a chip uses, but only a minority of chips are decapped. It's extremely expensive and analysis is time-consuming. Most stuff is reverse-engineered. That doesn't mean it's all HLE, we can infer a lot of behavior, and the composite timing is known, so it's close enough to use, but not to archive the design for future generations.

Reply on news.ycombinator.com