Question

I have a 64-bit unsigned integer with exactly 1 bit set. I’d like to assign a value to each of the possible 64 values (in this case, the odd primes, so 0x1 corresponds to 3, 0x2 corresponds to 5, …, 0x8000000000000000 corresponds to 313).

It seems like the best way would be to convert 1 → 0, 2 → 1, 4 → 2, 8 → 3, …, 2⁶³ → 63 and look up the values in an array. But even if that’s so, I’m not sure what the fastest way to get at the binary exponent is. And there may be more efficient ways, still.

This operation will be used 10¹⁴ to 10¹⁶ times, so performance is a serious issue.

Answer 1

If performance is a serious issue, then you should use intrinsics/builtins to use CPU specific instructions, such as the ones found here for GCC:

http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Other-Builtins.html

• Built-in function int __builtin_ffs(unsigned int x).

  Returns one plus the index of the least significant 1-bit of x, or if x is zero, returns zero.

• Built-in function int __builtin_clz(unsigned int x).

  Returns the number of leading 0-bits in x, starting at the most significant bit position. If x is 0, the result is undefined.

• Built-in function int __builtin_ctz(unsigned int x).

  Returns the number of trailing 0-bits in x, starting at the least significant bit position. If x is 0, the result is undefined.

Things like this are the core of many O(1) algorithms, such as kernel schedulers which need to find the first non-empty queue signified by an array of bits.

Note: I’ve listed the unsigned int versions, but GCC has unsigned long long versions, as well.