Jump to content
  • Advertisement
  • entries
  • comments
  • views

Random mind dump

Sign in to follow this  


Just offloading some interesting tidbits; I might get around to formatting this into a more interesting post later.

  • Floating point determinism is bloody hard, but not impossible, to achieve
  • Syncing between x86 and x64 code is a nightmare
  • SSE2 is pretty much everywhere, so configure your compiler to use it
  • If you have to interact with the FPU, use /fp:precise (in Visual C++) and set the floating-point control bits to force 24-bit mantissas (i.e. IEEE single precision)
  • Starting with non-deterministic code is a recipe for immense frustration. Before screwing with floating-point determinism issues, start with all your code running on the same machine with the same instruction set and make sure it's deterministic at the algorithm level before diving into the ugly parts
  • Divide-and-conquer is essential. Narrow down on one area that's full of synchronization problems and fix it, then move on to other areas
  • In the same vein, having a way to feed the same exact input into multiple runs of the code (across machines etc.) is so useful you don't want to live without it
  • Beware compiler optimizations; you may spend a lot of time rooting around in icky FPU or SSE2 code figuring out why exactly things differ across builds, for instance. Know how to suppress (or encourage!) your compiler's optimizations selectively so you can get better consistency
  • Work from the bottom layers upwards. Get consistent simulation results for, say, your physics before worrying about higher-level logic bugs, especially latency-related issues. Nothing sucks like banging your head on what seems to be a logic bug when it's just your physics being snarky

    Might update with more as time goes by, or again as above, I might bother to actually write up the reasoning behind all this. For now I'll just dump it here and see if anyone finds it interesting :-)
Sign in to follow this  


Recommended Comments

Why do you need f[color=#282828][font=helvetica, arial, verdana, tahoma, sans-serif][left]loating point determinism so bad?[/left][/font][/color]

Share this comment

Link to comment
At work I developed a fairly comprehensive image/analysis library. Writing unit tests really threw me for a loop though. Input consistent image data to a function, expect consistent image data out, right? [b]No[/b]. [i]Especially [/i]when your code splits into different optimized branches depending on what instruction sets the user may or may not have.

Even Windows XP does some things different between 32 and 64 bit versions. Blit some antialiased text using built in Windows functionality and the output will be different depending on the system (though the end user may not notice).

Share this comment

Link to comment
I have had fun floating point issues too: [url="http://stackoverflow.com/questions/10303762/0-0-0-0-0"]http://stackoverflow.com/questions/10303762/0-0-0-0-0[/url]

Share this comment

Link to comment

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!