Desync on all replays and games with Windows 11 Arm on M1 Max Apple
-
From the first link these two function calls are important to ensure deterministic floating point calculations across different systems (such as Intel and AMD):
_controlfp(_PC_24, _MCW_PC)
_controlfp(_RC_NEAR, _MCW_RC)The first is Precision Control, the second is Rounding Control. According to the microsoft documentation linked for controlfp - setting the Precision Control to 24 bits is not supported on ARM. Making this call on ARM will simply not change anything. The Rounding Control to NEAR seems to be ok.
(Precision Control is not supported for x64 either, but supreme commander FA is 32-bit application I think)
-
On a second thought, might also be this assert that fails the first tick:
gpAssert( (_controlfp(0, 0) & _MCW_PC) == _PC_24 );
Since setting the _PC_24 flag does not do anything on ARM, when checking the flags, that will be unchanged. First thought - could we disable one of these asserts with a patch? Or somehow pretend the flags are always set as expected on Apple Silicon with _PC_24 set (or redefine _MCW_PC)?
However, two more interesting bits of information I found, comparing Intel and Apple Silicon, which seems to hint at calculations using binary64 (double) match but binary32 (single float / 32 bit (24 bit precision)) don't match:
https://eclecticlight.co/2021/04/22/can-you-trust-floating-point-arithmetic-on-apple-silicon/
If so, that would mean the proper fix would be to replace all single floats in the game with double floats.
-
Hello everyone,
wondering if this issue was still being looked at by someone?This post made me remember about it.
https://x.com/lauriewired/status/2113322490219118804Quite related according to https://github.com/FAForever/downlords-faf-client/pull/3504
`There’s a hidden dagger in almost every PC game from 1995-2005 that murders ARM processors.
It’s kind of an accident, and it all has to do with floating points.
x87 was Intel’s floating point extension to x86. I won’t get into all the historical drama, but Intel decided that all internal float math would be at 80-bit extended precision to reduce rounding errors.
Of course, today no one in their right mind uses 80-bit; standard 64-bit doubles are just too convenient. Modern ARM64 doesn’t have any 80-bit hardware!
This creates a nasty problem for emulation. How much x87 arithmetic can you replace with say, native ARM64 floating point (losing precision!) without breaking behavior?
It’s not so simple; dropping 16-bits of precision can cause funny physics glitches and such. But boy, if you need all 80-bits, the software fallback REALLY stinks.
With all the decomp/recomp hype lately, porting OG Xbox and PC games to mobile / ARM devices is extra tricky. Not impossible, but you’d be amazed at how much x87 code is in old games!`
-
Since you referenced my pull request: it was never done to be able to actually play with it. I just need it to run the client and test FAF things while I mostly use a macbook
Hello! It looks like you're interested in this conversation, but you don't have an account yet.
Getting fed up of having to scroll through the same posts each visit? When you register for an account, you'll always come back to exactly where you were before, and choose to be notified of new replies (either via email, or push notification). You'll also be able to save bookmarks and upvote posts to show your appreciation to other community members.
With your input, this post could be even better 💗
Register Login