mirror
/
go
mirror of https://github.com/golang/go.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
48,375 Commits 63 Branches 451 Tags 660 MiB
Commit Graph

142 Commits

Author SHA1 Message Date
Ian Lance Taylor 8ac6544564 bytes: correct tense in comment 
Undo incorrect change accidentally made in CL 299109.

Change-Id: Iba29827d0fbd3637c311cebc50c2f4ea437fc582
Reviewed-on: https://go-review.googlesource.com/c/go/+/301830
Trust: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
 2021-03-15 17:37:09 +00:00
John Bampton 289d34a465 all: remove duplicate words 
Change-Id: Ib0469232a2b69a869e58d5d24990ad74ac96ea56
GitHub-Last-Rev: eb38e049ee
GitHub-Pull-Request: golang/go#44805
Reviewed-on: https://go-review.googlesource.com/c/go/+/299109
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
 2021-03-13 11:56:59 +00:00
David Benjamin 43652dc46f bufio, bytes, strings: handle negative runes in WriteRune 
Updates #43254

Change-Id: I7d4bf3b99cc36ca2156af5bb01a1c595419d1d3c
Reviewed-on: https://go-review.googlesource.com/c/go/+/280492
Reviewed-by: Emmanuel Odeke <emmanuel@orijtech.com>
Reviewed-by: Rob Pike <r@golang.org>
Trust: Emmanuel Odeke <emmanuel@orijtech.com>
Run-TryBot: Emmanuel Odeke <emmanuel@orijtech.com>
TryBot-Result: Go Bot <gobot@golang.org>
 2021-02-24 04:01:25 +00:00
