Why are bitwise operators slower than division and modulo in Go? - go

Question

Usually I program in C and frequently use bitwise operators since they are faster. Now I encountered this timing difference by solving Project Euler Problem 14 while using bitwise operators or division and modulo. The program was compiled with go version go1.6.2.
Version with bitwise operators:
package main
import (
"fmt"
)
func main() {
var buf, longest, cnt, longest_start int
for i:=2; i<1e6; i++ {
buf = i
cnt = 0
for buf > 1 {
if (buf & 0x01) == 0 {
buf >>= 1
} else {
buf = buf * 3 + 1
}
cnt++
}
if cnt > longest {
longest = cnt
longest_start = i
}
}
fmt.Println(longest_start)
}
executing the program:
time ./prob14
837799
real 0m0.300s
user 0m0.301s
sys 0m0.000s
Version without bitwise operators (replacing & 0x01 with % 2 and >>= 1 with /=2):
for buf > 1 {
if (buf % 2) == 0 {
buf /= 2
} else {
buf = buf * 3 + 1
}
cnt++
}
executing the program:
$ time ./prob14
837799
real 0m0.273s
user 0m0.274s
sys 0m0.000s
Why is the version with the bitwise operators in Go slower?
(I also created a solution for the problem in C. Here was the version with the bitwise operators faster without optimization flag (with -O3 they are equal).)
EDIT
I did a benchmark as suggested in the comments.
package main
import (
"testing"
)
func Colatz(num int) {
cnt := 0
buf := num
for buf > 1 {
if (buf % 2) == 0 {
buf /= 2
} else {
buf = buf * 3 + 1
}
cnt++
}
}
func ColatzBitwise(num int) {
cnt := 0
buf := num
for buf > 1 {
if (buf & 0x01) == 0 {
buf >>= 1
} else {
buf = buf * 3 + 1
}
cnt++
}
}
func BenchmarkColatz(b *testing.B) {
for i:=0; i<b.N; i++ {
Colatz(837799)
}
}
func BenchmarkColatzBitwise(b *testing.B) {
for i:=0; i<b.N; i++ {
ColatzBitwise(837799)
}
}
Here are the benchmark results:
go test -bench=.
PASS
BenchmarkColatz-8 2000000 650 ns/op
BenchmarkColatzBitwise-8 2000000 609 ns/op
It turns out the bitwise version is faster in the benchmark.
EDIT 2
I changed the type of all variables in the functions to uint. Here is the benchmark:
go test -bench=.
PASS
BenchmarkColatz-8 3000000 516 ns/op
BenchmarkColatzBitwise-8 3000000 590 ns/op
The arithmetic version is now faster, as Marc has written in his answer. I will test also with a newer compiler version.

Answer 1

If they ever were, they aren't now.
There are a few problems with your approach:
you're using go1.6.2 which was released over 4 years ago
you're running a binary that does other things and running it just once
you're expecting bitshift and arithmetic operations on signed integers to be the same, they're not
Using go1.15 with micro benchmarks will show the bitwise operations to be faster. The main reason for this is that a bitwise shift and a division by two are absolutely not the same for signed integers: the bitwise shift doesn't care about the sign but the division has to preserve it.
If you want to have something closer to equivalent, use unsigned integers for your arithmetic operations, the compiler may optimize it to a single bitshift.
In go1.15 on my machine, I see the following being generated for each type of division by 2:
buf >>=1:
MOVQ AX, DX
SARQ $1, AX
buf /= 2 with var buf int:
MOVQ AX, DX
SHRQ $63, AX
ADDQ DX, AX
SARQ $1, AX
buf /= 2 with var buf uint:
MOVQ CX, BX
SHRQ $1, CX
Even then, all this must be taken with a large grain of salt: the generated code will depend massively on what else is happening and how the results are used.
But the basic rule applies: when performing arithmetic operations, the type matters a lot. Bitshift operators don't care about sign.