Question

Possible Duplicate:
The importance of using a 16bit integer

If today’s processors perform (under standard conditions) 32-bit operations — then is using a “short int” reasonable? Because in order to perform an operation on that data, it will convert it to a 32-bit (from 16-bit) integer, perform the operations, and then go back to 16-bit — I think. So what is the point?

In essence my questions are as follows:

1. What (if any) performance gain/hindrance does using a smaller ranged integer bring? Like, if instead of using a standard 32-bit integer for storage, I use a 16-bit short integer.
2. “and then go back to 16-bit” — Am I correct here? See above.
3. Are all integer data stored as 32-bit integer space on CPU/RAM?

Answer 1

1. The processor doesn’t need to “expand” a value to work with it. It just pads the unused spaces with zeroes and ignores them when performing calculations. So, actually, it is faster to operate on a short int than a long int, although with today’s fast CPUs it is very hard to notice even a bit of difference (pun intended).

2. The machine doesn’t really convert. When changing the size of a value, it either pads zeroes to the left or totally ignores extra bits to the left that won’t fit in the target memory region.

3. No, and this is usually the reason people use short int values for purposes where the range of a long int just isn’t needed. The memory allocated is different for each length of int, like a short int takes up fewer bits of memory than a long int. One of the steps in optimization is to change long int values to short int values when the range does not exceed that of a short int, meaning that the value would never use the extra bits allocated with a long int. The memory saved from such an optimization can actually be quite significant when dealing with a lot of elements in arrays or a lot of objects of the same struct or class.

Different int sizes are stored with different amounts of bits in both the RAM and the internal processor cache. This is also true of float, double, and long double, although long double is mainly for 64-bit systems and most compilers just ignore the long if running on 32-bit machines because a 64-bit value in a 32-bit accumulator & ALU will be ‘mowed down’ during any calculation and would likely never receive anything but zeros for the first 32 bits.