Efficiency of different integer sizes on a 64-bit CPU

Question

In a 64-bit CPU, if the int is 32 bits whereas the long is 64 bits, would the long be more efficient than the int?

Answer 1

The main problem with your question is that you did not define "efficient". There are several possible efficiency related differences.

Of course if you need to use 64 bits, then there's no question. But sometimes you could use 32 bits and you wonder if it would be better to use 64 bits instead.

Data Size Efficiency

Using 32 bits will use less memory. This is more efficient especially if you use a lot of them. Not only it's more efficient in the sense that you may not get to swap out, but also in the sense that you'll have fewer cache misses. If you use just a few then the efficiency difference is irrelevant.

Code Size Efficiency

This is heavily dependent on the architecture. Some architectures will need longer instructions to manipulate 32 bit values, others will need longer instructions to manipulate 64 bits values and others will make no difference. On the intel processors, for example, 32 bits is the default operand size even for 64 bits code. Smaller code may have a little advantage both in cache behavior and in pipeline usage. But it is dependent on the architecture which operand size will use smaller code.

Execution Speed Efficiency

In general there should be no difference beyond the one implied by code size. Once the instruction has been decoded the timing for mere execution are generally identical. However, once again, this is in fact architecture specific. There are architectures that do not have native 32 bit arithmetic, for example.

My suggestion:

If it's just some local variables or data in small structures that you do not allocate in huge quantities, use int and do it in a way that does not assume a size, so that a new version of the compiler or a different compiler that use a different size for int will still work.

However if you have huge arrays or matrixes, then use the smallest type you can use and make sure its size is explicit.

Answer 2

On the common x86-64 architecture, 32-bit arithmetic is never slower than 64 bit arithmethic. So int is always the same speed or faster than long. On other architectures that don't actually have builtin 32-bit arithmetic, such as the MMIX, this might not hold.

Basic wisdom holds: Write it without considering such micro-optimizations and if necessary, profile and optimize.

Answer 3

If you are trying to store 64 bits of data, use a long. If you aren't going to need the 64 bits use the regular 32 bit int.

Answer 4

Yes, a 64bit number would be more efficient than a 32bit number.

On a 64bit CPU most compilers would give you 64bit if you ask for an long int though.

To see the size with your current compiler:

#include <stdio.h>

int main(int argc, char **argv){
    long int foo;
    printf("The size of an int is: %ld bytes\n", sizeof(foo));
    printf("The size of an int is: %ld bits\n", sizeof(foo) * 8);
    return 0;
}

If your cpu is running in 64bit mode you can expect that the CPU will use that regardless of what you ask. All the registers are 64bit, the operations are 64bit so if you want to get a 32bit result it will generally convert the 64bit result to 32bit for you.

The limits.h on my system defines long int as:

/* Minimum and maximum values a `signed long int' can hold.  */
#  if __WORDSIZE == 64
#   define LONG_MAX 9223372036854775807L
#  else
#   define LONG_MAX 2147483647L
#  endif
#  define LONG_MIN  (-LONG_MAX - 1L)