Loss of precision when using float

[Serpentine]

* the compiler is not good

They're being used for the most widespread container datatypes, a compiler should never touch that. If it was to do with a simple function returning ints as doubles or doing simple operations between doubles and ints; but these are pretty commonly avoided by the dev in the first place

 

* your CPU (32 bit mode?) is not good (and/or only one CPU core is used, anyway, the other one/two/four are idling)

These days, modern x86/AMD64 based processors will deal with single and double precision in the same manner(the same 80-bit internal comparisons etc), removing bandwidth and and memory use there'd be effectively little to no difference. I don't think anyone is running DR on a router or a p1!

 

* the renderer is not good (as in "it does waay too much work, the bulk should be on the GPU, not the CPU")

Graphics cards deal with floats not doubles, this is the reason why it is so beneficial. A modern gpu march will deliver about 25% of the throughput on doubles compared to floats. Some driver optimizations and such will automatically do this in cpu to avoid the massive penalties, but with GPGPU becoming more common it's hard to try and divine when it is safe. This is almost certainly the reason.

 

Anyway, it's always a good idea to have a read through Agner's pdfs over at http://www.agner.org/optimize/ They're written in a really nice to read style, data and code is represented really well and it's for the most part really interesting and constantly being updated and expanded.

[STiFU]

25% huh? That does indeed match up with Greebo's frame rendering time measurement... This is very interesting. We should definitely go for it. Just make the change revertible, so that it's easy if we should run into problems later on. After all, we do have an SVN. Another option would be the preprocessor of course.

[greebo]

It's already in SVN since yesterday.