[go-nuts] Slow 64 bit integer division on amd64

This is to be expected.
doing 64-bit division will (must) be slower than 32-bit division,
because AFAIK, all division circuits use some sort of iteration
algorithm (that is, don't expect a single cycle division circuit
to be built with adequate clock frequency as the other single
cycle arithmetic circuits).

--

On Sat, Jan 19, 2013 at 10:13 PM, Dominik Honnef wrote:

Cannot reproduce here (Xeon on dont-know-how-much GHz)

jnml@fsc-r630:~/src/tmp/20130119$ cat a_test.go
package main

import (
"testing"
)

func BenchmarkBase(b *testing.B) {
var x int32
for i := 1; i < b.N; i++ {
}
_ = x
}

func BenchmarkInt(b *testing.B) {
var x int
for i := 1; i < b.N; i++ {
x /= 42
}
_ = x
}

func BenchmarkInt32(b *testing.B) {
var x int32
for i := 1; i < b.N; i++ {
x /= 42
}
_ = x
}

func BenchmarkInt64(b *testing.B) {
var x int64
for i := 1; i < b.N; i++ {
x /= 42
}
_ = x
}
jnml@fsc-r630:~/src/tmp/20130119$ go test -bench .
testing: warning: no tests to run
PASS
BenchmarkBase 2000000000 0.88 ns/op
BenchmarkInt 100000000 10.3 ns/op
BenchmarkInt32 500000000 4.85 ns/op
BenchmarkInt64 100000000 10.2 ns/op
ok tmp/20130119 6.870s
jnml@fsc-r630:~/src/tmp/20130119$ go version
go version devel +422c00e8e022 Sun Nov 11 07:51:20 2012 +1100
jnml@fsc-r630:~/src/tmp/20130119$

-j

--

division by a constant should be turned into multiplication by magic
constants
by the Go compiler just to avoid the costly divide instruction.

you can verify that by 'go tool 6g -S'.

--

Integer division is slow.

It is the unloved arithmetic operation in CPU design because of its low
frequency of occurrence in the instruction stream. It is the one--if you
remember childhood schooling--that was "not like the others" in its
mechanism: there was lots of guessing using leading digits, trial divisors,
and so on. This awkwardness exists even in base 2 (though much less) and
means that any division circuit my have to do at least one "fixup" step. (A
good design does either zero or one fixup, but that one means more work and
plausibly an extra cycle on what is already a long cycle-count activity.)

As one specific example, when adding and subtracting were 1 cycle and
multiply was 4, a 32-bit integer division required 19 cycles.