I'm writing an application which reads large arrays of floats and performs some simple operations with them. I'm using floats because I thought it'd be faster than doubles, but after doing some research I've found that there's some confusion about this topic. Can anyone elaborate on this?
Thanks.
This indicates that floats are slightly faster than doubles: http://www.herongyang.com/cs_b/performance.html
In general, any time you do a comparison on performance, you should take into account any special cases, like does using one type require additional conversions or data massaging? Those add up and can belie generic benchmarks like this.
floats should be faster on a 32-bit system, but profile the code to make sure you're optimizing the right thing
The short answer is, "use whichever precision is required for acceptable results."
Your one guarantee is that operations performed on floating point data are done in at least the highest precision member of the expression. So multiplying two float's is done with at least the precision of float, and multiplying a float and a double would be done with at least double precision. The standard states that "[floating-point] operations may be performed with higher precision than the result type of the operation."
Given that the JIT for .Net attempts to leave your floating point operations in the precision requested, we can take a look at documentation from Intel for speeding up our operations. On the Intel platform your floating point operations may be done in an intermediate precision of 80bits, and converted down to the precision requested.
From Intel's guide to C++ Floating-point Operations1 (sorry only have dead tree), they mention:
- Use a single precision type (for example, float) unless the extra precision obtained through double or long double is required. Greater precision types increase memory size and bandwidth requirements. ...
- Avoid mixed data type arithmetic expressions
That last point is important as you can slow yourself down with unnecessary casts to/from float and double, which result in JIT'd code which requests the x87 to cast away from its 80bit intermediate format in between operations!
1. Yes it says C++, but the C# standard plus knowledge of the CLR lets us know the information for C++ should be applicable in this instance.
If load & store operations are the bottleneck, then floats will be faster, because they're smaller. If you're doing a significant number of calculations between loads and stores, it should be about equal.
Someone else mentioned avoiding conversions between float & double, and calculations that use operands of both types. That's good advice, and if you use any math library functions that return doubles (for example), then keeping everything as doubles will be faster.
I profiled a similar question a few weeks ago. The bottom line is that for x86 hardware, there is no significant difference in the performance of floats versus doubles unless you become memory bound, or you start running into cache issue. In that case floats will generally have the advantage because they are smaller.
Current Intel CPUs perform all floating point operations in 80 bit wide registers so the actual speed of the computation shouldn't vary between floats and doubles.
With 387 FPU arithmetic, float is only faster than double for certain long iterative operations like pow, log, etc (and only if the compiler sets the FPU control word appropriately).
With packed SSE arithmetic, it makes a big difference though.
I'm writing a ray tracer, and replacing the floats with doubles for my Color class gives me a 5% speedup. Replacing the Vectors floats with doubles is another 5% faster! Pretty cool :)
That's with a Core i7 920
for(long i=0; i<100000000; i++) { float1 = (float) i / 17.0; } for(long i=0; i<100000000; i++) { double1 = (double) i / 17.0; }
I have always thought that the processors were optimized or the same regardless of float or double. Searching for optimizations on my intensive computations (lots of gets from a matrix, comparisons of two values) I found out that floats run about 13 % faster
This surprised me, but I guess it is due to the nature of my problem. I don't do casts between float and double in the core of the operations and my computations are mainly adding, multiplying and substracting.
This is on my i7 920. Running a 64bit operating system.