qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-18 17:14:45 -07:00
Code Releases Activity

math/bits: faster OnesCount, added respective benchmarks

Browse Source 
Also: Changed Reverse/ReverseBytes implementations to use
the same (smaller) masks as OnesCount.

BenchmarkOnesCount-8          37.0          6.26          -83.08%
BenchmarkOnesCount8-8         7.24          1.99          -72.51%
BenchmarkOnesCount16-8        11.3          2.47          -78.14%
BenchmarkOnesCount32-8        18.4          3.02          -83.59%
BenchmarkOnesCount64-8        40.0          3.78          -90.55%
BenchmarkReverse-8            6.69          6.22          -7.03%
BenchmarkReverse8-8           1.64          1.64          +0.00%
BenchmarkReverse16-8          2.26          2.18          -3.54%
BenchmarkReverse32-8          2.88          2.87          -0.35%
BenchmarkReverse64-8          5.64          4.34          -23.05%
BenchmarkReverseBytes-8       2.48          2.17          -12.50%
BenchmarkReverseBytes16-8     0.63          0.95          +50.79%
BenchmarkReverseBytes32-8     1.13          1.24          +9.73%
BenchmarkReverseBytes64-8     2.50          2.16          -13.60%

OnesCount-8       37.0ns ± 0%   6.3ns ± 0%   ~             (p=1.000 n=1+1)
OnesCount8-8      7.24ns ± 0%  1.99ns ± 0%   ~             (p=1.000 n=1+1)
OnesCount16-8     11.3ns ± 0%   2.5ns ± 0%   ~             (p=1.000 n=1+1)
OnesCount32-8     18.4ns ± 0%   3.0ns ± 0%   ~             (p=1.000 n=1+1)
OnesCount64-8     40.0ns ± 0%   3.8ns ± 0%   ~             (p=1.000 n=1+1)
Reverse-8         6.69ns ± 0%  6.22ns ± 0%   ~             (p=1.000 n=1+1)
Reverse8-8        1.64ns ± 0%  1.64ns ± 0%   ~     (all samples are equal)
Reverse16-8       2.26ns ± 0%  2.18ns ± 0%   ~             (p=1.000 n=1+1)
Reverse32-8       2.88ns ± 0%  2.87ns ± 0%   ~             (p=1.000 n=1+1)
Reverse64-8       5.64ns ± 0%  4.34ns ± 0%   ~             (p=1.000 n=1+1)
ReverseBytes-8    2.48ns ± 0%  2.17ns ± 0%   ~             (p=1.000 n=1+1)
ReverseBytes16-8  0.63ns ± 0%  0.95ns ± 0%   ~             (p=1.000 n=1+1)
ReverseBytes32-8  1.13ns ± 0%  1.24ns ± 0%   ~             (p=1.000 n=1+1)
ReverseBytes64-8  2.50ns ± 0%  2.16ns ± 0%   ~             (p=1.000 n=1+1)

Change-Id: I591b0ffc83fc3a42828256b6e5030f32c64f9497
Reviewed-on: https://go-review.googlesource.com/37218
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
This commit is contained in:
Robert Griesemer 2017-02-17 14:20:11 -08:00
parent 21c71d7788
commit a12edb8db6
3 changed files with 119 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
src/math/bits/bits.go
View File