Russ Cox d4b2638234 all: go fmt std cmd (but revert vendor) 
Make all our package sources use Go 1.17 gofmt format
(adding //go:build lines).

Part of //go:build change (#41184).
See https://golang.org/design/draft-gobuild

Change-Id: Ia0534360e4957e58cd9a18429c39d0e32a6addb4
Reviewed-on: https://go-review.googlesource.com/c/go/+/294430
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Jason A. Donenfeld <Jason@zx2c4.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2021-02-20 03:54:50 +00:00
Federico Guerinoni 141fa337ad bytes: add example for (*Buffer).Bytes 
Change-Id: I49ac604530fff7928fa15de07563418b104da5e4
Reviewed-on: https://go-review.googlesource.com/c/go/+/268260
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Giovanni Bajo <rasky@develer.com>
 2020-11-11 20:51:00 +00:00
Russ Cox 1b09d43067 all: update references to symbols moved from io/ioutil to io 
The old ioutil references are still valid, but update our code
to reflect best practices and get used to the new locations.

Code compiled with the bootstrap toolchain
(cmd/asm, cmd/dist, cmd/compile, debug/elf)
must remain Go 1.4-compatible and is excluded.
Also excluded vendored code.

For #41190.

Change-Id: I6d86f2bf7bc37a9d904b6cee3fe0c7af6d94d5b1
Reviewed-on: https://go-review.googlesource.com/c/go/+/263142
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emm.odeke@gmail.com>
 2020-10-20 18:41:18 +00:00
Michael Munday 11cdbab9d4 bytes, internal/bytealg: fix incorrect IndexString usage 
The IndexString implementation in the bytealg package requires that
the string passed into it be in the range '2 <= len(s) <= MaxLen'
where MaxLen may be any value (including 0).

CL 156998 added calls to bytealg.IndexString where MaxLen was not
first checked. This led to an illegal instruction on s390x with
the vector facility disabled.

This CL guards the calls to bytealg.IndexString with a MaxLen check.
If the check fails then the code now falls back to the pre CL 156998
implementation (a loop over the runes in the string).

Since the MaxLen check is now in place the generic implementation is
no longer called so I have returned it to its original unimplemented
state.

In future we may want to drop MaxLen to prevent this kind of
confusion.

Fixes #41552.

Change-Id: Ibeb3f08720444a05c08d719ed97f6cef2423bbe9
Reviewed-on: https://go-review.googlesource.com/c/go/+/256717
Run-TryBot: Michael Munday <mike.munday@ibm.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Michael Munday <mike.munday@ibm.com>
Reviewed-by: Keith Randall <khr@golang.org>
 2020-09-23 19:55:33 +00:00
Robert Griesemer 45d288718d bytes: simpler and faster FieldsFunc (apply same changes as for strings) 
This change applies the recent changes to the strings package
(https://golang.org/cl/229765) to this package, with relevant
local adjustments.

In contrast to the changes in strings, for the bytes package
this change leads to a nice performance improvement of >10%.

Benchmarks run on a "quiet" MacBook Pro, 3.3GHz Dual-Core Intel Core i7,
with 16GB 2133MHz LPDDR3 RAM running macOS 10.15.4.

name                        old time/op    new time/op     delta
FieldsFunc/ASCII/16-4          191ns ± 9%      163ns ± 2%  -14.66%  (p=0.008 n=5+5)
FieldsFunc/ASCII/256-4        2.08µs ± 5%     1.80µs ± 8%  -13.51%  (p=0.008 n=5+5)
FieldsFunc/ASCII/4096-4       36.1µs ± 2%     31.7µs ± 7%  -12.34%  (p=0.008 n=5+5)
FieldsFunc/ASCII/65536-4       584µs ± 3%      517µs ± 3%  -11.52%  (p=0.008 n=5+5)
FieldsFunc/ASCII/1048576-4    9.45ms ± 3%     8.11ms ± 8%  -14.19%  (p=0.008 n=5+5)
FieldsFunc/Mixed/16-4          202ns ± 2%      181ns ± 2%  -10.02%  (p=0.008 n=5+5)
FieldsFunc/Mixed/256-4        2.12µs ± 6%     1.78µs ± 3%  -16.16%  (p=0.008 n=5+5)
FieldsFunc/Mixed/4096-4       40.4µs ± 2%     36.1µs ± 1%  -10.66%  (p=0.008 n=5+5)
FieldsFunc/Mixed/65536-4       700µs ± 5%      612µs ± 1%  -12.59%  (p=0.008 n=5+5)
FieldsFunc/Mixed/1048576-4    11.2ms ± 8%     10.3ms ± 4%   -8.15%  (p=0.008 n=5+5)

name                        old speed      new speed       delta
FieldsFunc/ASCII/16-4       84.0MB/s ± 9%   98.3MB/s ± 2%  +17.04%  (p=0.008 n=5+5)
FieldsFunc/ASCII/256-4       123MB/s ± 5%    143MB/s ± 8%  +15.74%  (p=0.008 n=5+5)
FieldsFunc/ASCII/4096-4      113MB/s ± 2%    130MB/s ± 6%  +14.20%  (p=0.008 n=5+5)
FieldsFunc/ASCII/65536-4     112MB/s ± 2%    127MB/s ± 3%  +13.05%  (p=0.008 n=5+5)
FieldsFunc/ASCII/1048576-4   111MB/s ± 3%    130MB/s ± 8%  +16.66%  (p=0.008 n=5+5)
FieldsFunc/Mixed/16-4       79.3MB/s ± 2%   88.2MB/s ± 2%  +11.15%  (p=0.008 n=5+5)
FieldsFunc/Mixed/256-4       121MB/s ± 5%    144MB/s ± 3%  +19.19%  (p=0.008 n=5+5)
FieldsFunc/Mixed/4096-4      101MB/s ± 2%    113MB/s ± 1%  +11.92%  (p=0.008 n=5+5)
FieldsFunc/Mixed/65536-4    93.7MB/s ± 5%  107.1MB/s ± 1%  +14.31%  (p=0.008 n=5+5)
FieldsFunc/Mixed/1048576-4  93.6MB/s ± 8%  101.8MB/s ± 4%   +8.77%  (p=0.008 n=5+5)

name                        old alloc/op   new alloc/op    delta
FieldsFunc/ASCII/16-4          80.0B ± 0%      80.0B ± 0%     ~     (all equal)
FieldsFunc/ASCII/256-4          768B ± 0%       768B ± 0%     ~     (all equal)
FieldsFunc/ASCII/4096-4       24.8kB ± 0%     24.8kB ± 0%     ~     (all equal)
FieldsFunc/ASCII/65536-4       497kB ± 0%      497kB ± 0%     ~     (p=0.444 n=5+5)
FieldsFunc/ASCII/1048576-4    9.61MB ± 0%     9.61MB ± 0%     ~     (p=0.500 n=5+5)
FieldsFunc/Mixed/16-4          96.0B ± 0%      96.0B ± 0%     ~     (all equal)
FieldsFunc/Mixed/256-4          768B ± 0%       768B ± 0%     ~     (all equal)
FieldsFunc/Mixed/4096-4       24.8kB ± 0%     24.8kB ± 0%     ~     (all equal)
FieldsFunc/Mixed/65536-4       497kB ± 0%      497kB ± 0%     ~     (all equal)
FieldsFunc/Mixed/1048576-4    9.61MB ± 0%     9.61MB ± 0%     ~     (p=0.881 n=5+5)

name                        old allocs/op  new allocs/op   delta
FieldsFunc/ASCII/16-4           1.00 ± 0%       1.00 ± 0%     ~     (all equal)
FieldsFunc/ASCII/256-4          1.00 ± 0%       1.00 ± 0%     ~     (all equal)
FieldsFunc/ASCII/4096-4         5.00 ± 0%       5.00 ± 0%     ~     (all equal)
FieldsFunc/ASCII/65536-4        12.0 ± 0%       12.0 ± 0%     ~     (all equal)
FieldsFunc/ASCII/1048576-4      24.0 ± 0%       24.0 ± 0%     ~     (all equal)
FieldsFunc/Mixed/16-4           1.00 ± 0%       1.00 ± 0%     ~     (all equal)
FieldsFunc/Mixed/256-4          1.00 ± 0%       1.00 ± 0%     ~     (all equal)
FieldsFunc/Mixed/4096-4         5.00 ± 0%       5.00 ± 0%     ~     (all equal)
FieldsFunc/Mixed/65536-4        12.0 ± 0%       12.0 ± 0%     ~     (all equal)
FieldsFunc/Mixed/1048576-4      24.0 ± 0%       24.0 ± 0%     ~     (all equal)

Change-Id: I59a2ed52563851c693b2c8dfce7e3cde640f62a9
Reviewed-on: https://go-review.googlesource.com/c/go/+/231120
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2020-05-01 03:49:21 +00:00
Martin Möhrmann f2163c4d45 bytes, strings: align requirements for functions passed to FieldFuncs 
golang.org/cl/229763 removed the documentation of requirements of
the function passed to FieldsFunc. The current implementation does
not require functions to return consistent results but this had not
been the case for previous implementations.

Add the requirement for consistent results back to the documentation
to allow for future implementations to be more allocation efficient
for an output with more than 32 fields. This is possible with a two
pass algorithm first determining the number of fields used to allocate
the output slice and then splitting the input into fields.

While at it align the documentation of bytes.FieldsFunc with
strings.FieldFunc.

Fixes #38630

Change-Id: Iabbf9ca3dff0daa41f4ec930a21a3dd98e19f122
Reviewed-on: https://go-review.googlesource.com/c/go/+/230797
Run-TryBot: Martin Möhrmann <moehrmann@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
 2020-04-29 19:58:47 +00:00
Andy Pan 1250a324b4 bytes: narrow the search of IndexByte in Index 
Change-Id: I5a47b18b64e7f781dcc77440b06de36966e3d01d
GitHub-Last-Rev: 8576f1931d
GitHub-Pull-Request: golang/go#37993
Reviewed-on: https://go-review.googlesource.com/c/go/+/224589
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2020-03-23 03:44:45 +00:00
erifan01 3af92acb9f strings, bytes: improve IndexAny and LastIndexAny performance 
For the case of a pattern containing multi-byte rune, the time complexity of the
previous algorithm is O(nm), and if both input arguments are long, the search
performance will be poor. This CL improves the searching performance for these
cases by using IndexRune, which is mainly implemented with IndexByte and Index.
As IndexByte and Index are specially optimized with some powerful instructions
for short patterns (an UTF8 rune is 1 to 4 bytes), so they can help to reduce the
runtime complexity of IndexAny and LastIndexAny.

Another optimization method is using hash table, however, the actual test results
show that using indexrune is better, and the space complexity is lower.

There are two fast paths in IndexAny and LastIndexAny for cases where the length
of the input arguements are 1, and their locations are not exactly the same, which
is determined based on the actual test results.

Benchmarks on arm64 and amd64:

name                        old time/op  new time/op  delta
pkg:strings goos:linux goarch:arm64
IndexAnyASCII/1:1-8         23.7ns ± 3%  28.5ns ± 0%  +20.15%  (p=0.008 n=5+5)
IndexAnyASCII/1:2-8         18.0ns ± 0%  33.1ns ± 0%  +83.67%  (p=0.008 n=5+5)
IndexAnyASCII/1:4-8         20.0ns ± 0%  36.0ns ± 0%  +80.00%  (p=0.029 n=4+4)
IndexAnyASCII/1:8-8         36.1ns ± 0%  36.0ns ± 0%     ~     (p=0.095 n=5+4)
IndexAnyASCII/1:16-8        48.1ns ± 0%  36.0ns ± 0%  -25.19%  (p=0.029 n=4+4)
IndexAnyASCII/1:32-8        72.1ns ± 0%  36.0ns ± 0%  -50.01%  (p=0.008 n=5+5)
IndexAnyASCII/1:64-8         120ns ± 0%    39ns ± 0%  -67.83%  (p=0.008 n=5+5)
IndexAnyASCII/16:1-8        73.0ns ± 0%  28.5ns ± 0%  -60.95%  (p=0.008 n=5+5)
IndexAnyASCII/16:2-8        76.8ns ± 0%  77.0ns ± 0%     ~     (p=1.000 n=5+5)
IndexAnyASCII/16:4-8        83.2ns ± 1%  83.0ns ± 0%     ~     (p=0.770 n=5+5)
IndexAnyASCII/16:8-8         111ns ± 1%   107ns ± 0%   -3.25%  (p=0.008 n=5+5)
IndexAnyASCII/16:16-8        139ns ± 1%   137ns ± 0%   -1.58%  (p=0.008 n=5+5)
IndexAnyASCII/16:32-8        199ns ± 1%   197ns ± 0%   -1.20%  (p=0.008 n=5+5)
IndexAnyASCII/16:64-8        307ns ± 0%   313ns ± 0%   +1.82%  (p=0.016 n=5+4)
IndexAnyASCII/256:1-8        674ns ± 0%    65ns ± 0%  -90.31%  (p=0.008 n=5+5)
IndexAnyASCII/256:2-8        678ns ± 0%   683ns ± 0%   +0.68%  (p=0.008 n=5+5)
IndexAnyASCII/256:4-8        685ns ± 0%   683ns ± 0%   -0.29%  (p=0.000 n=5+4)
IndexAnyASCII/256:8-8        711ns ± 0%   708ns ± 0%   -0.48%  (p=0.008 n=5+5)
IndexAnyASCII/256:16-8       740ns ± 0%   740ns ± 0%     ~     (p=0.444 n=5+5)
IndexAnyASCII/256:32-8       799ns ± 0%   798ns ± 0%   -0.18%  (p=0.008 n=5+5)
IndexAnyASCII/256:64-8       910ns ± 0%   914ns ± 0%   +0.44%  (p=0.016 n=4+5)
IndexAnyUTF8/1:1-8          27.1ns ± 0%  19.0ns ± 0%  -29.79%  (p=0.008 n=5+5)
IndexAnyUTF8/1:2-8          44.1ns ± 0%  33.0ns ± 0%  -25.17%  (p=0.008 n=5+5)
IndexAnyUTF8/1:4-8          46.1ns ± 0%  33.1ns ± 0%  -28.29%  (p=0.016 n=4+5)
IndexAnyUTF8/1:8-8          85.1ns ± 0%  33.0ns ± 0%  -61.18%  (p=0.008 n=5+5)
IndexAnyUTF8/1:16-8          110ns ± 1%    36ns ± 0%  -67.27%  (p=0.008 n=5+5)
IndexAnyUTF8/1:32-8          188ns ± 0%    36ns ± 0%  -80.85%  (p=0.008 n=5+5)
IndexAnyUTF8/1:64-8          332ns ± 0%    39ns ± 0%     ~     (p=0.079 n=4+5)
IndexAnyUTF8/16:1-8          293ns ± 0%    54ns ± 0%  -81.56%  (p=0.008 n=5+5)
IndexAnyUTF8/16:2-8          563ns ± 0%   349ns ± 0%  -37.98%  (p=0.008 n=5+5)
IndexAnyUTF8/16:4-8          546ns ± 1%   349ns ± 0%  -36.10%  (p=0.000 n=5+4)
IndexAnyUTF8/16:8-8         1.22µs ± 0%  0.35µs ± 0%  -71.39%  (p=0.008 n=5+5)
IndexAnyUTF8/16:16-8        1.63µs ± 1%  0.42µs ± 0%  -73.98%  (p=0.008 n=5+5)
IndexAnyUTF8/16:32-8        2.87µs ± 0%  0.42µs ± 0%  -85.22%  (p=0.008 n=5+5)
IndexAnyUTF8/16:64-8        5.18µs ± 0%  0.47µs ± 0%  -90.98%  (p=0.008 n=5+5)
IndexAnyUTF8/256:1-8        4.26µs ± 0%  0.47µs ± 0%  -88.85%  (p=0.000 n=4+5)
IndexAnyUTF8/256:2-8        8.62µs ± 0%  5.15µs ± 0%  -40.21%  (p=0.008 n=5+5)
IndexAnyUTF8/256:4-8        8.25µs ± 0%  5.15µs ± 0%  -37.50%  (p=0.016 n=5+4)
IndexAnyUTF8/256:8-8        19.2µs ± 1%   5.2µs ± 0%  -73.08%  (p=0.016 n=5+4)
IndexAnyUTF8/256:16-8       25.6µs ± 1%   6.3µs ± 0%  -75.32%  (p=0.008 n=5+5)
IndexAnyUTF8/256:32-8       45.6µs ± 0%   6.3µs ± 0%  -86.15%  (p=0.008 n=5+5)
IndexAnyUTF8/256:64-8       82.4µs ± 0%   7.0µs ± 0%  -91.53%  (p=0.016 n=5+4)
LastIndexAnyASCII/1:1-8     23.0ns ± 0%  33.5ns ± 0%  +45.65%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:2-8     24.5ns ± 0%  33.5ns ± 0%  +36.73%  (p=0.016 n=4+5)
LastIndexAnyASCII/1:4-8     27.5ns ± 0%  35.5ns ± 0%  +29.09%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:8-8     44.5ns ± 0%  35.5ns ± 0%  -20.13%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:16-8    56.5ns ± 0%  35.5ns ± 0%  -37.15%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:32-8    80.3ns ± 0%  35.5ns ± 0%  -55.79%  (p=0.000 n=5+4)
LastIndexAnyASCII/1:64-8     129ns ± 0%    40ns ± 0%  -68.85%  (p=0.008 n=5+5)
LastIndexAnyASCII/16:1-8    72.8ns ± 0%  72.7ns ± 0%   -0.19%  (p=0.016 n=4+5)
LastIndexAnyASCII/16:2-8    75.4ns ± 0%  75.1ns ± 0%     ~     (p=0.127 n=5+5)
LastIndexAnyASCII/16:4-8    81.9ns ± 1%  80.2ns ± 0%   -2.00%  (p=0.008 n=5+5)
LastIndexAnyASCII/16:8-8     110ns ± 1%   108ns ± 0%   -1.46%  (p=0.008 n=5+5)
LastIndexAnyASCII/16:16-8    138ns ± 1%   134ns ± 0%   -3.18%  (p=0.008 n=5+5)
LastIndexAnyASCII/16:32-8    198ns ± 0%   197ns ± 0%   -0.51%  (p=0.008 n=5+5)
LastIndexAnyASCII/16:64-8    309ns ± 0%   313ns ± 0%   +1.30%  (p=0.008 n=5+5)
LastIndexAnyASCII/256:1-8    652ns ± 0%   653ns ± 0%   +0.21%  (p=0.008 n=5+5)
LastIndexAnyASCII/256:2-8    656ns ± 0%   656ns ± 0%     ~     (all equal)
LastIndexAnyASCII/256:4-8    663ns ± 0%   663ns ± 0%     ~     (p=0.444 n=5+5)
LastIndexAnyASCII/256:8-8    691ns ± 0%   690ns ± 0%     ~     (p=0.079 n=4+5)
LastIndexAnyASCII/256:16-8   719ns ± 0%   715ns ± 0%   -0.53%  (p=0.000 n=5+4)
LastIndexAnyASCII/256:32-8   779ns ± 0%   780ns ± 0%   +0.13%  (p=0.029 n=4+4)
LastIndexAnyASCII/256:64-8   890ns ± 0%   894ns ± 0%   +0.45%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:1-8      31.6ns ± 0%  33.5ns ± 0%   +6.01%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:2-8      48.6ns ± 0%  33.5ns ± 0%  -30.99%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:4-8      48.6ns ± 0%  33.5ns ± 0%  -31.13%  (p=0.000 n=5+4)
LastIndexAnyUTF8/1:8-8      89.6ns ± 0%  33.5ns ± 0%  -62.56%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:16-8      113ns ± 1%    36ns ± 0%  -68.47%  (p=0.000 n=5+4)
LastIndexAnyUTF8/1:32-8      190ns ± 0%    36ns ± 0%  -81.26%  (p=0.029 n=4+4)
LastIndexAnyUTF8/1:64-8      327ns ± 0%    40ns ± 0%  -87.77%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:1-8      364ns ± 0%   158ns ± 0%     ~     (p=0.079 n=4+5)
LastIndexAnyUTF8/16:2-8      636ns ± 0%   472ns ± 0%  -25.79%  (p=0.000 n=5+4)
LastIndexAnyUTF8/16:4-8      630ns ± 0%   472ns ± 0%  -25.03%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:8-8     1.28µs ± 0%  0.47µs ± 0%  -63.09%  (p=0.016 n=5+4)
LastIndexAnyUTF8/16:16-8    1.66µs ± 0%  0.53µs ± 0%  -68.39%  (p=0.016 n=5+4)
LastIndexAnyUTF8/16:32-8    2.88µs ± 0%  0.53µs ± 0%  -81.72%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:64-8    5.08µs ± 0%  0.57µs ± 0%  -88.79%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:1-8    5.41µs ± 0%  2.03µs ± 0%  -62.46%  (p=0.016 n=4+5)
LastIndexAnyUTF8/256:2-8    9.77µs ± 0%  7.14µs ± 0%  -26.97%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:4-8    9.63µs ± 0%  7.14µs ± 0%  -25.86%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:8-8    20.0µs ± 0%   7.1µs ± 0%  -64.30%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:16-8   26.1µs ± 1%   8.0µs ± 0%  -69.40%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:32-8   45.6µs ± 1%   8.0µs ± 0%  -82.51%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:64-8   80.8µs ± 0%   8.6µs ± 0%  -89.33%  (p=0.016 n=5+4)
pkg:bytes goos:linux goarch:arm64
IndexAnyASCII/1:1-8         26.2ns ± 1%  26.5ns ± 0%   +1.30%  (p=0.016 n=5+4)
IndexAnyASCII/1:2-8         18.5ns ± 0%  26.5ns ± 0%  +43.24%  (p=0.008 n=5+5)
IndexAnyASCII/1:4-8         21.0ns ± 0%  26.5ns ± 0%  +26.38%  (p=0.008 n=5+5)
IndexAnyASCII/1:8-8         37.5ns ± 0%  26.5ns ± 0%  -29.33%  (p=0.000 n=5+4)
IndexAnyASCII/1:16-8        49.6ns ± 0%  26.5ns ± 0%  -46.49%  (p=0.008 n=5+5)
IndexAnyASCII/1:32-8        73.6ns ± 0%  30.1ns ± 0%  -59.16%  (p=0.008 n=5+5)
IndexAnyASCII/1:64-8         122ns ± 0%    33ns ± 0%  -73.23%  (p=0.008 n=5+5)
IndexAnyASCII/16:1-8        73.7ns ± 0%  33.4ns ± 0%  -54.71%  (p=0.008 n=5+5)
IndexAnyASCII/16:2-8        79.1ns ± 0%  78.9ns ± 0%   -0.30%  (p=0.016 n=4+5)
IndexAnyASCII/16:4-8        84.8ns ± 0%  86.1ns ± 0%   +1.58%  (p=0.016 n=5+4)
IndexAnyASCII/16:8-8         111ns ± 0%   111ns ± 0%     ~     (all equal)
IndexAnyASCII/16:16-8        139ns ± 0%   144ns ± 0%   +3.60%  (p=0.016 n=4+5)
IndexAnyASCII/16:32-8        196ns ± 0%   207ns ± 0%   +5.61%  (p=0.016 n=5+4)
IndexAnyASCII/16:64-8        311ns ± 0%   320ns ± 0%   +2.89%  (p=0.016 n=4+5)
IndexAnyASCII/256:1-8        674ns ± 0%    65ns ± 1%  -90.35%  (p=0.008 n=5+5)
IndexAnyASCII/256:2-8        680ns ± 0%   680ns ± 0%     ~     (p=0.444 n=5+5)
IndexAnyASCII/256:4-8        686ns ± 0%   687ns ± 0%     ~     (p=0.167 n=5+5)
IndexAnyASCII/256:8-8        713ns ± 0%   712ns ± 0%   -0.14%  (p=0.008 n=5+5)
IndexAnyASCII/256:16-8       740ns ± 0%   744ns ± 0%   +0.54%  (p=0.016 n=5+4)
IndexAnyASCII/256:32-8       797ns ± 0%   808ns ± 0%   +1.43%  (p=0.008 n=5+5)
IndexAnyASCII/256:64-8       912ns ± 0%   921ns ± 0%   +0.99%  (p=0.016 n=4+5)
IndexAnyUTF8/1:1-8          27.5ns ± 0%  26.5ns ± 0%   -3.64%  (p=0.008 n=5+5)
IndexAnyUTF8/1:2-8          44.5ns ± 0%  26.5ns ± 0%  -40.50%  (p=0.008 n=5+5)
IndexAnyUTF8/1:4-8          45.6ns ± 0%  26.5ns ± 0%  -41.89%  (p=0.000 n=5+4)
IndexAnyUTF8/1:8-8          85.8ns ± 1%  26.5ns ± 0%  -69.11%  (p=0.008 n=5+5)
IndexAnyUTF8/1:16-8          110ns ± 1%    26ns ± 0%  -76.00%  (p=0.016 n=5+4)
IndexAnyUTF8/1:32-8          188ns ± 0%    30ns ± 0%  -84.04%  (p=0.008 n=5+5)
IndexAnyUTF8/1:64-8          333ns ± 0%    33ns ± 0%  -90.20%  (p=0.008 n=5+5)
IndexAnyUTF8/16:1-8          294ns ± 0%   235ns ± 0%  -20.07%  (p=0.008 n=5+5)
IndexAnyUTF8/16:2-8          563ns ± 0%   309ns ± 0%  -45.12%  (p=0.008 n=5+5)
IndexAnyUTF8/16:4-8          558ns ± 1%   309ns ± 0%  -44.60%  (p=0.000 n=5+4)
IndexAnyUTF8/16:8-8         1.23µs ± 0%  0.31µs ± 0%  -74.79%  (p=0.008 n=5+5)
IndexAnyUTF8/16:16-8        1.62µs ± 2%  0.31µs ± 0%  -80.93%  (p=0.008 n=5+5)
IndexAnyUTF8/16:32-8        2.86µs ± 0%  0.38µs ± 0%  -86.87%  (p=0.008 n=5+5)
IndexAnyUTF8/16:64-8        5.18µs ± 0%  0.42µs ± 0%  -91.86%  (p=0.008 n=5+5)
IndexAnyUTF8/256:1-8        4.27µs ± 1%  3.30µs ± 1%  -22.75%  (p=0.008 n=5+5)
IndexAnyUTF8/256:2-8        8.61µs ± 0%  4.45µs ± 0%  -48.31%  (p=0.016 n=4+5)
IndexAnyUTF8/256:4-8        8.44µs ± 0%  4.45µs ± 0%  -47.23%  (p=0.008 n=5+5)
IndexAnyUTF8/256:8-8        19.2µs ± 0%   4.5µs ± 0%  -76.78%  (p=0.008 n=5+5)
IndexAnyUTF8/256:16-8       25.6µs ± 0%   4.5µs ± 0%  -82.63%  (p=0.008 n=5+5)
IndexAnyUTF8/256:32-8       45.4µs ± 0%   5.5µs ± 0%  -87.85%  (p=0.016 n=4+5)
IndexAnyUTF8/256:64-8       82.5µs ± 0%   6.2µs ± 0%  -92.49%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:1-8     23.0ns ± 0%  26.5ns ± 0%  +15.02%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:2-8     24.5ns ± 0%  26.5ns ± 0%   +8.16%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:4-8     27.8ns ± 0%  26.5ns ± 0%   -4.68%  (p=0.029 n=4+4)
LastIndexAnyASCII/1:8-8     45.1ns ± 1%  26.5ns ± 0%  -41.29%  (p=0.000 n=5+4)
LastIndexAnyASCII/1:16-8    57.1ns ± 0%  26.5ns ± 0%  -53.61%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:32-8    81.5ns ± 0%  30.0ns ± 0%     ~     (p=0.079 n=4+5)
LastIndexAnyASCII/1:64-8     129ns ± 0%    32ns ± 0%  -74.81%  (p=0.008 n=5+5)
LastIndexAnyASCII/16:1-8    72.6ns ± 0%  72.1ns ± 0%   -0.63%  (p=0.000 n=4+5)
LastIndexAnyASCII/16:2-8    77.2ns ± 0%  77.2ns ± 0%     ~     (p=0.167 n=5+5)
LastIndexAnyASCII/16:4-8    83.1ns ± 0%  83.2ns ± 0%     ~     (p=0.444 n=5+5)
LastIndexAnyASCII/16:8-8     109ns ± 1%   108ns ± 0%     ~     (p=0.167 n=5+5)
LastIndexAnyASCII/16:16-8    136ns ± 0%   136ns ± 0%     ~     (all equal)
LastIndexAnyASCII/16:32-8    195ns ± 0%   197ns ± 0%   +0.82%  (p=0.008 n=5+5)
LastIndexAnyASCII/16:64-8    309ns ± 0%   309ns ± 0%     ~     (all equal)
LastIndexAnyASCII/256:1-8    653ns ± 0%   657ns ± 0%   +0.61%  (p=0.008 n=5+5)
LastIndexAnyASCII/256:2-8    659ns ± 0%   658ns ± 0%     ~     (p=0.167 n=5+5)
LastIndexAnyASCII/256:4-8    664ns ± 0%   663ns ± 0%     ~     (p=0.095 n=5+4)
LastIndexAnyASCII/256:8-8    698ns ± 0%   689ns ± 0%   -1.29%  (p=0.008 n=5+5)
LastIndexAnyASCII/256:16-8   726ns ± 0%   717ns ± 0%   -1.24%  (p=0.008 n=5+5)
LastIndexAnyASCII/256:32-8   777ns ± 0%   779ns ± 0%     ~     (p=0.079 n=5+4)
LastIndexAnyASCII/256:64-8   889ns ± 0%   890ns ± 0%     ~     (p=0.444 n=5+5)
LastIndexAnyUTF8/1:1-8      32.1ns ± 0%  26.5ns ± 0%  -17.45%  (p=0.000 n=5+4)
LastIndexAnyUTF8/1:2-8      48.6ns ± 0%  26.5ns ± 0%  -45.52%  (p=0.000 n=5+4)
LastIndexAnyUTF8/1:4-8      49.6ns ± 0%  26.5ns ± 0%  -46.62%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:8-8      91.9ns ± 0%  26.5ns ± 0%  -71.18%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:16-8      114ns ± 1%    26ns ± 0%  -76.84%  (p=0.000 n=5+4)
LastIndexAnyUTF8/1:32-8      203ns ± 6%    30ns ± 0%  -85.25%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:64-8      330ns ± 0%    33ns ± 0%  -90.14%  (p=0.000 n=4+5)
LastIndexAnyUTF8/16:1-8      365ns ± 0%   164ns ± 0%  -55.04%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:2-8      638ns ± 0%   296ns ± 0%  -53.58%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:4-8      634ns ± 0%   296ns ± 0%  -53.31%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:8-8     1.30µs ± 0%  0.30µs ± 0%  -77.18%  (p=0.000 n=4+5)
LastIndexAnyUTF8/16:16-8    1.66µs ± 0%  0.30µs ± 0%  -82.19%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:32-8    2.90µs ± 0%  0.38µs ± 0%  -87.00%  (p=0.029 n=4+4)
LastIndexAnyUTF8/16:64-8    5.10µs ± 0%  0.42µs ± 0%  -91.78%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:1-8    5.42µs ± 0%  2.12µs ± 0%  -60.92%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:2-8    9.79µs ± 0%  4.26µs ± 0%  -56.47%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:4-8    9.66µs ± 0%  4.26µs ± 0%  -55.87%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:8-8    20.4µs ± 0%   4.3µs ± 0%  -79.10%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:16-8   26.0µs ± 1%   4.3µs ± 0%  -83.62%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:32-8   46.0µs ± 0%   5.5µs ± 0%  -88.09%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:64-8   81.1µs ± 0%   6.2µs ± 0%  -92.38%  (p=0.008 n=5+5)

name                         old time/op  new time/op   delta
pkg:strings goos:linux goarch:amd64
IndexAnyASCII/1:1-48         10.0ns ± 0%   13.3ns ± 0%  +33.00%  (p=0.008 n=5+5)
IndexAnyASCII/1:2-48         11.0ns ± 0%   15.5ns ± 0%  +40.55%  (p=0.016 n=4+5)
IndexAnyASCII/1:4-48         12.9ns ± 0%   15.4ns ± 0%  +19.69%  (p=0.008 n=5+5)
IndexAnyASCII/1:8-48         18.6ns ± 0%   15.5ns ± 0%  -16.45%  (p=0.000 n=4+5)
IndexAnyASCII/1:16-48        30.1ns ± 0%   16.9ns ± 0%     ~     (p=0.079 n=4+5)
IndexAnyASCII/1:32-48        53.1ns ± 0%   18.6ns ± 0%  -64.95%  (p=0.000 n=5+4)
IndexAnyASCII/1:64-48        98.9ns ± 0%   17.4ns ± 0%  -82.41%  (p=0.000 n=5+4)
IndexAnyASCII/16:1-48        35.0ns ± 0%   14.2ns ± 0%  -59.47%  (p=0.000 n=5+4)
IndexAnyASCII/16:2-48        35.5ns ± 0%   35.6ns ± 0%     ~     (p=0.238 n=5+4)
IndexAnyASCII/16:4-48        40.8ns ± 0%   40.7ns ± 1%     ~     (p=0.643 n=5+5)
IndexAnyASCII/16:8-48        50.8ns ± 0%   50.9ns ± 1%     ~     (p=1.000 n=4+5)
IndexAnyASCII/16:16-48       64.0ns ± 1%   64.5ns ± 1%     ~     (p=0.071 n=5+5)
IndexAnyASCII/16:32-48       98.3ns ± 0%  100.8ns ± 1%   +2.52%  (p=0.008 n=5+5)
IndexAnyASCII/16:64-48        156ns ± 0%    157ns ± 0%     ~     (p=0.238 n=4+5)
IndexAnyASCII/256:1-48        299ns ± 0%     24ns ± 3%  -92.12%  (p=0.008 n=5+5)
IndexAnyASCII/256:2-48        303ns ± 0%    304ns ± 0%     ~     (p=0.762 n=5+5)
IndexAnyASCII/256:4-48        311ns ± 0%    311ns ± 0%     ~     (p=0.476 n=5+5)
IndexAnyASCII/256:8-48        321ns ± 0%    321ns ± 0%     ~     (p=0.429 n=4+5)
IndexAnyASCII/256:16-48       334ns ± 0%    335ns ± 0%     ~     (p=0.079 n=5+4)
IndexAnyASCII/256:32-48       367ns ± 0%    365ns ± 0%     ~     (p=0.079 n=4+5)
IndexAnyASCII/256:64-48       431ns ± 1%    421ns ± 0%   -2.27%  (p=0.008 n=5+5)
IndexAnyUTF8/1:1-48          17.2ns ± 0%   10.8ns ± 0%  -37.21%  (p=0.029 n=4+4)
IndexAnyUTF8/1:2-48          26.7ns ± 0%   15.6ns ± 0%     ~     (p=0.079 n=4+5)
IndexAnyUTF8/1:4-48          28.2ns ± 0%   15.6ns ± 0%  -44.68%  (p=0.000 n=5+4)
IndexAnyUTF8/1:8-48          48.8ns ± 0%   15.6ns ± 0%  -68.03%  (p=0.029 n=4+4)
IndexAnyUTF8/1:16-48         58.3ns ± 0%   16.2ns ± 0%     ~     (p=0.079 n=4+5)
IndexAnyUTF8/1:32-48          103ns ± 0%     18ns ± 0%  -82.27%  (p=0.008 n=5+5)
IndexAnyUTF8/1:64-48          182ns ± 0%     17ns ± 0%  -90.53%  (p=0.008 n=5+5)
IndexAnyUTF8/16:1-48          197ns ± 0%     25ns ± 0%  -87.34%  (p=0.000 n=5+4)
IndexAnyUTF8/16:2-48          348ns ± 0%    163ns ± 0%  -53.11%  (p=0.000 n=5+4)
IndexAnyUTF8/16:4-48          374ns ± 0%    163ns ± 0%  -56.37%  (p=0.000 n=5+4)
IndexAnyUTF8/16:8-48          716ns ± 0%    163ns ± 0%  -77.22%  (p=0.000 n=5+4)
IndexAnyUTF8/16:16-48         859ns ± 0%    175ns ± 0%  -79.63%  (p=0.000 n=5+4)
IndexAnyUTF8/16:32-48        1.58µs ± 0%   0.20µs ± 0%  -87.01%  (p=0.029 n=4+4)
IndexAnyUTF8/16:64-48        2.84µs ± 0%   0.19µs ± 1%  -93.34%  (p=0.008 n=5+5)
IndexAnyUTF8/256:1-48        2.61µs ± 0%   0.27µs ± 0%  -89.81%  (p=0.008 n=5+5)
IndexAnyUTF8/256:2-48        4.95µs ± 0%   2.23µs ± 0%  -54.91%  (p=0.016 n=5+4)
IndexAnyUTF8/256:4-48        5.55µs ± 0%   2.23µs ± 0%  -59.72%  (p=0.008 n=5+5)
IndexAnyUTF8/256:8-48        10.8µs ± 0%    2.2µs ± 0%  -79.39%  (p=0.008 n=5+5)
IndexAnyUTF8/256:16-48       13.1µs ± 0%    2.5µs ± 0%  -81.21%  (p=0.016 n=4+5)
IndexAnyUTF8/256:32-48       24.7µs ± 0%    2.8µs ± 0%  -88.49%  (p=0.008 n=5+5)
IndexAnyUTF8/256:64-48       45.0µs ± 0%    2.6µs ± 1%  -94.23%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:1-48     13.9ns ± 0%   15.2ns ± 0%   +9.35%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:2-48     14.4ns ± 0%   15.2ns ± 0%   +5.56%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:4-48     16.7ns ± 0%   15.2ns ± 0%   -8.98%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:8-48     24.0ns ± 0%   15.2ns ± 0%  -36.67%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:16-48    35.6ns ± 0%   15.0ns ± 0%  -57.82%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:32-48    68.9ns ± 0%   16.7ns ± 0%  -75.75%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:64-48     104ns ± 0%     17ns ± 1%  -83.81%  (p=0.008 n=5+5)
LastIndexAnyASCII/16:1-48    35.0ns ± 0%   35.0ns ± 0%     ~     (all equal)
LastIndexAnyASCII/16:2-48    35.6ns ± 0%   35.6ns ± 0%     ~     (all equal)
LastIndexAnyASCII/16:4-48    41.0ns ± 0%   40.8ns ± 0%   -0.49%  (p=0.032 n=5+5)
LastIndexAnyASCII/16:8-48    50.9ns ± 0%   50.7ns ± 1%     ~     (p=0.397 n=5+5)
LastIndexAnyASCII/16:16-48   64.3ns ± 1%   64.4ns ± 1%     ~     (p=1.000 n=4+5)
LastIndexAnyASCII/16:32-48    100ns ± 0%    100ns ± 0%   +0.38%  (p=0.016 n=4+5)
LastIndexAnyASCII/16:64-48    157ns ± 1%    163ns ± 0%   +3.82%  (p=0.008 n=5+5)
LastIndexAnyASCII/256:1-48    302ns ± 0%    300ns ± 0%   -0.53%  (p=0.008 n=5+5)
LastIndexAnyASCII/256:2-48    305ns ± 0%    303ns ± 0%   -0.66%  (p=0.000 n=5+4)
LastIndexAnyASCII/256:4-48    313ns ± 0%    307ns ± 0%   -2.04%  (p=0.000 n=4+5)
LastIndexAnyASCII/256:8-48    323ns ± 0%    315ns ± 0%   -2.48%  (p=0.029 n=4+4)
LastIndexAnyASCII/256:16-48   333ns ± 0%    332ns ± 0%   -0.30%  (p=0.048 n=5+5)
LastIndexAnyASCII/256:32-48   366ns ± 0%    367ns ± 0%     ~     (p=0.238 n=4+5)
LastIndexAnyASCII/256:64-48   430ns ± 0%    430ns ± 0%     ~     (p=1.000 n=5+5)
LastIndexAnyUTF8/1:1-48      21.1ns ± 0%   13.9ns ± 0%  -34.00%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:2-48      29.5ns ± 0%   13.9ns ± 0%  -52.95%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:4-48      31.6ns ± 0%   13.9ns ± 0%  -55.96%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:8-48      51.1ns ± 0%   13.9ns ± 0%  -72.81%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:16-48     58.9ns ± 0%   14.6ns ± 0%  -75.23%  (p=0.016 n=5+4)
LastIndexAnyUTF8/1:32-48      103ns ± 0%     16ns ± 1%  -84.12%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:64-48      177ns ± 0%     17ns ± 1%  -90.62%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:1-48      275ns ± 1%    105ns ± 0%  -61.85%  (p=0.000 n=5+4)
LastIndexAnyUTF8/16:2-48      406ns ± 0%    216ns ± 0%  -46.70%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:4-48      458ns ± 0%    216ns ± 0%  -52.75%  (p=0.000 n=4+5)
LastIndexAnyUTF8/16:8-48      753ns ± 0%    216ns ± 0%  -71.31%  (p=0.029 n=4+4)
LastIndexAnyUTF8/16:16-48     902ns ± 0%    221ns ± 0%  -75.50%  (p=0.016 n=5+4)
LastIndexAnyUTF8/16:32-48    1.57µs ± 0%   0.24µs ± 0%  -84.46%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:64-48    2.77µs ± 0%   0.24µs ± 0%  -91.22%  (p=0.000 n=5+4)
LastIndexAnyUTF8/256:1-48    4.06µs ± 0%   1.53µs ± 0%  -62.26%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:2-48    5.92µs ± 0%   3.04µs ± 0%  -48.55%  (p=0.016 n=4+5)
LastIndexAnyUTF8/256:4-48    6.82µs ± 0%   3.04µs ± 0%  -55.34%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:8-48    11.5µs ± 0%    3.0µs ± 0%  -73.48%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:16-48   14.1µs ± 0%    3.1µs ± 0%  -77.85%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:32-48   24.5µs ± 0%    3.5µs ± 0%  -85.85%  (p=0.016 n=5+4)
LastIndexAnyUTF8/256:64-48   44.0µs ± 0%    3.5µs ± 0%  -92.12%  (p=0.008 n=5+5)
pkg:bytes goos:linux goarch:amd64
IndexAnyASCII/1:1-48         9.56ns ± 0%  11.00ns ± 0%  +15.06%  (p=0.016 n=5+4)
IndexAnyASCII/1:2-48         11.0ns ± 0%   10.8ns ± 2%   -1.64%  (p=0.048 n=5+5)
IndexAnyASCII/1:4-48         13.9ns ± 0%   11.0ns ± 1%  -21.15%  (p=0.008 n=5+5)
IndexAnyASCII/1:8-48         19.6ns ± 0%   10.8ns ± 3%  -44.90%  (p=0.008 n=5+5)
IndexAnyASCII/1:16-48        31.1ns ± 0%   11.5ns ± 0%  -63.02%  (p=0.008 n=5+5)
IndexAnyASCII/1:32-48        54.0ns ± 0%   11.8ns ± 0%  -78.15%  (p=0.000 n=5+4)
IndexAnyASCII/1:64-48         100ns ± 0%     13ns ± 0%  -86.89%  (p=0.008 n=5+5)
IndexAnyASCII/16:1-48        35.5ns ± 0%   14.8ns ± 0%  -58.26%  (p=0.008 n=5+5)
IndexAnyASCII/16:2-48        36.2ns ± 1%   36.0ns ± 1%     ~     (p=0.087 n=5+5)
IndexAnyASCII/16:4-48        40.3ns ± 1%   39.7ns ± 4%     ~     (p=0.175 n=4+5)
IndexAnyASCII/16:8-48        48.7ns ± 5%   45.8ns ± 0%   -6.02%  (p=0.016 n=5+4)
IndexAnyASCII/16:16-48       64.1ns ±11%   62.1ns ± 1%     ~     (p=0.143 n=5+5)
IndexAnyASCII/16:32-48       97.9ns ± 1%   98.3ns ± 1%     ~     (p=0.294 n=5+5)
IndexAnyASCII/16:64-48        163ns ± 0%    157ns ± 0%   -3.68%  (p=0.008 n=5+5)
IndexAnyASCII/256:1-48        389ns ± 0%     25ns ± 0%  -93.65%  (p=0.000 n=5+4)
IndexAnyASCII/256:2-48        391ns ± 0%    307ns ± 0%  -21.48%  (p=0.000 n=5+4)
IndexAnyASCII/256:4-48        394ns ± 0%    323ns ± 0%  -17.92%  (p=0.008 n=5+5)
IndexAnyASCII/256:8-48        402ns ± 0%    323ns ± 0%  -19.51%  (p=0.008 n=5+5)
IndexAnyASCII/256:16-48       414ns ± 0%    334ns ± 0%  -19.32%  (p=0.016 n=4+5)
IndexAnyASCII/256:32-48       446ns ± 0%    367ns ± 0%  -17.75%  (p=0.016 n=5+4)
IndexAnyASCII/256:64-48       511ns ± 0%    424ns ± 0%  -17.02%  (p=0.008 n=5+5)
IndexAnyUTF8/1:1-48          17.4ns ± 0%   11.0ns ± 0%  -36.64%  (p=0.008 n=5+5)
IndexAnyUTF8/1:2-48          27.3ns ± 1%   11.0ns ± 0%  -59.74%  (p=0.008 n=5+5)
IndexAnyUTF8/1:4-48          28.7ns ± 0%   11.0ns ± 0%  -61.73%  (p=0.008 n=5+5)
IndexAnyUTF8/1:8-48          49.2ns ± 0%   11.0ns ± 0%  -77.66%  (p=0.008 n=5+5)
IndexAnyUTF8/1:16-48         56.0ns ± 0%   11.5ns ± 0%  -79.46%  (p=0.000 n=5+4)
IndexAnyUTF8/1:32-48          102ns ± 0%     12ns ± 0%  -88.24%  (p=0.008 n=5+5)
IndexAnyUTF8/1:64-48          177ns ± 0%     13ns ± 0%  -92.51%  (p=0.008 n=5+5)
IndexAnyUTF8/16:1-48          212ns ± 0%    112ns ± 0%  -47.17%  (p=0.008 n=5+5)
IndexAnyUTF8/16:2-48          356ns ± 0%    159ns ± 1%  -55.28%  (p=0.000 n=4+5)
IndexAnyUTF8/16:4-48          372ns ± 0%    158ns ± 0%  -57.47%  (p=0.008 n=5+5)
IndexAnyUTF8/16:8-48          712ns ± 0%    159ns ± 1%  -77.70%  (p=0.008 n=5+5)
IndexAnyUTF8/16:16-48         829ns ± 0%    129ns ± 0%  -84.44%  (p=0.008 n=5+5)
IndexAnyUTF8/16:32-48        1.55µs ± 0%   0.16µs ± 0%  -89.87%  (p=0.008 n=5+5)
IndexAnyUTF8/16:64-48        2.77µs ± 0%   0.14µs ± 0%  -94.94%  (p=0.008 n=5+5)
IndexAnyUTF8/256:1-48        2.85µs ± 0%   1.63µs ± 1%  -42.74%  (p=0.008 n=5+5)
IndexAnyUTF8/256:2-48        5.14µs ± 1%   2.03µs ± 0%  -60.51%  (p=0.008 n=5+5)
IndexAnyUTF8/256:4-48        5.56µs ± 0%   2.03µs ± 0%  -63.52%  (p=0.008 n=5+5)
IndexAnyUTF8/256:8-48        10.8µs ± 0%    2.0µs ± 0%  -81.22%  (p=0.008 n=5+5)
IndexAnyUTF8/256:16-48       12.9µs ± 0%    1.9µs ± 0%  -85.55%  (p=0.008 n=5+5)
IndexAnyUTF8/256:32-48       24.2µs ± 0%    2.1µs ± 0%  -91.29%  (p=0.016 n=5+4)
IndexAnyUTF8/256:64-48       43.7µs ± 0%    2.0µs ± 0%  -95.32%  (p=0.016 n=5+4)
LastIndexAnyASCII/1:1-48     13.7ns ± 1%   12.8ns ± 0%   -6.57%  (p=0.016 n=5+4)
LastIndexAnyASCII/1:2-48     14.7ns ± 0%   12.7ns ± 1%  -13.33%  (p=0.000 n=4+5)
LastIndexAnyASCII/1:4-48     16.9ns ± 0%   12.7ns ± 1%  -24.73%  (p=0.000 n=4+5)
LastIndexAnyASCII/1:8-48     20.5ns ± 0%   12.7ns ± 0%  -37.85%  (p=0.000 n=4+5)
LastIndexAnyASCII/1:16-48    28.0ns ± 0%   11.7ns ± 0%     ~     (p=0.079 n=4+5)
LastIndexAnyASCII/1:32-48    69.8ns ± 0%   12.4ns ± 0%  -82.19%  (p=0.008 n=5+5)
LastIndexAnyASCII/1:64-48    73.8ns ± 0%   13.3ns ± 0%  -82.03%  (p=0.000 n=4+5)
LastIndexAnyASCII/16:1-48    35.5ns ± 0%   35.5ns ± 0%     ~     (all equal)
LastIndexAnyASCII/16:2-48    36.0ns ± 0%   36.1ns ± 0%   +0.28%  (p=0.016 n=4+5)
LastIndexAnyASCII/16:4-48    40.3ns ± 2%   40.0ns ± 6%     ~     (p=0.651 n=5+5)
LastIndexAnyASCII/16:8-48    50.3ns ± 0%   50.2ns ± 9%     ~     (p=0.175 n=4+5)
LastIndexAnyASCII/16:16-48   62.4ns ± 4%   64.4ns ± 0%   +3.28%  (p=0.016 n=5+4)
LastIndexAnyASCII/16:32-48   98.9ns ± 0%   98.4ns ± 0%   -0.53%  (p=0.016 n=5+4)
LastIndexAnyASCII/16:64-48    160ns ± 1%    161ns ± 1%     ~     (p=0.325 n=5+5)
LastIndexAnyASCII/256:1-48    300ns ± 0%    301ns ± 0%   +0.33%  (p=0.008 n=5+5)
LastIndexAnyASCII/256:2-48    304ns ± 0%    304ns ± 0%     ~     (p=1.000 n=5+5)
LastIndexAnyASCII/256:4-48    311ns ± 0%    311ns ± 0%     ~     (p=0.556 n=4+5)
LastIndexAnyASCII/256:8-48    320ns ± 0%    321ns ± 0%     ~     (p=0.143 n=5+5)
LastIndexAnyASCII/256:16-48   333ns ± 0%    335ns ± 0%   +0.60%  (p=0.029 n=4+4)
LastIndexAnyASCII/256:32-48   367ns ± 0%    366ns ± 0%     ~     (p=0.095 n=4+5)
LastIndexAnyASCII/256:64-48   431ns ± 0%    424ns ± 0%   -1.62%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:1-48      19.7ns ± 1%   11.9ns ± 0%  -39.47%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:2-48      27.6ns ± 1%   11.9ns ± 0%  -56.82%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:4-48      29.9ns ± 0%   11.9ns ± 0%     ~     (p=0.079 n=4+5)
LastIndexAnyUTF8/1:8-48      48.7ns ± 0%   11.9ns ± 0%  -75.54%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:16-48     57.8ns ± 0%   11.4ns ± 0%  -80.26%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:32-48     94.7ns ± 0%   12.2ns ± 0%  -87.07%  (p=0.008 n=5+5)
LastIndexAnyUTF8/1:64-48      163ns ± 0%     13ns ± 1%  -91.93%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:1-48      258ns ± 0%     88ns ± 0%  -65.76%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:2-48      400ns ± 0%    162ns ± 0%  -59.38%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:4-48      415ns ± 0%    162ns ± 0%  -60.87%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:8-48      737ns ± 0%    162ns ± 0%  -78.02%  (p=0.000 n=5+4)
LastIndexAnyUTF8/16:16-48     882ns ± 0%    128ns ± 0%  -85.49%  (p=0.008 n=5+5)
LastIndexAnyUTF8/16:32-48    1.47µs ± 0%   0.16µs ± 0%  -89.29%  (p=0.000 n=4+5)
LastIndexAnyUTF8/16:64-48    2.56µs ± 0%   0.14µs ± 0%  -94.41%  (p=0.016 n=5+4)
LastIndexAnyUTF8/256:1-48    3.60µs ± 0%   1.23µs ± 0%  -65.67%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:2-48    5.78µs ± 0%   2.18µs ± 0%  -62.32%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:4-48    6.26µs ± 0%   2.18µs ± 0%  -65.15%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:8-48    11.2µs ± 0%    2.2µs ± 0%  -80.53%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:16-48   13.5µs ± 0%    1.9µs ± 0%  -86.02%  (p=0.016 n=4+5)
LastIndexAnyUTF8/256:32-48   23.0µs ± 0%    2.1µs ± 0%  -90.72%  (p=0.008 n=5+5)
LastIndexAnyUTF8/256:64-48   40.5µs ± 0%    2.1µs ± 0%  -94.73%  (p=0.008 n=5+5)

Change-Id: Ie05e306f8b184b989701868cb161ce8b3f18203b
Reviewed-on: https://go-review.googlesource.com/c/go/+/156998
Run-TryBot: eric fang <eric.fang@arm.com>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2020-03-11 05:13:13 +00:00
erifan01 18a6fd44bb bytes, strings: moves indexRabinKarp function to internal/bytealg 
In order to facilitate optimization of IndexAny and LastIndexAny, this patch moves
three Rabin-Karp related functions indexRabinKarp, hashStr and hashStrRev in strings
package to initernal/bytealg. There are also three functions in the bytes package with
the same names and functions but different parameter types. To highlight this, this
patch also moves them to internal/bytealg and gives them slightly different names.

Related benchmark changes on amd64 and arm64:

name          old time/op    new time/op    delta
pkg:strings goos:linux goarch:amd64
Index-16        14.0ns ± 1%    14.1ns ± 2%    ~     (p=0.738 n=5+5)
LastIndex-16    15.5ns ± 1%    15.7ns ± 4%    ~     (p=0.897 n=5+5)
pkg:bytes goos:linux goarch:amd64
Index/10-16     26.5ns ± 1%    26.5ns ± 0%    ~     (p=0.873 n=5+5)
Index/32-16     26.2ns ± 0%    25.7ns ± 0%  -1.68%  (p=0.008 n=5+5)
Index/4K-16     5.12µs ± 4%    5.14µs ± 2%    ~     (p=0.841 n=5+5)
Index/4M-16     5.44ms ± 3%    5.34ms ± 2%    ~     (p=0.056 n=5+5)
Index/64M-16    85.8ms ± 3%    84.6ms ± 0%  -1.37%  (p=0.016 n=5+5)

name          old speed      new speed      delta
pkg:bytes goos:linux goarch:amd64
Index/10-16    377MB/s ± 1%   377MB/s ± 0%    ~     (p=1.000 n=5+5)
Index/32-16   1.22GB/s ± 1%  1.24GB/s ± 0%  +1.66%  (p=0.008 n=5+5)
Index/4K-16    800MB/s ± 4%   797MB/s ± 2%    ~     (p=0.841 n=5+5)
Index/4M-16    771MB/s ± 3%   786MB/s ± 2%    ~     (p=0.056 n=5+5)
Index/64M-16   783MB/s ± 3%   793MB/s ± 0%  +1.36%  (p=0.016 n=5+5)

name         old time/op   new time/op   delta
pkg:strings goos:linux goarch:arm64
Index-8       22.6ns ± 0%   22.5ns ± 0%    ~     (p=0.167 n=5+5)
LastIndex-8   17.5ns ± 0%   17.5ns ± 0%    ~     (all equal)
pkg:bytes goos:linux goarch:arm64
Index/10-8    25.0ns ± 0%   25.0ns ± 0%    ~     (all equal)
Index/32-8     160ns ± 0%    160ns ± 0%    ~     (all equal)
Index/4K-8    6.26µs ± 0%   6.26µs ± 0%    ~     (p=0.167 n=5+5)
Index/4M-8    6.30ms ± 0%   6.31ms ± 0%    ~     (p=1.000 n=5+5)
Index/64M-8    101ms ± 0%    101ms ± 0%    ~     (p=0.690 n=5+5)

name         old speed     new speed     delta
pkg:bytes goos:linux goarch:arm64
Index/10-8   399MB/s ± 0%  400MB/s ± 0%  +0.08%  (p=0.008 n=5+5)
Index/32-8   200MB/s ± 0%  200MB/s ± 0%    ~     (p=0.127 n=4+5)
Index/4K-8   654MB/s ± 0%  654MB/s ± 0%  +0.01%  (p=0.016 n=5+5)
Index/4M-8   665MB/s ± 0%  665MB/s ± 0%    ~     (p=0.833 n=5+5)
Index/64M-8  665MB/s ± 0%  665MB/s ± 0%    ~     (p=0.913 n=5+5)

Change-Id: Icce3bc162bb8613ac36dc963a46c51f8e82ab842
Reviewed-on: https://go-review.googlesource.com/c/go/+/208638
Run-TryBot: eric fang <eric.fang@arm.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2020-03-04 17:36:05 +00:00
HowJMay 75619d199f bytes: deflake TestGrow by using testing.AllocsPerRun 
Fixes #36695

Change-Id: I4392246015252018b49f321a5a839cc68cc611d7
GitHub-Last-Rev: c2fb1f7ddb
GitHub-Pull-Request: golang/go#36732
Reviewed-on: https://go-review.googlesource.com/c/go/+/216237
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
 2020-02-26 18:40:56 +00:00
Keith Randall 35cfe059a1 hash/maphash: move bytes/hash to hash/maphash 
Fixes #34778

Change-Id: If8225a7c41cb2af3f67157fb9670eef86272e85e
Reviewed-on: https://go-review.googlesource.com/c/go/+/204997
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-11-02 18:30:37 +00:00
Keith Randall dba19c65a7 bytes/hash: initialize all 64 bits of hash seed 
Fixes #34925

Change-Id: Iadf12ca47a69b62c3f48d732b430cc85cf62a91c
Reviewed-on: https://go-review.googlesource.com/c/go/+/202577
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-10-21 22:01:12 +00:00
Meng Zhuo fc2915fabd bytes: add endian base compare test 
The current bytes test suit didn't come with endian based test
which causing #34549 can passed the try-bot.
This test will failed when little endian architecture simply using
load and compare uint.

Update #34549

Change-Id: I0973c2cd505ce21c2bed1deeb7d526f1e872118d
Reviewed-on: https://go-review.googlesource.com/c/go/+/198358
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
 2019-10-07 14:49:57 +00:00
Andrew Medvedev 78e5288b5c strings, bytes: clarify usage of EqualFolds 
This clarifies meaning of "case folding" Unicode equality with more familiar "case insensitive" wording.
For case folding properties see ftp://ftp.unicode.org/Public/UNIDATA/CaseFolding.txt.

Fixes #33447

Change-Id: I6ee85ab398679bf2a0b7d18693985ff0979d6c5a
GitHub-Last-Rev: accc915933
GitHub-Pull-Request: golang/go#34434
Reviewed-on: https://go-review.googlesource.com/c/go/+/196717
Reviewed-by: Rob Pike <r@golang.org>
 2019-09-21 21:45:58 +00:00
Keith Randall 7c90e2cbda bytes/hash: disable seed test on 32-bit platforms 
The distribution of hash outputs when varying the seed is
not good enough on 32-bit platforms.

This isn't a likely attack vector (the adversary controlling the seed),
so it isn't a huge deal. Would be nice to fix, though. For now, just
skip this test.

Fixes #33988

Change-Id: Icf51ab687fc215422a5492ae78e6f414b33e04cb
Reviewed-on: https://go-review.googlesource.com/c/go/+/193078
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-09-03 19:37:16 +00:00
Keith Randall bf36219cdd bytes/hash: add hashing package for bytes and strings 
Fixes #28322

R=go1.14

RELNOTE=yes

Change-Id: Ic29f8b587c8c77472260836a5c3e13edaded13fa
Reviewed-on: https://go-review.googlesource.com/c/go/+/186877
Reviewed-by: Alan Donovan <adonovan@google.com>
 2019-08-29 21:27:53 +00:00
Maxim Eryomenko 0f897f916a bytes: remove obsolete comment 
Change-Id: Iec4348eb674c8c64497c82e5d7cd656736cfcebd
GitHub-Last-Rev: 462c323960
GitHub-Pull-Request: golang/go#32225
Reviewed-on: https://go-review.googlesource.com/c/go/+/178797
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-05-28 02:52:39 +00:00
Martin Möhrmann 3259bc4419 strings, bytes: add ToValidUTF8 
The newly added functions create a copy of their input with all bytes in
invalid UTF-8 byte sequences mapped to the UTF-8 byte sequence
given as replacement parameter.

Fixes #25805

Change-Id: Iaf65f65b40c0581c6bb000f1590408d6628321d0
Reviewed-on: https://go-review.googlesource.com/c/go/+/142003
Run-TryBot: Martin Möhrmann <moehrmann@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-05-01 18:31:47 +00:00
Josh Bleecher Snyder ca0c449a6b bytes, internal/bytealg: simplify Equal 
The compiler has advanced enough that it is cheaper
to convert to strings than to go through the assembly
trampolines to call runtime.memequal.

Simplify Equal accordingly, and cull dead code from bytealg.

While we're here, simplify Equal's documentation.

Fixes #31587

Change-Id: Ie721d33f9a6cbd86b1d873398b20e7882c2c63e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/173323
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Dave Cheney <dave@cheney.net>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-04-24 00:56:36 +00:00
Tobias Klauser 08e1823a63 bytes: optimize ToLower and ToUpper for ASCII-only case 
Follow what CL 68370 and CL 76470 did for the respective functions in
package strings.

Also adjust godoc strings to match the respective strings functions and
mention the special case for ASCII-only byte slices which don't need
conversion.

name                                       old time/op  new time/op  delta
ToUpper/#00-8                              9.35ns ± 3%  6.08ns ± 2%  -35.04%  (p=0.000 n=9+9)
ToUpper/ONLYUPPER-8                        77.7ns ± 1%  16.9ns ± 2%  -78.22%  (p=0.000 n=10+10)
ToUpper/abc-8                              36.5ns ± 1%  22.1ns ± 1%  -39.43%  (p=0.000 n=10+8)
ToUpper/AbC123-8                           56.9ns ± 2%  28.2ns ± 2%  -50.54%  (p=0.000 n=8+10)
ToUpper/azAZ09_-8                          62.3ns ± 1%  26.9ns ± 1%  -56.82%  (p=0.000 n=9+10)
ToUpper/longStrinGwitHmixofsmaLLandcAps-8   219ns ± 2%    63ns ± 2%  -71.17%  (p=0.000 n=10+10)
ToUpper/longɐstringɐwithɐnonasciiⱯchars-8   367ns ± 2%   374ns ± 3%   +2.05%  (p=0.000 n=9+10)
ToUpper/ɐɐɐɐɐ-8                             200ns ± 1%   206ns ± 1%   +2.49%  (p=0.000 n=10+10)
ToUpper/a\u0080\U0010ffff-8                90.4ns ± 1%  93.8ns ± 0%   +3.82%  (p=0.000 n=10+7)
ToLower/#00-8                              9.59ns ± 1%  6.13ns ± 2%  -36.08%  (p=0.000 n=10+10)
ToLower/abc-8                              36.4ns ± 1%  10.4ns ± 1%  -71.50%  (p=0.000 n=10+10)
ToLower/AbC123-8                           55.8ns ± 1%  27.5ns ± 1%  -50.61%  (p=0.000 n=10+10)
ToLower/azAZ09_-8                          61.7ns ± 1%  30.2ns ± 1%  -50.98%  (p=0.000 n=8+10)
ToLower/longStrinGwitHmixofsmaLLandcAps-8   226ns ± 1%    64ns ± 1%  -71.53%  (p=0.000 n=10+9)
ToLower/LONGⱯSTRINGⱯWITHⱯNONASCIIⱯCHARS-8   354ns ± 0%   361ns ± 0%   +2.18%  (p=0.000 n=10+10)
ToLower/ⱭⱭⱭⱭⱭ-8                             180ns ± 1%   186ns ± 0%   +3.45%  (p=0.000 n=10+9)
ToLower/A\u0080\U0010ffff-8                91.7ns ± 0%  94.5ns ± 0%   +2.99%  (p=0.000 n=10+10)

Change-Id: Ifdb8ae328ff9feacd1c170db8eebbf98c399e204
Reviewed-on: https://go-review.googlesource.com/c/go/+/170954
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
 2019-04-09 05:45:34 +00:00
Tobias Klauser 94507d2213 bytes: merge explodetests into splittests 
splittests already contains most of the tests that cover explode. Add
the missing ones and skip the append test for empty results which would
otherwise lead to an "index out of range" panic.

Change-Id: I2cb922282d2676be9ef85f186513075ae17c0243
Reviewed-on: https://go-review.googlesource.com/c/go/+/170126
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-04-03 14:46:01 +00:00
Ben Hoyt 154e5abfcd bytes, strings: add tests for TrimLeftFunc and TrimRightFunc 
When I was working on the fix for #31038 (make TrimSpace return nil on
all-space input) I noticed that there were no tests for TrimLeftFunc
and TrimRightFunc, including the funky nil behavior. So add some!

I've just reused the existing TrimFunc test cases for TrimLeftFunc and
TrimRightFunc, as well as adding new tests for the empty string and
all-trimmed cases (which test the nil-returning behavior of TrimFunc and
TrimLeftFunc).

Change-Id: Ib580d4364e9b3c91350305f9d9873080d7862904
Reviewed-on: https://go-review.googlesource.com/c/go/+/170061
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2019-03-29 14:16:35 +00:00
Ben Hoyt f24e1099cb bytes: make TrimSpace return nil on all-space input 
Issue #29122 introduced a subtle regression due to the way that
TrimFuncLeft is written: previously TrimSpace returned nil when given
an input of all whitespace, but with the #29122 changes it returned an
empty slice on all-space input.

This change adds a special case to the new, optimized TrimSpace to go
back to that behavior. While it is odd behavior and people shouldn't be
relying on these functions returning a nil slice in practice, it's not
worth the breakage of code that does.

This tweak doesn't change the TrimSpace benchmarks significantly.

Fixes #31038

Change-Id: Idb495d02b474054d2b2f593c2e318a7a6625688a
Reviewed-on: https://go-review.googlesource.com/c/go/+/169518
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2019-03-27 13:52:52 +00:00
Tobias Klauser 9d9d4eeb87 bytes: add hard benchmarks for Index and Count 
Add Benchmark(Index|Count)Hard[1-3] in preparation for implementing
Index and Count in assembly on arm.

Updates #29001

Change-Id: I2a9701892190e8d91de069c2f5a7f5bd3544c6c2
Reviewed-on: https://go-review.googlesource.com/c/go/+/167798
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-03-15 14:04:37 +00:00
Ben Hoyt 4b4f222a0d bytes, strings: speed up TrimSpace 4-5x for common ASCII cases 
This change adds a fast path for ASCII strings to both
strings.TrimSpace and bytes.TrimSpace. It doesn't slow down the
non-ASCII path much, if at all.

I added benchmarks for strings.TrimSpace as it didn't have any, and
I fleshed out the benchmarks for bytes.TrimSpace as it just had one
case (for ASCII). The benchmarks (and the code!) are now the same
between the two versions. Below are the benchmark results:

strings.TrimSpace:

name                      old time/op  new time/op  delta
TrimSpace/NoTrim-8        18.6ns ± 0%   3.8ns ± 0%  -79.53%  (p=0.000 n=5+4)
TrimSpace/ASCII-8         33.5ns ± 2%   6.0ns ± 3%  -82.05%  (p=0.008 n=5+5)
TrimSpace/SomeNonASCII-8  97.1ns ± 1%  88.6ns ± 1%   -8.68%  (p=0.008 n=5+5)
TrimSpace/JustNonASCII-8   144ns ± 0%   143ns ± 0%     ~     (p=0.079 n=4+5)

bytes.TrimSpace:

name                      old time/op  new time/op  delta
TrimSpace/NoTrim-8        18.9ns ± 1%   4.1ns ± 1%  -78.34%  (p=0.008 n=5+5)
TrimSpace/ASCII-8         29.9ns ± 0%   6.3ns ± 1%  -79.06%  (p=0.008 n=5+5)
TrimSpace/SomeNonASCII-8  91.5ns ± 0%  82.3ns ± 0%  -10.03%  (p=0.008 n=5+5)
TrimSpace/JustNonASCII-8   150ns ± 0%   150ns ± 0%     ~     (all equal)

Fixes #29122

Change-Id: Ica45cd86a219cadf60173ec9db260133cd1d7951
Reviewed-on: https://go-review.googlesource.com/c/go/+/152917
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Gobot Gobot <gobot@golang.org>
 2019-03-12 15:52:17 +00:00
Tobias Klauser 0e9d7d430b bytes: return early in Repeat if count is 0 
This matches the implementation of strings.Repeat and slightly increases
performance:

name      old time/op  new time/op  delta
Repeat-8   145ns ±12%   125ns ±29%  -13.35%  (p=0.009 n=10+10)

Change-Id: Ic0a0e2ea9e36591286a49def320ddb67fe0b2c50
Reviewed-on: https://go-review.googlesource.com/c/go/+/166399
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-03-09 14:17:13 +00:00
Tobias Klauser ce7534ff06 bytes: use Rabin-Karp algorithm for LastIndex 
Implement LastIndex using the Rabin-Karp algorithm akin to
strings.LastIndex

name              old time/op  new time/op  delta
LastIndexHard1-8  3.16ms ± 1%  1.44ms ± 0%  -54.35%  (p=0.008 n=5+5)
LastIndexHard2-8  3.17ms ± 1%  1.45ms ± 0%  -54.27%  (p=0.008 n=5+5)
LastIndexHard3-8  3.05ms ± 1%  1.44ms ± 1%  -52.58%  (p=0.008 n=5+5)

Change-Id: Ie8ddd179cd84dfa00e3e4e2327ef932975c88670
Reviewed-on: https://go-review.googlesource.com/c/go/+/166258
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2019-03-08 13:46:43 +00:00
Tobias Klauser b4baa8dd1d bytes: add benchmark for LastIndex 
Add BenchmarkLastIndexHard[1-3] in preparation for implementing
LastIndex using Rabin-Karp akin to strings.LastIndex

BenchmarkLastIndexHard1-8   	     500	   3162694 ns/op
BenchmarkLastIndexHard2-8   	     500	   3170475 ns/op
BenchmarkLastIndexHard3-8   	     500	   3051127 ns/op

Change-Id: Id99f85f9640e248958f2b4be4dfd8c974e3b50e7
Reviewed-on: https://go-review.googlesource.com/c/go/+/166257
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2019-03-08 13:46:34 +00:00
Ketan Parmar 1f3d38fdaa bytes: add examples for ToTitleSpecial, ToUpperSpecial and ToLowerSpecial 
Change-Id: If700a150492181f68e23e90ef829ff9eaf7ca7b5
Reviewed-on: https://go-review.googlesource.com/c/161737
Run-TryBot: Andrew Bonventre <andybons@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Andrew Bonventre <andybons@golang.org>
 2019-03-01 14:56:41 +00:00
Leon Klingele 97f81572c4 bytes: clean up a test 
Change-Id: Iaa0e1721996b582bba9509c083755e1f125abb6b
GitHub-Last-Rev: c9b13ec0cd
GitHub-Pull-Request: golang/go#29996
Reviewed-on: https://go-review.googlesource.com/c/160420
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
 2019-02-26 23:16:46 +00:00
Marcel van Lohuizen ef954a03eb bytes: hoist error creation out of function 
generating frame information in errors will cause this
function to no longer be inlined.

Updates #29934.

Change-Id: I1d7bc11707f1872d7315f627bfb9a12afa41e358
Reviewed-on: https://go-review.googlesource.com/c/161760
Run-TryBot: Marcel van Lohuizen <mpvl@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2019-02-26 22:57:25 +00:00
dupoxy 57de1af78c bytes: add ReplaceAll example 
Change-Id: I36cc0b68a5a47ac78982b05118c58723c9c6648c
GitHub-Last-Rev: 0704d95694
GitHub-Pull-Request: golang/go#29203
Reviewed-on: https://go-review.googlesource.com/c/153842
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2018-12-13 19:40:13 +00:00
Tobias Klauser 9e277f7d55 all: use "reports whether" consistently instead of "returns whether" 
Follow-up for CL 147037 and after Brad noticed the "returns whether"
pattern during the review of CL 150621.

Go documentation style for boolean funcs is to say:

    // Foo reports whether ...
    func Foo() bool

(rather than "returns whether")

Created with:

    $ perl -i -npe 's/returns whether/reports whether/' $(git grep -l "returns whether" | grep -v vendor)

Change-Id: I15fe9ff99180ad97750cd05a10eceafdb12dc0b4
Reviewed-on: https://go-review.googlesource.com/c/150918
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2018-12-02 15:12:26 +00:00
Keith Randall ad4a58e315 strings,bytes: use inlineable function trampolines instead of linkname 
Cleans things up quite a bit.

There's still a few more, like runtime.cmpstring, which might also
be worth fixing.

Change-Id: Ide18dd621efc129cc686db223f47fa0b044b5580
Reviewed-on: https://go-review.googlesource.com/c/148578
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
 2018-11-08 20:52:47 +00:00
Tim Cooper 5fc4604aa8 bytes, strings: fix Reader.UnreadRune returning without error on a zero Reader 
Fixes #28269

Change-Id: I878dff43c0b6bdb98702d8e73f2ecd984fb2350f
Reviewed-on: https://go-review.googlesource.com/c/145098
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
 2018-10-29 20:07:25 +00:00
LotusFenn c96c2a39bb bytes: vary the input alignment to Compare argument in compare_test.go 
Currently there are no tests that vary the alignment of Compare arguments.
Since Compare is written in assembly on most platforms (in internal/bytealg)
we should be testing different input alignments. This change modifies TestCompare
to vary the alignment of the second argument of Compare.

Updates #26129

Change-Id: I4c30a5adf96a41225df748675f4e9beea413b35c
Reviewed-on: https://go-review.googlesource.com/c/122536
Reviewed-by: Lotus Fenn <fenn.lotus@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
 2018-10-11 04:45:18 +00:00
Brad Fitzpatrick ebdc0b8d68 bytes, strings: add ReplaceAll 
Credit to Harald Nordgren for the proposal in
https://golang.org/cl/137456 and #27864.

Fixes #27864

Change-Id: I80546683b0623124fe4627a71af88add2f6c1c27
Reviewed-on: https://go-review.googlesource.com/137855
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2018-09-26 20:51:23 +00:00
erifan01 691f5c34ad strings, bytes: optimize function Index 
This change compares the first two characters instead of the first one,
and if they match, the entire string is compared. Comparing the first two
characters helps to filter out the case where the first character matches
but the subsequent characters do not match, thereby improving the substring
search speed in this case.

Benchmarks with no effect or minimal impact (less than 5%) is not listed,
the following are improved benchmarks:
On arm64:
strings:
IndexPeriodic/IndexPeriodic16-8   172890.00ns +- 2%   124156.20ns +- 0%  -28.19%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic32-8    78092.80ns +- 0%    65138.60ns +- 0%  -16.59%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic64-8    42322.20ns +- 0%    34661.60ns +- 0%  -18.10%  (p=0.008 n=5+5)
bytes:
IndexPeriodic/IndexPeriodic16-8     183468.20ns +- 6%     123759.00ns +- 0%  -32.54%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic32-8      84776.40ns +- 0%      63907.80ns +- 0%  -24.62%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic64-8      45835.60ns +- 0%      34194.20ns +- 0%  -25.40%  (p=0.008 n=5+5)

On amd64:
strings:
IndexPeriodic/IndexPeriodic8-16    219499.00ns +- 0%   178123.40ns +- 0%  -18.85%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic16-16   109760.20ns +- 0%    88957.80ns +- 0%  -18.95%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic32-16    54943.00ns +- 0%    44573.80ns +- 0%  -18.87%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic64-16    29804.80ns +- 0%    24417.80ns +- 0%  -18.07%  (p=0.008 n=5+5)
bytes:
IndexPeriodic/IndexPeriodic8-16     226592.60ns +- 0%    181183.20ns +- 0%  -20.04%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic16-16    111432.60ns +- 0%     90634.60ns +- 0%  -18.66%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic32-16     55640.60ns +- 0%     45433.00ns +- 0%  -18.35%  (p=0.008 n=5+5)
IndexPeriodic/IndexPeriodic64-16     30833.00ns +- 0%     24784.20ns +- 0%  -19.62%  (p=0.008 n=5+5)

Change-Id: I2d9e7e138d29e960d20a203eb74dc2ec976a9d71
Reviewed-on: https://go-review.googlesource.com/131177
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2018-09-13 16:21:55 +00:00
Iskander Sharipov 9c2be4c22d bytes: remove bootstrap array from Buffer 
Rationale: small buffer optimization does not work and it has
made things slower since 2014. Until we can make it work,
we should prefer simpler code that also turns out to be more
efficient.

With this change, it's possible to use
NewBuffer(make([]byte, 0, bootstrapSize)) to get the desired
stack-allocated initial buffer since escape analysis can
prove the created slice to be non-escaping.

New implementation key points:

    - Zero value bytes.Buffer performs better than before
    - You can have a truly stack-allocated buffer, and it's not even limited to 64 bytes
    - The unsafe.Sizeof(bytes.Buffer{}) is reduced significantly
    - Empty writes don't cause allocations

Buffer benchmarks from bytes package:

    name                       old time/op    new time/op    delta
    ReadString-8                 9.20µs ± 1%    9.22µs ± 1%     ~     (p=0.148 n=10+10)
    WriteByte-8                  28.1µs ± 0%    26.2µs ± 0%   -6.78%  (p=0.000 n=10+10)
    WriteRune-8                  64.9µs ± 0%    65.0µs ± 0%   +0.16%  (p=0.000 n=10+10)
    BufferNotEmptyWriteRead-8     469µs ± 0%     461µs ± 0%   -1.76%  (p=0.000 n=9+10)
    BufferFullSmallReads-8        108µs ± 0%     108µs ± 0%   -0.21%  (p=0.000 n=10+10)

    name                       old speed      new speed      delta
    ReadString-8               3.56GB/s ± 1%  3.55GB/s ± 1%     ~     (p=0.165 n=10+10)
    WriteByte-8                 146MB/s ± 0%   156MB/s ± 0%   +7.26%  (p=0.000 n=9+10)
    WriteRune-8                 189MB/s ± 0%   189MB/s ± 0%   -0.16%  (p=0.000 n=10+10)

    name                       old alloc/op   new alloc/op   delta
    ReadString-8                 32.8kB ± 0%    32.8kB ± 0%     ~     (all equal)
    WriteByte-8                   0.00B          0.00B          ~     (all equal)
    WriteRune-8                   0.00B          0.00B          ~     (all equal)
    BufferNotEmptyWriteRead-8    4.72kB ± 0%    4.67kB ± 0%   -1.02%  (p=0.000 n=10+10)
    BufferFullSmallReads-8       3.44kB ± 0%    3.33kB ± 0%   -3.26%  (p=0.000 n=10+10)

    name                       old allocs/op  new allocs/op  delta
    ReadString-8                   1.00 ± 0%      1.00 ± 0%     ~     (all equal)
    WriteByte-8                    0.00           0.00          ~     (all equal)
    WriteRune-8                    0.00           0.00          ~     (all equal)
    BufferNotEmptyWriteRead-8      3.00 ± 0%      3.00 ± 0%     ~     (all equal)
    BufferFullSmallReads-8         3.00 ± 0%      2.00 ± 0%  -33.33%  (p=0.000 n=10+10)

The most notable thing in go1 benchmarks is reduced allocs in HTTPClientServer (-1 alloc):

    HTTPClientServer-8           64.0 ± 0%      63.0 ± 0%  -1.56%  (p=0.000 n=10+10)

For more explanations and benchmarks see the referenced issue.

Updates #7921

Change-Id: Ica0bf85e1b70fb4f5dc4f6a61045e2cf4ef72aa3
Reviewed-on: https://go-review.googlesource.com/133715
Reviewed-by: Martin Möhrmann <moehrmann@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2018-09-06 19:33:18 +00:00
Erin Masatsugu 5e755e9d6d bytes: add example for Buffer.Len 
Change-Id: Ide50aba940727a7b32cd33dea5315050f1a34717
Reviewed-on: https://go-review.googlesource.com/132237
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2018-08-30 19:10:14 +00:00
Alberto Donizetti c64006ab5d bytes: note that NewBuffer's initial size can change 
bytes.NewBuffer's documentation says it can be used to set the initial
size of the buffer. The current wording is:

> It can also be used to size the internal buffer for writing.

This may led users to believe that the buffer (its backing array) is
fixed in size and won't grow, which isn't true (subsequent Write calls
will expand the backing array as needed).

Change the doc to make it clearer that NewBuffer just sets the initial
size of the buffer.

Fixes #27242

Change-Id: I2a8cb5bee02ca2c1657ef59e2cf1434c7a9bd397
Reviewed-on: https://go-review.googlesource.com/132035
Reviewed-by: Dominik Honnef <dominik@honnef.co>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2018-08-29 22:36:49 +00:00
Kazuhiro Sera ad644d2e86 all: fix typos detected by github.com/client9/misspell 
Change-Id: Iadb3c5de8ae9ea45855013997ed70f7929a88661
GitHub-Last-Rev: ae85bcf82b
GitHub-Pull-Request: golang/go#26920
Reviewed-on: https://go-review.googlesource.com/128955
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
 2018-08-23 15:54:07 +00:00
Johan Brandhorst 841a9136b3 strings, bytes: avoid unnecessary function literals 
A number of explicit function literals found through the
unlambda linter are removed.

Fixes #26802

Change-Id: I0b122bdd95e9cb804c77efe20483fdf681c8154e
Reviewed-on: https://go-review.googlesource.com/127756
Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
 2018-08-22 16:09:06 +00:00
bill_ofarrell a5f8128e39 bytes, strings: fix comparison of long byte slices on s390x 
The existing implementation of bytes.Compare on s390x doesn't work properly for slices longer
than 256 elements. This change fixes that. Added tests for long strings and slices of bytes.

Fixes #26114

Change-Id: If6d8b68ee6dbcf99a24f867a1d3438b1f208954f
Reviewed-on: https://go-review.googlesource.com/121495
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
 2018-06-29 20:48:07 +00:00
Dave Russell 23b687eccb bytes: re-slice buffer to its previous length after call to grow() 
Fixes #25435

The added test fails without the re-slice and passes with it.

Change-Id: I5ebc2a737285eb116ecc5938d8bf49050652830f
GitHub-Last-Rev: 454ddad7df
GitHub-Pull-Request: golang/go#25436
Reviewed-on: https://go-review.googlesource.com/113495
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
 2018-05-29 19:46:33 +00:00
Eric Pauley 9d11c63b64 bytes, strings: improve EqualFold fast version for ASCII 
The existing implementation only considers the special ASCII
case when the lower character is an upper case letter. This
means that most ASCII comparisons use unicode.SimpleFold even
when it is not necessary.

benchmark                old ns/op     new ns/op     delta
BenchmarkEqualFold-8     450           390           -13.33%

Change-Id: I735ca3c30fc0145c186d2a54f31fd39caab2c3fa
Reviewed-on: https://go-review.googlesource.com/110018
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2018-05-01 18:52:19 +00:00
Keith Randall ee58eccc56 internal/bytealg: move short string Index implementations into bytealg 
Also move the arm64 CountByte implementation while we're here.

Fixes #19792

Change-Id: I1e0fdf1e03e3135af84150a2703b58dad1b0d57e
Reviewed-on: https://go-review.googlesource.com/98518
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
 2018-03-04 19:49:44 +00:00