Thread: conversion from double to float - loss of data

x87 is nowadays often used to distinguish between the SSE and the old instruction sets.

I did some research on this very topic some time back and found that the instructions for double and float at the FPU assembly level execute at almost identical speeds. If I remember correctly the opcodes are the same and it is the data size that is the difference (or the operand size). So if you looked at the assembly code you would see the same opcodes being used regardless of the C data type. I remember coding a bilinear interpolation in pure asm using the FPU and it was very fast. Fordy came along and showed me how to make it faster. Now this is a moot point since I get it for free from the GPU.

The native data type for the FPU is larger than both float and double. So at the assembly level the FPU really doesn't care and I believe uses saturation to fill the unused bits. But what some have said about being able to store more floats than doubles in the data type does hold some weight so that may be the key here.

In the end I doubt seriously if you will see a huge performance hit by simply using doubles instead of floats. The surefire way to tell is to code an algorithm and profile it using floats and then using doubles. You won't find a big difference. The FPU is EXTREMELY fast at floating point operations and has come a very long way from the first gen math-co's. So much that I now believe that a floating point operation is as fast as an integer operation. Previously look up tables were used but now the time it takes to look-up the value and the possible cache thrash to do so is actually slower than just telling the FPU to do the operation.

Now when it comes to graphics most GPUs appear on the surface to work with floats so it would probably be best to maintain data type consistency with them. However I'm not sure what they use internally.

An interesting note is that my manual on the 486 processor shows that all FPU instructions execute at the same speed regardless of the underlying data type. The clock cycle counts are identical with float or double. Newer Intel manuals do not show the clock cycle counts. I could not find any clock cycle counts in my IA32 or IA64 tech refs.

The x87 always works on 80-bit units. That's the size of the FPU registers. To work with any data type, you load the values into the register stack and do something. Size normalization is done during the load, so the opcodes are the same.

GPUs have only recently learned to handle 64-bit units. They're probably still better at dealing with 32-bit units. Also, since bandwidth remains the #1 bottleneck in graphics (unless you use absurdly complex shaders), cutting the data size in half is probably a good thing.

And of course, there's the 128-bit SSE registers that can fit 4 32-bit values, but only 2 64-bits. A well-parallelized algorithm could execute up to twice as fast.

char uses 1 byte, because that's the C++ definition of a byte. char also has a minimum of 8 bits.
Beyond that, there's only relations.