What's the best way of counting the number of 1-bits in an integer?

On modern hardware, have your CPU do it for you. On Intel CPUs, the `popcnt`

instruction is what you want. I learned reading *Hacker's Delight* that some architectures
called counting the 1-bits *population count*, which presumably informed the name of
the Intel instruction.

Let's try to count the number of 1-bits in a 64-bit integer on an Intel CPU.

I'm trying to keep this as simple as possible (for me; I'm not an assembly guru), so I'll purposefully keep the number of 1-bits low, so that I can just return the count as the exit value from my little assembler program.

The following went into a file named `popcnt.s`

:

.section .data .globl _start _start: # I'll put my test value in one of the new-ish 64-bit registers. # I would have preferred to just us a literal arg to popcnt, but # apparently the instruction does not support that. Also, # thanks, GNU Assembler, for having binary literals! movq $0b1000000010000000100000001000000010000000100000001000000010000000, %r11 # Count the number of 1-bits in %r11 and put the answer in %rdi popcntq %r11, %rdi # Move the number 60 to %rax in preparation for a syscall. # Syscall number 60 is exit. The exit syscall requires the exit number # to be in %rdi, which we have done, above. movq $60, %rax syscall

Build the little assembly program...

$ as --gstabs popcnt.s -o popcnt.o $ ld popcnt.o -o popcnt

Run the little assembly program and ask for the exit number:

$ ./popcnt $ echo $? 8

And that's how we use `popcnt`

.

In Go 1.13rc1, we can also use a binary literal (thanks, Go Team!)
and we can use `bits.OnesCount64()`

to count the number of
1-bits:

package main import ( "fmt" "math/bits" ) func main() { var n uint64 = 0b10000000_10000000_10000000_10000000_10000000_10000000_10000000_10000000 fmt.Printf("OnesCount64(%064b) = %d\n", n, bits.OnesCount64(n)) }

$ go1.13rc1 build $ ./popcnt OnesCount64(1000000010000000100000001000000010000000100000001000000010000000) = 8

Let's ask Go to show us the assembly code for the program.

$ go1.13rc1 tool compile -S main.go > main.S

When we look in `main.S`

, we do indeed see the `popcnt`

instruction:

0x0049 00073 (main.go:10) POPCNTQ AX, CX

Cool!

Because of CPU instruction support for counting 1-bits, the rest of this discussion
is moot. But the book *Hacker's Delight* really does show a neat way of counting the number
of 1-bits in an integer. There was a clearer example on Stack Overflow that really
made this click for me.

Let's say I have the byte 10110110, and I want to count the number of 1-bits in it.

The approach explained in *Hacker's Delight* is to sum the number of 1-bits
in each pair of bits, and then sum the number of 1-bits in each quad of bits, and
then add both quads together. It's a basic divide-and-conquer algorithm, but seeing
it work in practice makes it way clearer.

As I said, the first step is to count the number of 1-bits in each pair of bits. For our example number, 10110110, that means we want to count the number of bits in each of these pairs:

10 11 01 10

The interesting thing is that we can store the sum of each pair using only
two bits! After all, each pair can have only 0 or 1 or 2 bits, and 0, 1, and 2
in binary are 00, 01, and 10 respectively. So not only can we sum the 1-bits
for each pair, we can overwrite each pair with the sum! *And* we can
sum all 4 pairs in parallel.

First, we need to arrange the bits in those 4 pairs so that we can add them together. Essentailly what we want to do is sum all of the odd bits to all of the event bits. If we find a way to arrange the bits of this number

10 11 01 10

like so,

0 1 1 0 1 1 0 1

then we could just sum them together like so:

0 1 1 0 1 1 0 1 ---------- 01 10 01 01

And if we could only arrange this result like so:

10 01 01 01

then we could sum those together like so:

10 01 01 01 ----- 11 10

And if we could only arrange that result like so:

10 11

then we could sum to get our final answer like so:

10 11 ---- 101which is 5 in decimal, and the number of 1-bits in the number we started with!

Happily, it turns out there is a way to do this. If we want to take our starting value, 10110110, and sum each pair of bits, we can do it like so.

First, isolate all the odd bits by masking them, like so:

10110110 & 01010101 -------- 00010100 <-- odd bits

Second, shift all of the even bits so that we can place them "under" the odd bits for summing...

10110110 >> 1 -------- 01011011

...but don't forget to isolate only the even bits! (Yes, I realize the even bits have now shifted into the odd place, but bear with me.)

01011011 & 01010101 -------- 01010001 <-- even bits

Now we have two sets of bits, even and odd, which are "aligned", so we can now stack one on top of the other and sum them.

00010100 <-- odd bits + 01010001 <-- even bits -------- 01100101 <-- result A

If we stack our original pairs of bits on top of their sums, we will see that each pair of bits in our result is the sum of 1-bits.

10 11 01 10 <-- starting bits 01 10 01 01 <-- result A, from above 1 2 1 1 <-- each pair's sum in decimal

Progress! The next step is to take each pair of sums, and sum those. The number of spaces we need to shift doubles, and the bitmask pattern, used to isolate each sum, changes too.

01100101 <-- result A, from above & 00110011 -------- 00100001 <-- even sums 01100101 <-- result A, from above >> 2 -------- 00011001 <-- shift result 00011001 <-- shift result from right above & 00110011 -------- 00010001 <-- odd sums 00100001 <-- even sums + 00010001 <-- odd sums -------- 00110010 <-- result B

If we were successful, we added two pairs of sums together:

binary | decimal 10 01 | 2 1 <-- even sums + 01 01 | 1 1 <-- odd sums --------- | --- 0011 0010 | 3 2 1011 0110 <-- starting bits

Looks good! Now all we have to do is add our final two sums together. Once more, we double our shift amount, and change the bit mask pattern.

00110010 <-- result B from above & 00001111 -------- 00000010 <-- right sum 00110010 <-- result B from above >> 4 -------- 00000011 <-- left sum shifted 00000011 <-- left sum shifted from right above & 00001111 -------- 00000011 <-- left sum 00000010 <-- right sum + 00000011 <-- left sum -------- 00000101 <-- final sum, 5 in decimal

And there we are! The starting bits were 10110110, and there are indeed 5 1-bits.

In go 1.13 code, the above would look like this:

package main import ( "fmt" ) func main() { var startBits uint8 = 0b10110110 x := startBits x = (x & 0b01010101) + ((x >> 1) & 0b01010101) x = (x & 0b00110011) + ((x >> 2) & 0b00110011) x = (x & 0b00001111) + ((x >> 4) & 0b00001111) fmt.Printf("Number of 1-bits in %08b: %d\n", startBits, x) }

$ go1.13rc1 build $ ./popcnt Number of 1-bits in 10110110: 5

In the Go example, I only count the 1-bits in a byte. For the more common
use-cases of 32-bit or 64-bit numbers, you can extend out the pattern above.
Also, the above code can be simplified (and therefore sped up) even more,
which books like *Hacker's Delight* will show you how to do.
Of course, I'll return to the advice from the top;
modern CPUs have an instruction to do this, so always favor that.