@ -45,20 +45,58 @@ func TrailingZeros64(x uint64) int { return ntz64(x) }
// --- OnesCount ---
const m0 = 0x5555555555555555 // 01010101 ...
const m1 = 0x3333333333333333 // 00110011 ...
const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ...
const m3 = 0x00ff00ff00ff00ff // etc.
const m4 = 0x0000ffff0000ffff
const m5 = 0x00000000ffffffff
// OnesCount returns the number of one bits ("population count") in x.
func OnesCount(x uint) int { return pop(uint64(x)) }
func OnesCount(x uint) int {
if UintSize == 32 {
return OnesCount32(uint32(x))
}
return OnesCount64(uint64(x))
}
// OnesCount8 returns the number of one bits ("population count") in x.
func OnesCount8(x uint8) int { return pop(uint64(x)) }
func OnesCount8(x uint8) int {
const m = 1<<8 - 1
x = x>>1&(m0&m) + x&(m0&m)
x = x>>2&(m1&m) + x&(m1&m)
return int(x>>4 + x&(m2&m))
}
// OnesCount16 returns the number of one bits ("population count") in x.
func OnesCount16(x uint16) int { return pop(uint64(x)) }
func OnesCount16(x uint16) int {
const m = 1<<16 - 1
x = x>>1&(m0&m) + x&(m0&m)
x = x>>2&(m1&m) + x&(m1&m)
x = x>>4&(m2&m) + x&(m2&m)
return int(x>>8 + x&(m3&m))
}
// OnesCount32 returns the number of one bits ("population count") in x.
func OnesCount32(x uint32) int { return pop(uint64(x)) }
func OnesCount32(x uint32) int {
const m = 1<<32 - 1
x = x>>1&(m0&m) + x&(m0&m)
x = x>>2&(m1&m) + x&(m1&m)
x = x>>4&(m2&m) + x&(m2&m)
x = x>>8&(m3&m) + x&(m3&m)
return int(x>>16 + x&(m4&m))
}
// OnesCount64 returns the number of one bits ("population count") in x.
func OnesCount64(x uint64) int { return pop(uint64(x)) }
func OnesCount64(x uint64) int {
const m = 1<<64 - 1
x = x>>1&(m0&m) + x&(m0&m)
x = x>>2&(m1&m) + x&(m1&m)
x = x>>4&(m2&m) + x&(m2&m)
x = x>>8&(m3&m) + x&(m3&m)
x = x>>16&(m4&m) + x&(m4&m)
return int(x>>32 + x&(m5&m))
}
// --- RotateLeft ---
@ -96,12 +134,6 @@ func RotateRight64(x uint64, k int) uint64 { return uint64(rot(uint64(x), 64, 64
// --- Reverse ---
const m0 = 0xaaaaaaaaaaaaaaaa // 10101010 ...
const m1 = 0xcccccccccccccccc // 11001100 ...
const m2 = 0xf0f0f0f0f0f0f0f0 // 11110000 ...
const m3 = 0xff00ff00ff00ff00 // etc.
const m4 = 0xffff0000ffff0000
// Reverse returns the value of x with its bits in reversed order.
func Reverse(x uint) uint {
if UintSize == 32 {
@ -113,38 +145,38 @@ func Reverse(x uint) uint {
// Reverse8 returns the value of x with its bits in reversed order.
func Reverse8(x uint8) uint8 {
const m = 1<<8 - 1
x = x&(m0&m)>>1 | x<<1&(m0&m)
x = x&(m1&m)>>2 | x<<2&(m1&m)
x = x>>1&(m0&m) | x&(m0&m)<<1
x = x>>2&(m1&m) | x&(m1&m)<<2
return x>>4 | x<<4
}
// Reverse16 returns the value of x with its bits in reversed order.
func Reverse16(x uint16) uint16 {
const m = 1<<16 - 1
x = x&(m0&m)>>1 | x<<1&(m0&m)
x = x&(m1&m)>>2 | x<<2&(m1&m)
x = x&(m2&m)>>4 | x<<4&(m2&m)
x = x>>1&(m0&m) | x&(m0&m)<<1
x = x>>2&(m1&m) | x&(m1&m)<<2
x = x>>4&(m2&m) | x&(m2&m)<<4
return x>>8 | x<<8
}
// Reverse32 returns the value of x with its bits in reversed order.
func Reverse32(x uint32) uint32 {
const m = 1<<32 - 1
x = x&(m0&m)>>1 | x<<1&(m0&m)
x = x&(m1&m)>>2 | x<<2&(m1&m)
x = x&(m2&m)>>4 | x<<4&(m2&m)
x = x&(m3&m)>>8 | x<<8&(m3&m)
x = x>>1&(m0&m) | x&(m0&m)<<1
x = x>>2&(m1&m) | x&(m1&m)<<2
x = x>>4&(m2&m) | x&(m2&m)<<4
x = x>>8&(m3&m) | x&(m3&m)<<8
return x>>16 | x<<16
}
// Reverse64 returns the value of x with its bits in reversed order.
func Reverse64(x uint64) uint64 {
const m = 1<<64 - 1
x = x&(m0&m)>>1 | x<<1&(m0&m)
x = x&(m1&m)>>2 | x<<2&(m1&m)
x = x&(m2&m)>>4 | x<<4&(m2&m)
x = x&(m3&m)>>8 | x<<8&(m3&m)
x = x&(m4&m)>>16 | x<<16&(m4&m)
x = x>>1&(m0&m) | x&(m0&m)<<1
x = x>>2&(m1&m) | x&(m1&m)<<2
x = x>>4&(m2&m) | x&(m2&m)<<4
x = x>>8&(m3&m) | x&(m3&m)<<8
x = x>>16&(m4&m) | x&(m4&m)<<16
return x>>32 | x<<32
}
@ -166,15 +198,15 @@ func ReverseBytes16(x uint16) uint16 {
// ReverseBytes32 returns the value of x with its bytes in reversed order.
func ReverseBytes32(x uint32) uint32 {
const m = 1<<32 - 1
x = x&(m3&m)>>8 | x<<8&(m3&m)
x = x>>8&(m3&m) | x&(m3&m)<<8
return x>>16 | x<<16
}
// ReverseBytes64 returns the value of x with its bytes in reversed order.
func ReverseBytes64(x uint64) uint64 {
const m = 1<<64 - 1
x = x&(m3&m)>>8 | x<<8&(m3&m)
x = x&(m4&m)>>16 | x<<16&(m4&m)
x = x>>8&(m3&m) | x&(m3&m)<<8
x = x>>16&(m4&m) | x&(m4&m)<<16
return x>>32 | x<<32
}

8
src/math/bits/bits_impl.go
View File

@ -74,14 +74,6 @@ func ntz64(x uint64) int {
return int(deBruijn64tab[(x&-x)*deBruijn64>>(64-6)])
}
func pop(x uint64) (n int) {
for x != 0 {
n++
x &= x - 1
}
return
}
func pos(k int) uint {
if k < 0 {
panic("negative rotation count")

73
src/math/bits/bits_test.go
View File

@ -189,6 +189,56 @@ func TestOnesCount(t *testing.T) {
}
}
// Exported (global) variable to store function results
// during benchmarking to ensure side-effect free calls
// are not optimized away.
var Unused int
// Exported (global) variable serving as input for some
// of the benchmarks to ensure side-effect free calls
// are not optimized away.
var Input uint64 = deBruijn64
func BenchmarkOnesCount(b *testing.B) {
var s int
for i := 0; i < b.N; i++ {
s += OnesCount(uint(Input))
}
Unused = s
}
func BenchmarkOnesCount8(b *testing.B) {
var s int
for i := 0; i < b.N; i++ {
s += OnesCount8(uint8(Input))
}
Unused = s
}
func BenchmarkOnesCount16(b *testing.B) {
var s int
for i := 0; i < b.N; i++ {
s += OnesCount16(uint16(Input))
}
Unused = s
}
func BenchmarkOnesCount32(b *testing.B) {
var s int
for i := 0; i < b.N; i++ {
s += OnesCount32(uint32(Input))
}
Unused = s
}
func BenchmarkOnesCount64(b *testing.B) {
var s int
for i := 0; i < b.N; i++ {
s += OnesCount64(uint64(Input))
}
Unused = s
}
func TestRotateLeft(t *testing.T) {
var m uint64 = deBruijn64
@ -367,17 +417,12 @@ func testReverse(t *testing.T, x64, want64 uint64) {
}
}
// Exported (global) variable to store function results
// during benchmarking, to ensure side-effect free calls
// are not optimized away.
var Unused uint64
func BenchmarkReverse(b *testing.B) {
var s uint
for i := 0; i < b.N; i++ {
s += Reverse(uint(i))
}
Unused = uint64(s)
Unused = int(s)
}
func BenchmarkReverse8(b *testing.B) {
@ -385,7 +430,7 @@ func BenchmarkReverse8(b *testing.B) {
for i := 0; i < b.N; i++ {
s += Reverse8(uint8(i))
}
Unused = uint64(s)
Unused = int(s)
}
func BenchmarkReverse16(b *testing.B) {
@ -393,7 +438,7 @@ func BenchmarkReverse16(b *testing.B) {
for i := 0; i < b.N; i++ {
s += Reverse16(uint16(i))
}
Unused = uint64(s)
Unused = int(s)
}
func BenchmarkReverse32(b *testing.B) {
@ -401,7 +446,7 @@ func BenchmarkReverse32(b *testing.B) {
for i := 0; i < b.N; i++ {
s += Reverse32(uint32(i))
}
Unused = uint64(s)
Unused = int(s)
}
func BenchmarkReverse64(b *testing.B) {
@ -409,7 +454,7 @@ func BenchmarkReverse64(b *testing.B) {
for i := 0; i < b.N; i++ {
s += Reverse64(uint64(i))
}
Unused = s
Unused = int(s)
}
func TestReverseBytes(t *testing.T) {
@ -473,7 +518,7 @@ func BenchmarkReverseBytes(b *testing.B) {
for i := 0; i < b.N; i++ {
s += ReverseBytes(uint(i))
}
Unused = uint64(s)
Unused = int(s)
}
func BenchmarkReverseBytes16(b *testing.B) {
@ -481,7 +526,7 @@ func BenchmarkReverseBytes16(b *testing.B) {
for i := 0; i < b.N; i++ {
s += ReverseBytes16(uint16(i))
}
Unused = uint64(s)
Unused = int(s)
}
func BenchmarkReverseBytes32(b *testing.B) {
@ -489,7 +534,7 @@ func BenchmarkReverseBytes32(b *testing.B) {
for i := 0; i < b.N; i++ {
s += ReverseBytes32(uint32(i))
}
Unused = uint64(s)
Unused = int(s)
}
func BenchmarkReverseBytes64(b *testing.B) {
@ -497,7 +542,7 @@ func BenchmarkReverseBytes64(b *testing.B) {
for i := 0; i < b.N; i++ {
s += ReverseBytes64(uint64(i))
}
Unused = s
Unused = int(s)
}
func TestLen(t *testing.T) {