86Box: Why Not Pentium III?
86box.net
86box.net
With old hardware, the sort I imagine 86Box is mainly used to emulate (it's how I use it, anyway), old OSes rely on specific behavior of old systems and peripherals that can't be easily virtualized through KVM + QEMU or the like. A mixture of processors being too fast and behaving subtly different, possibly due to differences in "undefined behavior".
I doubt there's a binary cutoff point where it's obviously more useful to virtualize or emulate, but it's obvious that emulating an 80386 is ideal, and virtualizing a "Core 2 Duo" is ideal, for running software from those respective periods. Is the Pentium III desirable to emulate, and simply not computationally feasible, or is this just people wanting to make cool things for cool things' sakes? Or a little of both?
This sounds interesting. Do you have examples of these behaviors where something is faulty using standard virtualization versus hardware-level emulation? (I know clock speed can make a difference.)
https://blog.stuffedcow.net/2015/08/win9x-tlb-invalidation-b...
These crashes are not related to clock speed. While Windows 9x already cannot run on these CPU due to clock speed, the clock speed issues have mostly been patched in 9x.
And 9x can still be virtualized even on the latest Intel iMac, with nested paging enabled (or not). On AMD, you need to disable nested paging due to the above change in behavior.
I wonder if in some sense there isn't a market for someone to just make new motherboards instead for this stuff using modern parts. I realize there are some licensing issues after a certain point, but in theory everything up to a PIII should be doable. Particularly since memory controllers are in the chipset there are options to use things like modern ram chips and then 'downgrade' performance to be compatible in the chipset. This could also be used to allow for modern M.2 SATA drives to be run in IDE emulation mode locally or even have SD/CF options directly on the board.
The main downside at that point is space of course, hardware always takes up more space than an emulator ;)
https://en.wikipedia.org/wiki/List_of_VIA_chipsets#:~:text=V....
But to your original point: CPUs don't really fail unless abused is my understanding. The bad ones are filtered out at the factory before they ever get to consumers.
I bet there are modern PCI cards out there that can add a hard-to-emulate processor to a consumer/prosumer-grade system, but I'm not sure what to search for.
There’s decent availability of PCI and AGP GPUs supported by OS 9 and early OS X, especially if you include PC variants that can be flashed to work with Mac OS, so I wouldn’t worry about video too much in the short term… just make sure the motherboard has a PCI or AGP slot.
If there was a demand they could probably do the same for older models if they can harvest enough chipsets. There were quite a few 430HX's on embedded modules that could be recycled...
It might not be possible to do it with an interpreter, but a well-designed JIT should be able to shift the cost of calculating instruction scheduling and cycle-costs from execution time to JIT time.
Since OoO CPUs spend long stretches of time between branch miss-predicts and L1 cache misses, you can get long sequence of instructions that executing with the exact same timings every time. A tracing JIT is perfect for this usecase. You just need to normalise the pipeline state on entry (and this since this normally happens after a miss-predict, the pipeline is often drained), and then exit on every branch miss-predict or L1 cache miss and start a new trace.
I suspect such a scheme might be fast enough for a Pentium III, I just need to find some time to actually try out my ideas at some point.
https://dl.acm.org/doi/10.1145/384265.291063
It’ll help, but still won’t get you down to the 10-20x cycle overhead range that you need to claim success.
You a right, they get a 190-360x overhead, and on today's CPUs, I think I need need to get it down to about 20-30x overhead to get realtime on current CPUs. It's only off by a single order of magnitude.
Though, it would be fast enough for some usecases. 10% of realtime would be bearable for some TAS usecases.
It might be possible for me to improve on what they have. For starters, they aren't using a trace-based approach and I think they are applying the memorisation on every single branch, correctly predicted or not, and every single memory access (even when they hit L1). But I would need a 10x improvement over what they had, and that's a big ask.
gem5 is a simulator that aims to do precisely all that, and yes it is extremely slow. Probably on the order of 100x slower, but I don't have timings to hand.
Similarly booting a small processor compiled into C++ with verilator is very taxing on the processor too.
My friend wrote an NES emulator decades ago and he fit this model. Got into flamewars on Zophar's Domain and such lol
It's difficult to let go of your code baby, especially when you could technically do it all on your own. It's probably easier when the task is so large there's no way you could do it alone
I've been following the 86Box project from the sidelines and seems to be one of the few projects that actually handles people issues well.
Performance is secondary, you can think of the emulation as a lasting documentation, which in time comes usable due to improvements of hardware and software, or can be used as a reference for FPGA, ASIC or alternative implementations.
This is not a videogame console where all hardware was the same, or the early PC world were everything was designed for the Intel 8086 timings as on the IBM PC. This is the modern PC world. Which exact CPU model would you even choose to emulate ?
If there was SMP P3 emulation, then I could (albeit at horrible speed, at the moment) but at some point, it'd become quite reasonable.
There is no cycle-accurate emulation, but again the question is: why would need cycle-accurate emulation to run win2k? It runs just fine on virtualizers, even.
What you are asking is FPGA territory anyway, maybe not even that, the Pentium 3 is too complex to accurately emulate.
The XBOX, but for PC it doesn't has sense unless you want cycle accurate emulation to exploit SSE under an emulated OS such as Windows 98 under Bochs.
You are correctly that software doesn't require fully accurate timings. Just accurate enough to bypass any timing bugs and replicate the experience. Especially outside of the console space. If your only goal is running all known software, then you can get away with some massive accuracy bugs.
But there is more to hardware preservation than simply running all software that might have been shipped on a platform. Some people want to do retro programming and develop new software for a platform. And if you don't have accurate emulation, then the more likely you are to introduce a bug that works in the emulator but not on real hardware. The less accurate an emulator, the more often you have to check on real hardware. And since there was such a wide variety of real hardware, your collection would have to be huge to ensure extensive testing.
You could argue that people wanting to do retro-coding as a hobby should just test on real hardware, but I'd argue that raises costs to the hobby. Also, in the distant future, the last Pentium III will die, and acquiring real hardware might not be possible. I have no idea if people will still be interesting in retro-coding for the Pentium III that far in the future, but my point is the hardware is not truly preserved unless they can.
BTW, the Pentium III was used in a console, with identical hardware configurations, so an accurate P3 might be more useful there.
Though, the Pentium III was used in a video game console. An accurate emulation could be more useful there.
> Some people want to do retro programming and develop new software for a platform. And if you don't have accurate emulation, then the more likely you are to introduce a bug that works in the emulator but not on real hardware.
The two things go hand by hand. If era-developed software is unlikely to suffer from timing bugs, then _your own software_ is also unlikely to suffer from timing bugs. It's down to the same argument.
It's like claiming that because I developed for Pentium 4, my software is unlikely to work on the Pentium 3. Save for the very explicit case that I use some new extensions, how crazily out of the way would I need to go in order to even remotely hit such an issue?
In fact, it can all be summarized to: what CPU timing would you even emulate ? Why would you even target the P3 _specifically_? Why not Transmeta?
Note that this does not apply to accuracy emulation of accompanying hardware, but then again I would also claim that accuracy of hardware emulation is hardly relevant post-P3, since _the real hardware_ often is massively inaccurate by any definition of the word. Why accurately model a specific Radeon card, when the budget model of the same year is completely different , with the differences abstracted by hacks in the driver ?
How do you know if your game will run at 60 fps if the execution times aren't accurate?
> what CPU timing would you even emulate
Ideally your emulator would support as many CPU + hardware configurations as possible, at many different speeds, so you can test as many as you want.
But just one single accurate hardware configuration is better than none. At least then I can say "I programmed this game it runs on a Pentium III 550E, with a Riva TNT2"
It's exactly the same when doing retro-programming on real hardware. If you only have one PC, then you can only confirm it's working on that exact same hardware configuration. But accurate emulators have advantages due to cost and ability to easily support multiple configurations.
Again, this is not a console. If you rely on a specific Pentium 3's instruction timings to reach 60 fps, your game is not going to reach 60fps _on any other PC_, not even if someone has an identical CPU, since any single other difference in hardware, configuration, or even layout of the filesystem is going to matter much more.
You just can't get away with the same kinds of bug you can get away with in consoles, because even just trying ATI vs NVIDIA (or any two different brands of accelerator) is already going to be a completely different environment and timings, likely enough to trigger all those bugs (or at least more than different instruction timings will).
i.e. even the simplest of emulators (incl. a virtualizer) with a runtime cap is going to suffice for the usecase of mildly estimating a framerate based on the CPU of some era. And there's very little value to increase the accuracy of such estimation since with so wildly varying PC hardware anything you can produce is going to be irrelevant anyway.
(How to make a similar accurate-enough estimation of GPU performance is a different story).
For a mental exercise, just to prove it to yourself, why don't _you_ try examining all the reasons such accurate emulation might be desirable?
The other poster already provided a reasonable motivation - preservation. But since this discussion started, you've only really come out swinging with disparagement. One has to wonder why you are putting so much energy into suppressing and trashing someone's hobby.
Frankly it looks to me like you have some kind of preconceived and inflexible bias, or that you maybe trying to discover the appeal to this effort in a pointlessly adversarial way. Not a great look. If you really want people to think you have a smart, winning argument maybe try to show some understanding of both sides of the coin before floating your attempt at a clever and withering denouncement.
The most issues you would have it's for high 486-Pentium I-II era games (specially the multimedia ones) which lots of them were speed bound, but for sure these games will be interpreted by ScummVM one day or another (Macromedia Director engine).
I am asking a question, and answering "preservation" (which is not really the answer the poster made, since his goal is new development) without giving an actual concrete example of what behavior needs such accurate preservation kind of defeats the purpose of asking the question in the first place.
If the answer is "for the sake of it" that is also fine. But I'm unaware of anything post-P3 that would really require cycle-level emulation, so I ask. Most PC emulators "draw the line" around that era for a reason, even the ones who wouldn't necessarily have performance problems with newer machines (like DosBox).
> But since this discussion started, you've only really come out swinging with disparagement. One has to wonder why you are putting so much energy into suppressing and trashing someone's hobby.
What do you think? Because not only I have the same hobby, my work is also related to this. I am most definitely not interested in thrashing it.
It is also the _main thesis_ of this entire article, so why shouldn't we discuss it?
Either a real machine, or a accurate emulator.
It doesn't matter if there is other PC hardware configurations out there with different preformance. A minimum requirements just means "I tested on this machine, and it meets the minimums." Ideally you should underspec your minimum requirement test machine so that your target audience can be reasonably expected meet it.
You can't substitute in virtualization. That has zero chance in hell of providing a realistic estimate of performance, even if you paired it with an accurate gpu emulator.
Modern CPUs simply have very different performance characters, instructions that might have huge stalls on the P3 might be extremely cheap under virtualization. Caches are also widely different sizes.
If you use a proper, but inaccurate emulator, you get different issues. Even if it was tuned to provide a decent estimate of cpu performance over average code (and they are typically tuned to overestimate cpu preformance, because people playing games would rather framedrops from real hardware are not emulated), it's just an average that doesn't take into account things like cache misses and branch misspredicts.
If you were to write code with a lot of cache misses or branch misspredicts, your inaccurate emulator would massively overestimate it's preformance compared to a real cpu.
The various issues just add up and it becomes impossible to profile and optimise the game you are developing unless you have an accurate emulator. Other solutions will all point to different parts of the code being hot.
Also, remember this is within the era when you might be still developing a game with a software renderer, and if not you still have to do vertex transform and lighting on the cpu.
Personally I'm not that interested in accurate emulation of PC, the issues get a lot worse when it comes to developing games for 5th, 6th and maybe even 7th gen consoles. That's were my true interest in accurate OoO emulation lies. But I can see why someone might want accurate PC emulation too.
This just doesn't happen in modern PC development, save for heavyweights who can afford multiple identical hardware configurations (e.g. HPC clusters). I know I'm repeating myself, but the variety of configurations just makes this highly implausible. Sure, you can be some demoscene type of guy who decides to target specifically this configuration, but then you're literally targeting one processor out of hundreds, and per your own words, the fact that it works on the 500Mhz doesn't mean it will work with the same performance on the next generation or even on the 550Mhz variant. I guess this is obviously fine, but really stretching it. You'll quickly end up having something that only works on your machine, with the same starting disk image, etc.
Even PCem doesn't fully simulate the x86 cache because there is no benefit to it, and that includes cores from eras which were much more sensitive to timing. Branch mispredictions? Forget about it. Most P3 software is going to run concurrently to some other software, anyway.
I'm not saying that you don't need a cycle-accurate simulator to get real timings. I'm saying that with such a large divergence in configurations and environments, virtualization (or any other inaccurate emulator) is likely to provide a performance level that is quite accurately somewhere in the interval. Most specially since you will have actually calibrated it to that interval beforehand :)
Now on consoles I can see the benefit. Consoles are lots of identical hardware, operating systems that tend to get out of the way, and the people who develop for them only test (for obvious reasons) on the console hardware itself or at most a developer edition which has the same hardware (for obvious reasons again). You can have a silent bug that depends on timing of a mispredicted branch or the relative speed between the bus accesses of two cores and _never_ notice it since your testing environment is exactly 1 device (such a bug would immediate flare on a PC on like the 2nd reboot). Whatever it is that you develop for any one such console, it is highly likely it will work on all the million other sold consoles. Consoles are practically designed to have reproduce-able environments.
On the other hand you practically can emulate the entire x86 software catalog with emulators which _still_ have large differences in behavior at the actual instruction level compared to the hardware, so the instruction timing doesn't really seem important, and creating now some software that does depend on it seems .. complicated.
As an anecdote, not long ago I was working on a x86 emulator, and to my horror I realized that the push/pop instructions were actually miscomputing the operand size on a rather common but not primary situation (long mode but with a 32-bit segment). The emulator was pushing the stack by double the amount it should, and pushing/popping the high dword of registers it shouldn't have clobbered. This was actually happening in some of the most critical operating system code out there (bootloaders, WoW, etc.) ... and yet the bug had been in the emulator for years and no one had been the wiser, booting 64-bit OSes just fine :)
If you aren't using at least one accurate configuration for your testing, there is a huge risk that you miss your performance target by a huge margin. Your 60fps game could end up running at 20fps on your target minimum hardware. Small performance inaccuracies can massively add up if you have a non-emulated cache-miss or branch miss-predict delay in your inner-most loop.
I think you are massively overestimating how accuracy of timings that you can get though virtualisation or semi-accurate emulation. Yes. They are probably accurate enough for running any historic software from the era, as most code for the PC is well-behaved to not do the wrong thing when running too fast.
It's just for the use-case of developing new software, as soon as you start optimising or profiling, you need accurate timings. And yes, we might be talking about weird demo-scene style projects along the lines of "I want to get the absolute best possible graphics out of the computer I had 25 years ago, no frames dropped, no wasted cpu cycles". I'm talking about the kind of project were someone is writing inner loops with intrinsics or in assembly.
You might argue that such a project is a massive edge case that it's not worth catering too. And if you are writing an emulator, that's a 100% legitimate position to hold, emulators shouldn't have to cater for every possible usecase. My point is only "If you don't have a 100% accurate emulator, and there is some niche use case it can't emulate, then the hardware isn't fully preserved" and that it would be nice if an accurate emulator existed.
> Now on consoles I can see the benefit. Consoles are lots of identical hardware, operating systems that tend to get out of the way, and the people who develop for them only test (for obvious reasons) on the console hardware itself or at most a developer edition which has the same hardware (for obvious reasons again).
Yes, I've chased after bugs in console emulation (Dolphin Emulator) that were impossible to fix correctly without significantly more accurate emulation.
Like the game which memset a staging buffer before data had finished DMAing out. The game was only saved on real hardware because after memsetting, it invalidated the cachelines and in typical situations, none of the memset cachelines had been evicted. Impossible to correctly fix without emulating the existence of an L2 cache. We eventually resorted to patching the game to fix the bug.
Or games where video decoding stutters, because it has a hot inner loop that push the out-of-order CPU and has very few cache misses. It executes faster over the whole frame on real hardware than Dolphin's CPU timing model, which assumes a certain number of cache misses. The game must have tuned it's video codec to use as much CPU time as possible.
We have speed running tricks that don't work in Dolphin, because the depend on lagging the game. And games that freak out when the GPU executes too fast, but when you adjust the timings for those other games freak out because the GPU is executing too slow. It's impossible to calculate accurate GPU timings without running much of vertex transform and a basic depth rasterizer.
These are projects I'd love to work on at some point, accurate CPU and GPU timings for Dolphin, even if they don't run at full speed and bus contention is still ignored. I think might be possible to get within the correct order of magnitude (so 10-50% of realtime), which is workable for some usecases like TASes and testing bugs.
Yet... Like I said, you can get pretty far with low-levels of accuracy. PS2 emulation is actually quite timing sensitive.
I have at least one bug in Dolphin that I investigated, that can't get fixed correctly until we get significantly better GPU timings. And also some speed-running strategies that rely on generating enough lag, but don't work in dolphin because it (usually) emulates the CPU and GPU way too fast.
This makes sense in principle, but exact emulation is something computationally prohibitive even for a (probably) 386¹. The computational problems of exact emulation have been described in a famous article about emulating the SNES².
I suppose that emulating even "just" a superscalar architecture is going to be prohibitive (due to the split into micro ops), and an out-of-order one would probably require transistor-level emulation (or at least, another, lower, level of emulation).
¹=Fairly arbitrary; I'm basing this just on the complexity of emulating the SNES, and the following considerations.
²=https://arstechnica.com/gaming/2011/08/accuracy-takes-power-...
BTW Intel has this internally
I would guess this article is an effort to distance themselves from this dev if people google it
https://www.reddit.com/r/emulation/comments/tjnxg3/why_not_p...
The developer of 86Box as a rule has a history of backing up their claims -hence 86Box which has gone from strength to strength in the years since being forced to fork from pcem.
A *LOT* of people float into the project's discord and ask "pentium III when?" -this addresses that, as well as answering the overly ambitious promises made by a recent fork of 86box.
Having the wrong scope can be very detrimental to a project in general, and although I'm not an emulator developer I feel this is probably especially true in this case.
Socket 8 Pentium pro 200 is just universally great for everything. Disable cache and move down to 150 and you can run older stuff quite well with no hyper speed. I have a bunch of old system presets I use every day. I got a win98se setup that is usually socket 7, super 7 or socket 8 for most stuff. It has 4 55GB VHD drives mounted to it. It's great. Every DOS game is just there. Bunch of Windows software ISOs too. Got a bunch of 2gb dos compatible disks and every DOS version installed and ready to go. I'll toy around with all the OS/2s sometimes too, very cool system.
But please, just polish what is there!
That's AIUI what box86 targets on the CPUs it supports emulating.
The original Rosetta software provided during the PowerPC to Intel x86 transition was an instruction and system call translation layer. I haven't used Rosetta 2 but it's probably similar.
As I understand 86Box is emulating specific chip implementations and all of the peripherals, cards and boards needed to run them, not just translating instructions. This makes the emulated machines appear to the guest OS as real hardware, I assume with all the flaws and quirks included.
I wonder though about truly ancient x86, why aren't there more clean-room clones of those?
Probably you could use an FPGA a bit smaller if you use FPGA-native memory for L1-L3 instead of transistors, but you'll nevertheless need an FPGA that is many orders of magnitude too expensive for a hobbyist niche project. Also, you would need serious quality photographs of the die... which can be done for old and small chips on a budget, but will be really expensive even for something of the Pentium 3 era.
What has always interested me though: how are CPUs and modern GPUs actually developed, given that FPGAs are way, way too small and silicon-making runs extremely expensive?
[1] https://www.computerhistory.org/revolution/story/330
[2] https://hackaday.com/2019/09/24/who-could-possibly-need-an-f...
Far from a Pentium MMX.
FPGA LUTs are quite sophisticated, the LUTs in both Xilinx and Intel's latest offerings are able to implement an arbitrary boolean logic function with up to 6 inputs and 1 output. The FPGA also comes packed with other specialized hardware such as on chip memory and multipliers so you do not need to burn logic to use those things. You very likely could fit a Pentium III on a moderately large FPGA.
The real challenge would be matching the clock speed of the original processor. Even 400MHz of the first pentium IIIs on the market might be difficult, getting near 1GHz is likely impossible.
At least some of it is done on FPGA clusters, boards with multiple enormous FPGAs. Cost of such a system is in at least 6-7 digit range.
Why would emulating x86 be so much harder, especially since you can actually use the host x86 cpu... via hardware hyoervisors e.g. https://github.com/intel/haxm
86Box is not entirely cycle accurate, but much more accurate than QEMU, so no patches are required.
gem5 is on the other end of the spectrum, it can emulate hardware very accurately, but very slowly.
That's unwarranted hubris.
It's not your call to tell developers where to direct their volunteer efforts.