debruijn | de Bruijn graph construction tool | Genomics library

I agree with harold that std::countl_zero() is the way to go. Memory has gotten a lot slower relative to compute since this bit-twiddling hack was designed, and processors typically have built-in instructions.

To answer your question, however, this hack combines a couple primitives. (When I talk about bit indexes, I'm counting from most to least significant, starting the count at zero.)

1. The sequence of lines starting with v |= v >> 1; achieves its stated goal of rounding up to the nearest power of two minus one (i.e., a number whose binary representation matches 0*1*) by setting every bit to the right of at least one set bit.

   • None of these lines clears bits in v.
   • Since there are right shifts only, every bit set by these lines is to the right of at least one set bit.
   • Given a set bit at position i, we observe that a bit at position i + delta will be guaranteed set by the lines matching delta's binary representation, e.g., delta = 13 (1101 in binary) is handled by v |= v >> 1; v |= v >> 4; v |= v >> 8;.

2. Extracting bits [L, L+delta) from an unsigned integer n with WIDTH bits can be accomplished with (n << L) >> (WIDTH - delta). The left shift truncates the upper bits that should be discarded, and the right shift, which is logical in C++ for unsigned, truncates the lower bits and fills the truncated upper bits with zeros.

3. Given that the answer is k, we want to extract 5 (= log2(32), for 32-bit) or 6 (= log2(64), for 64-bit) bits starting with index k from the magic constant n. We can't shift by k because we only know pow2(k) (sort of, I'll get to that in a second), but we can use the equivalence between multiplying by pow2(k) and left shifting by k as a workaround.

4. Actually we only know pow2(k+1) - 1. We're going to be greedy and shave the two ops that we'd need to get pow2(k). By putting 5 or 6 ones after the initial zeros, we force that minus one to always cause the answer to be one less than it should have been (mod 32 or 64).

5. So the de Bruijn sequence: the idea is that we can uniquely identify our index in the sequence by reading the next 5 or 6 bits. We aren't so lucky as to be able to have these bits be equal to the index, which is where the look-up table comes in.

As an example, I'll adapt this algorithm to 8-bit words. We start with