Operation on different data types

Considering the basic data types like char, int, float, double etc..in any standard language C/C++, Java etc

Is there anything like.."operating on integers are faster than operating on c开发者_StackOverflow社区haracters".. by operating I mean assignment, arithmetic op/ comparison etc. Are data types slower than one another?

For almost anything you're doing this has almost no effect, but purely for informational purposes, it is usually fastest to work with data types whose size is machine word size (i.e. 32 bits on x86 and 64-bits on amd64). Additionally, SSE/MMX instructions give you benefits as well if you can group these and work on them at the same time

Rules for this are a bit like rules for English spelling and/or grammar. The rules are broken at least as often as they're followed.

Just for example, for years "everybody has known" that floating point operations are slower than integers, especially for more complex operations like multiply and divide. In reality, some processors do some integer operations (especially multiplication and division) by converting the operands to floating point, doing the operation in floating point, then converting the result back to an integer. As you'd expect from that, the floating point operation is actually faster (though only a little bit).

Most of the time, however, it doesn't matter much -- in a lot of cases, it's quite reasonable to think of the operations on the processor itself as free, and concern yourself primarily with optimizing your use of bandwidth to memory. Of course, doing that well is often even harder...

yes , some data types are definitely slower than others. For example , floats are more complicated than int's and thus may incur additional penalties when doing divides and multiplies. It all depends on how your hardware is setup and what kind of instructions it supports.

Data types which is longer than the machine word size will also be slower because it takes more cycles to perform operations.

depending on what you do, the difference can be quite large, especially when working with floats versus double versus long double.

In modern processors it comes down to simd instructions, which have certain length, most commonly 128 bit. so four float versus two double numbers.

However some processors only have 32 bit simd instructions(PPC) and GPU hardware has a factor of eight performance difference between float and double.

when you add trigonometric , exponential, and square root functions into the mix, float numbers are going to have better performance overall given number of factors.

Almost all of the answers on this page are mostly right. The answer, however, varies wildly depending upon your hardware, language, compiler, and VM (in managed languages like Java). On most CPUs, your best performance will be to do the operations on a data type that fits the native operand size of your CPU. In some cases, some compilers will optimize this for you, however.

On most modern desktop CPUs the difference between floating point and integer operations has become pretty trivial. However, on older hardware and a lot of embedded systems the difference in all of these factors can still be really, really big.

The important thing is to know the specifics of your target architecture and your tools.

This answer relates to the Java case (only).

The literal answer is that the relative speed of the primitive types and operators depends on your processor hardware and your JVM implementation.

But a better answer is that it usually doesn't make a a lot of difference to performance what representations you use. Indeed, any clever data type optimizations you do to make your code run fast on your current machine / JVM may turn out to be anti-optimizations on a different machine / JVM combination.

In general, it is better to pick a data type that represents your data in a correct and natural way, and leave it to the compiler to sort out the details. However, if you are creating large arrays of a primitive type, it is worth knowing that Java uses compact representations for arrays of boolean, byte and short.