qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-12 09:20:22 -07:00
Code Releases Activity

encoding/base64: slight decoding speed-up

Browse Source 
First, use a dummy slice access on decode64 and decode32 to ensure that
there is a single bounds check for src.

Second, move the PutUint64/PutUint32 calls out of these functions,
meaning that they are simpler and smaller. This may also open the door
to inlineability in the future, but for now, they both go past the
budget.

While at it, get rid of the ilen and olen variables, which have no
impact whatsoever on performance. At least, not measurable by any of the
benchmarks.

name                 old time/op    new time/op    delta
DecodeString/2-4       54.3ns ± 1%    55.2ns ± 2%   +1.60%  (p=0.017 n=5+6)
DecodeString/4-4       66.6ns ± 1%    66.8ns ± 2%     ~     (p=0.903 n=6+6)
DecodeString/8-4       79.3ns ± 2%    79.6ns ± 1%     ~     (p=0.448 n=6+6)
DecodeString/64-4       300ns ± 1%     281ns ± 3%   -6.54%  (p=0.002 n=6+6)
DecodeString/8192-4    27.4µs ± 1%    23.7µs ± 2%  -13.47%  (p=0.002 n=6+6)

name                 old speed      new speed      delta
DecodeString/2-4     73.7MB/s ± 1%  72.5MB/s ± 2%   -1.55%  (p=0.026 n=5+6)
DecodeString/4-4      120MB/s ± 1%   120MB/s ± 2%     ~     (p=0.851 n=6+6)
DecodeString/8-4      151MB/s ± 2%   151MB/s ± 1%     ~     (p=0.485 n=6+6)
DecodeString/64-4     292MB/s ± 1%   313MB/s ± 3%   +7.03%  (p=0.002 n=6+6)
DecodeString/8192-4   399MB/s ± 1%   461MB/s ± 2%  +15.58%  (p=0.002 n=6+6)

For #19636.

Change-Id: I0dfbdafa2a41dc4c582f63aef94b90b8e473731c
Reviewed-on: https://go-review.googlesource.com/113776
Reviewed-by: Ian Lance Taylor <iant@golang.org>
This commit is contained in:
Daniel Martí 2018-05-18 18:31:05 +01:00
parent 1484270aec
commit 811b187a4f
1 changed files with 32 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
src/encoding/base64/base64.go
View File

@ -465,10 +465,9 @@ func (enc *Encoding) Decode(dst, src []byte) (n int, err error) {
}
si := 0
ilen := len(src)
olen := len(dst)
for strconv.IntSize >= 64 && ilen-si >= 8 && olen-n >= 8 {
if ok := enc.decode64(dst[n:], src[si:]); ok {
for strconv.IntSize >= 64 && len(src)-si >= 8 && len(dst)-n >= 8 {
if dn, ok := enc.decode64(src[si:]); ok {
binary.BigEndian.PutUint64(dst[n:], dn)
n += 6
si += 8
} else {
@ -481,8 +480,9 @@ func (enc *Encoding) Decode(dst, src []byte) (n int, err error) {
}
}
for ilen-si >= 4 && olen-n >= 4 {
if ok := enc.decode32(dst[n:], src[si:]); ok {
for len(src)-si >= 4 && len(dst)-n >= 4 {
if dn, ok := enc.decode32(src[si:]); ok {
binary.BigEndian.PutUint32(dst[n:], dn)
n += 3
si += 4
} else {
@ -506,72 +506,70 @@ func (enc *Encoding) Decode(dst, src []byte) (n int, err error) {
return n, err
}
// decode32 tries to decode 4 base64 char into 3 bytes.
// len(dst) and len(src) must both be >= 4.
// Returns true if decode succeeded.
func (enc *Encoding) decode32(dst, src []byte) bool {
var dn, n uint32
// decode32 tries to decode 4 base64 characters into 3 bytes, and returns those
// bytes. len(src) must be >= 4.
// Returns (0, false) if decoding failed.
func (enc *Encoding) decode32(src []byte) (dn uint32, ok bool) {
var n uint32
_ = src[3]
if n = uint32(enc.decodeMap[src[0]]); n == 0xff {
return false
return 0, false
}
dn |= n << 26
if n = uint32(enc.decodeMap[src[1]]); n == 0xff {
return false
return 0, false
}
dn |= n << 20
if n = uint32(enc.decodeMap[src[2]]); n == 0xff {
return false
return 0, false
}
dn |= n << 14
if n = uint32(enc.decodeMap[src[3]]); n == 0xff {
return false
return 0, false
}
dn |= n << 8
binary.BigEndian.PutUint32(dst, dn)
return true
return dn, true
}
// decode64 tries to decode 8 base64 char into 6 bytes.
// len(dst) and len(src) must both be >= 8.
// Returns true if decode succeeded.
func (enc *Encoding) decode64(dst, src []byte) bool {
var dn, n uint64
// decode64 tries to decode 8 base64 characters into 6 bytes, and returns those
// bytes. len(src) must be >= 8.
// Returns (0, false) if decoding failed.
func (enc *Encoding) decode64(src []byte) (dn uint64, ok bool) {
var n uint64
_ = src[7]
if n = uint64(enc.decodeMap[src[0]]); n == 0xff {
return false
return 0, false
}
dn |= n << 58
if n = uint64(enc.decodeMap[src[1]]); n == 0xff {
return false
return 0, false
}
dn |= n << 52
if n = uint64(enc.decodeMap[src[2]]); n == 0xff {
return false
return 0, false
}
dn |= n << 46
if n = uint64(enc.decodeMap[src[3]]); n == 0xff {
return false
return 0, false
}
dn |= n << 40
if n = uint64(enc.decodeMap[src[4]]); n == 0xff {
return false
return 0, false
}
dn |= n << 34
if n = uint64(enc.decodeMap[src[5]]); n == 0xff {
return false
return 0, false
}
dn |= n << 28
if n = uint64(enc.decodeMap[src[6]]); n == 0xff {
return false
return 0, false
}
dn |= n << 22
if n = uint64(enc.decodeMap[src[7]]); n == 0xff {
return false
return 0, false
}
dn |= n << 16
binary.BigEndian.PutUint64(dst, dn)
return true
return dn, true
}
type newlineFilteringReader struct {