qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-18 15:34:53 -07:00
Code Releases Activity
53,947 Commits 58 Branches 402 Tags 522 MiB
76c94eb706
Commit Graph

169 Commits

Author SHA1 Message Date
cuiweixie
2a627afe13 bytes: simplify code using unsafe.SliceData 
Updates #54854

Change-Id: I9c14f9fa595f73eae44eb714abc5d486915893c1
Reviewed-on: https://go-review.googlesource.com/c/go/+/428155
Reviewed-by: Ian Lance Taylor <iant@google.com>
Reviewed-by: Bryan Mills <bcmills@google.com>
Run-TryBot: Ian Lance Taylor <iant@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Auto-Submit: Ian Lance Taylor <iant@google.com>
 2022-09-07 01:33:52 +00:00
Joe Tsai
70de482d17 bytes: rely on utf8.AppendRune 
This is both simpler and more performant.

WriteRune                                 23.9µs ± 1%   22.8µs ± 8%   -4.43%  (p=0.006 n=8+10)
ToUpper/longɐstringɐwithɐnonasciiⱯchars    573ns ± 4%    474ns ± 6%  -17.27%  (p=0.000 n=10+10)
ToUpper/ɐɐɐɐɐ                              236ns ± 6%    202ns ± 5%  -14.12%  (p=0.000 n=10+10)
ToUpper/a\u0080\U0010ffff                 98.8ns ± 6%   91.2ns ± 3%   -7.67%  (p=0.000 n=10+10)
ToLower/LONGⱯSTRINGⱯWITHⱯNONASCIIⱯCHARS    511ns ± 3%    409ns ± 4%  -20.02%  (p=0.000 n=10+10)
ToLower/ⱭⱭⱭⱭⱭ                              178ns ± 4%    173ns ± 2%   -2.76%  (p=0.005 n=10+10)
ToLower/A\u0080\U0010ffff                  100ns ± 3%     91ns ± 2%   -8.55%  (p=0.000 n=10+10)

Change-Id: I968ef194da2c115cbdcac2d3575c34c65e6a8a56
Reviewed-on: https://go-review.googlesource.com/c/go/+/412337
Reviewed-by: Ian Lance Taylor <iant@google.com>
Auto-Submit: Joseph Tsai <joetsai@digital-static.net>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Run-TryBot: Joseph Tsai <joetsai@digital-static.net>
 2022-08-23 20:26:47 +00:00
Michal Bohuslávek
5f0170f9a5 bytes, strings: s/after/before/ in CutSuffix 
This follows on CL 407176 which added this function (in both
packages). This CL makes it consistent with the Cut function,
which uses “before” and “after” in return variable names.

Change-Id: Id4345d2fe0f50bf301a880803e87bf356986b518
Reviewed-on: https://go-review.googlesource.com/c/go/+/424922
Run-TryBot: Robert Griesemer <gri@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Auto-Submit: Robert Griesemer <gri@google.com>
Reviewed-by: Ian Lance Taylor <iant@google.com>
 2022-08-19 20:56:43 +00:00
Changkun Ou
68005592b3 strings, bytes: add CutPrefix and CutSuffix 
Fixes #42537

Change-Id: Ie03c2614ffee30ebe707acad6b9f6c28fb134a45
Reviewed-on: https://go-review.googlesource.com/c/go/+/407176
Reviewed-by: Benny Siegert <bsiegert@gmail.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Changkun Ou <mail@changkun.de>
Reviewed-by: Ian Lance Taylor <iant@google.com>
 2022-08-16 19:48:39 +00:00
Martin Möhrmann
7b45edb450 bytes: add Clone function 
The new Clone function returns a copy of b[:len(b)]
for the input byte slice b.
The result may have additional unused capacity.
Clone(nil) returns nil.

Fixes #45038

Change-Id: I0469a202d77a7b491f1341c08915d07ddd1f0300
Reviewed-on: https://go-review.googlesource.com/c/go/+/359675
Run-TryBot: Martin Möhrmann <martin@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Joseph Tsai <joetsai@digital-static.net>
Reviewed-by: Martin Möhrmann <moehrmann@google.com>
Reviewed-by: Ian Lance Taylor <iant@google.com>
 2022-08-15 19:17:20 +00:00
Joe Tsai
9a4685f220 strings: avoid utf8.RuneError mangling in Split 
Split should only split strings and not perform mangling
of invalid UTF-8 into ut8.RuneError.
The prior behavior is clearly a bug since mangling is not
performed in all other situations (e.g., separator is non-empty).

Fixes #53511

Change-Id: I112a2ef15ee46ddecda015ee14bca04cd76adfbf
Reviewed-on: https://go-review.googlesource.com/c/go/+/413715
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Ian Lance Taylor <iant@google.com>
Run-TryBot: Ian Lance Taylor <iant@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
 2022-08-08 20:44:51 +00:00
Muhammed Can Küçükaslan
ceefd3a37b bytes: document that Reader.Reset affects the result of Size 
The Reader.Reset changes the underlying byte slice, so it actually
changes the return value of the Size method.

Fixes #54018

Change-Id: I160deaa2244e95cb93303cb5dfb67a8d90a375ef
GitHub-Last-Rev: b04724a072
GitHub-Pull-Request: golang/go#54020
Reviewed-on: https://go-review.googlesource.com/c/go/+/419237
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Joseph Tsai <joetsai@digital-static.net>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@google.com>
Run-TryBot: Ian Lance Taylor <iant@google.com>
Auto-Submit: Ian Lance Taylor <iant@google.com>
 2022-07-26 14:20:34 +00:00
Archana R
7ca1e2aa56 internal/bytealg: optimize index function for ppc64le/power9 
Optimized index2to16 loop by unrolling the loop by 4.
Multiple benchmark tests show performance improvement on
POWER9. Similar improvements are seen on POWER10. Added
tests to ensure changes work fine.

name            old time/op   new time/op    delta
Index/10         18.3ns ± 0%    19.7ns ±25%     ~
Index/32         75.3ns ± 0%    69.2ns ± 0%   -8.22%
Index/4K         5.53µs ± 0%    3.69µs ± 0%  -33.20%
Index/4M         5.64ms ± 0%    3.75ms ± 0%  -33.55%
Index/64M        92.9ms ± 0%    61.6ms ± 0%  -33.69%
IndexHard2       1.41ms ± 0%    0.93ms ± 0%  -33.75%
CountHard2       1.41ms ± 0%    0.93ms ± 0%  -33.75%

Change-Id: If9331df6a141a4716724b8cb648d2b91bdf17e5f
Reviewed-on: https://go-review.googlesource.com/c/go/+/377016
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Paul Murphy <murp@ibm.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Archana Ravindar <aravind5@in.ibm.com>
 2022-05-09 12:02:02 +00:00
Philippe Antoine
5e4543c29f bytes: explode checks for n too large 
As is already done in strings package.

Change-Id: Ia45e6443ddf6beac5e70a1cc493119030e173139
GitHub-Last-Rev: 1174c25035
GitHub-Pull-Request: golang/go#52348
Reviewed-on: https://go-review.googlesource.com/c/go/+/400239
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@google.com>
Auto-Submit: Ian Lance Taylor <iant@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
 2022-04-16 02:01:19 +00:00
Russ Cox
19309779ac all: gofmt main repo 
[This CL is part of a sequence implementing the proposal #51082.
The design doc is at https://go.dev/s/godocfmt-design.]

Run the updated gofmt, which reformats doc comments,
on the main repository. Vendored files are excluded.

For #51082.

Change-Id: I7332f099b60f716295fb34719c98c04eb1a85407
Reviewed-on: https://go-review.googlesource.com/c/go/+/384268
Reviewed-by: Jonathan Amsterdam <jba@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2022-04-11 16:34:30 +00:00
hopehook
c451a02a6d strings, bytes: improve the description of simple case-folding in EqualFold 
This CL removes the problem description pointed out by @bjkail.
Second, synchronously modify the comments of the bytes package.

Updates #52022
Fixes #52204

Change-Id: I0aa52c774f40bb91f32bebdd2a62a11067a77be0
Reviewed-on: https://go-review.googlesource.com/c/go/+/398736
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Auto-Submit: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
Trust: Cherry Mui <cherryyz@google.com>
 2022-04-07 23:06:24 +00:00
Philippe Antoine
5bb2628c6f bytes: limit allocation in SplitN 
So that bytes.SplitN("", "T", int(144115188075855872)) does not panic.

Change-Id: I7c068852bd708416164fc2ed8b84cf6b2d593666
GitHub-Last-Rev: f8df09d65e
GitHub-Pull-Request: golang/go#52147
Reviewed-on: https://go-review.googlesource.com/c/go/+/398076
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: mzh <mzh@golangcn.org>
 2022-04-06 03:13:34 +00:00
Ian Lance Taylor
32fdad19a2 bytes: restore old Trim/TrimLeft behavior for nil 
Keep returning nil for the cases where we historically returned nil,
even though this is slightly different for TrimLeft and TrimRight.

Fixes #51793

Change-Id: Ifbdfc6b09d52b8e063cfe6341019f9b2eb8b70e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/393876
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
 2022-03-28 22:06:49 +00:00
Joe Tsai
2d026a4ea5 bytes: rely on runtime.growslice for growing 
Rather than naively making a slice of capacity 2*c+n,
rely on the append(..., make(...)) pattern to allocate a
slice that aligns up to the closest size class.

Performance:
	name                          old time/op    new time/op    delta
	BufferWriteBlock/N4096       3.03µs ± 6%    2.04µs ± 6%  -32.60%  (p=0.000 n=10+10)
	BufferWriteBlock/N65536      47.8µs ± 6%    28.1µs ± 2%  -41.32%  (p=0.000 n=9+8)
	BufferWriteBlock/N1048576     844µs ± 7%     510µs ± 5%  -39.59%  (p=0.000 n=8+9)

	name                          old alloc/op   new alloc/op   delta
	BufferWriteBlock/N4096       12.3kB ± 0%     7.2kB ± 0%  -41.67%  (p=0.000 n=10+10)
	BufferWriteBlock/N65536       258kB ± 0%     130kB ± 0%  -49.60%  (p=0.000 n=10+10)
	BufferWriteBlock/N1048576    4.19MB ± 0%    2.10MB ± 0%  -49.98%  (p=0.000 n=10+8)

	name                          old allocs/op  new allocs/op  delta
	BufferWriteBlock/N4096         3.00 ± 0%      3.00 ± 0%     ~     (all equal)
	BufferWriteBlock/N65536        7.00 ± 0%      7.00 ± 0%     ~     (all equal)
	BufferWriteBlock/N1048576      11.0 ± 0%      11.0 ± 0%     ~     (all equal)

The performance is faster since the growth rate is capped at 2x,
while previously it could grow by amounts potentially much greater than 2x,
leading to significant amounts of memory waste and extra copying.

Credit goes to Martin Möhrmann for suggesting the
append(b, make([]T, n)...) pattern.

Fixes #42984
Updates #51462

Change-Id: I7b23f75dddbf53f8b8b93485bb1a1fff9649b96b
Reviewed-on: https://go-review.googlesource.com/c/go/+/349994
Trust: Joseph Tsai <joetsai@digital-static.net>
Trust: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Bryan Mills <bcmills@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
 2022-03-10 16:24:16 +00:00
Ian Lance Taylor
540632841e bytes, strings: mention Cut in docs for Split and SplitN 
For #46336

Change-Id: Idc23302085e14e24d571f5995d6d33ca964a0021
Reviewed-on: https://go-review.googlesource.com/c/go/+/382954
Trust: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
 2022-02-08 22:25:54 +00:00
Russ Cox
2580d0e08d all: gofmt -w -r 'interface{} -> any' src 
And then revert the bootstrap cmd directories and certain testdata.
And adjust tests as needed.

Not reverting the changes in std that are bootstrapped,
because some of those changes would appear in API docs,
and we want to use any consistently.
Instead, rewrite 'any' to 'interface{}' in cmd/dist for those directories
when preparing the bootstrap copy.

A few files changed as a result of running gofmt -w
not because of interface{} -> any but because they
hadn't been updated for the new //go:build lines.

Fixes #49884.

Change-Id: Ie8045cba995f65bd79c694ec77a1b3d1fe01bb09
Reviewed-on: https://go-review.googlesource.com/c/go/+/368254
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
 2021-12-13 18:45:54 +00:00
smasher164
7aed6dd7e1 strings, bytes: deprecate Title 
Title doesn't handle Unicode punctuation and language-specific
capitalization rules. Replace the BUG comment with a Deprecated
one, suggesting a more robust alternative, and allowing Title
to be exposed to tooling.

Fixes #48367.

Change-Id: I952f1f37cd35b587a95893fb022827bdd9ec7de9
Reviewed-on: https://go-review.googlesource.com/c/go/+/359485
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Cherry Mui <cherryyz@google.com>
 2021-11-05 21:27:34 +00:00
jiahua wang
3e9e02412e bytes: add example with (*Buffer).Cap, (*Buffer).Read, (*Buffer).ReadByte 
Change-Id: Ieb107fdfccde9f054491f667a384b16f7af71dea
Reviewed-on: https://go-review.googlesource.com/c/go/+/355289
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Cherry Mui <cherryyz@google.com>
 2021-11-05 21:26:54 +00:00
Paul E. Murphy
4e7dd9fc08 bytes: test for page boundary crosses on sep of Index 
Improve TestIndexNearPageBoundary to verify needles
ending on a page boundary don't cause a segfault.

Change-Id: I2edb13db63a71dc9955e266f6b97026ee13bf76e
Reviewed-on: https://go-review.googlesource.com/c/go/+/356889
Reviewed-by: Cherry Mui <cherryyz@google.com>
Trust: Lynn Boger <laboger@linux.vnet.ibm.com>
 2021-11-02 17:31:50 +00:00
Brad Fitzpatrick
a59e33224e net/netip: add new IP address package 
Co-authored-by: Alex Willmer <alex@moreati.org.uk> (GitHub @moreati)
Co-authored-by: Alexander Yastrebov <yastrebov.alex@gmail.com>
Co-authored-by: David Anderson <dave@natulte.net> (Tailscale CLA)
Co-authored-by: David Crawshaw <crawshaw@tailscale.com> (Tailscale CLA)
Co-authored-by: Dmytro Shynkevych <dmytro@tailscale.com> (Tailscale CLA)
Co-authored-by: Elias Naur <mail@eliasnaur.com>
Co-authored-by: Joe Tsai <joetsai@digital-static.net> (Tailscale CLA)
Co-authored-by: Jonathan Yu <jawnsy@cpan.org> (GitHub @jawnsy)
Co-authored-by: Josh Bleecher Snyder <josharian@gmail.com> (Tailscale CLA)
Co-authored-by: Maisem Ali <maisem@tailscale.com> (Tailscale CLA)
Co-authored-by: Manuel Mendez (Go AUTHORS mmendez534@...)
Co-authored-by: Matt Layher <mdlayher@gmail.com>
Co-authored-by: Noah Treuhaft <noah.treuhaft@gmail.com> (GitHub @nwt)
Co-authored-by: Stefan Majer <stefan.majer@gmail.com>
Co-authored-by: Terin Stock <terinjokes@gmail.com> (Cloudflare CLA)
Co-authored-by: Tobias Klauser <tklauser@distanz.ch>

Fixes #46518

Change-Id: I0041f9e1115d61fa6e95fcf32b01d9faee708712
Reviewed-on: https://go-review.googlesource.com/c/go/+/339309
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>
Trust: Brad Fitzpatrick <bradfitz@golang.org>
 2021-11-02 01:28:01 +00:00
Alexander Melentyev
3fa9ee49a0 bytes: remove redundant type conversion 
Change-Id: Icafb2d9fd11b23d3acaf9df07e7f90d8bcd829fa
GitHub-Last-Rev: 2b76646055
GitHub-Pull-Request: golang/go#49243
Reviewed-on: https://go-review.googlesource.com/c/go/+/360096
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Trust: Brad Fitzpatrick <bradfitz@golang.org>
Trust: Martin Möhrmann <martin@golang.org>
 2021-10-31 17:52:41 +00:00
Russ Cox
f229e7031a all: go fix -fix=buildtag std cmd (except for bootstrap deps, vendor) 
When these packages are released as part of Go 1.18,
Go 1.16 will no longer be supported, so we can remove
the +build tags in these files.

Ran go fix -fix=buildtag std cmd and then reverted the bootstrapDirs
as defined in src/cmd/dist/buildtool.go, which need to continue
to build with Go 1.4 for now.

Also reverted src/vendor and src/cmd/vendor, which will need
to be updated in their own repos first.

Manual changes in runtime/pprof/mprof_test.go to adjust line numbers.

For #41184.

Change-Id: Ic0f93f7091295b6abc76ed5cd6e6746e1280861e
Reviewed-on: https://go-review.googlesource.com/c/go/+/344955
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Bryan C. Mills <bcmills@google.com>
 2021-10-28 18:17:57 +00:00
kjgorman
3986e5c8e7 bytes: fix Cut godoc typo 
If sep does not appear in s, we return nil here
rather than the empty string. Presumably the docs
were copied from the  strings package implementation
and brought that along.

Change-Id: I3706c94fe04abd9e2a2c8840f7cc6116386965c8
Reviewed-on: https://go-review.googlesource.com/c/go/+/354969
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: Alexander Rakoczy <alex@golang.org>
 2021-10-13 16:39:23 +00:00
Carlo Alberto Ferraris
4002616f9a strings,bytes: avoid allocations in Trim/TrimLeft/TrimRight 
There is evidence that the vast majority of uses for Trim* involve
cutsets with a single ASCII character, and the vast majority of
remaining uses involve cutsets with a small (<4) ASCII characters.
For this reason it makes sense to provide better fast paths for these
common cases.

Furthermore the current implementation needlessly allocates for unclear
benefits. This CL also replaces all paths to avoid allocations and, as
a side effect, it speeds up also the slow path.

strings:
name                    old time/op    new time/op    delta
Trim                      1.71µs ± 1%    0.70µs ± 0%   -58.93%  (p=0.008 n=5+5)
TrimASCII/1:1             6.43ns ± 0%    6.34ns ± 0%    -1.41%  (p=0.008 n=5+5)
TrimASCII/1:2             97.3ns ± 0%    18.2ns ± 1%   -81.34%  (p=0.008 n=5+5)
TrimASCII/1:4              101ns ± 0%      21ns ± 0%   -78.77%  (p=0.008 n=5+5)
TrimASCII/1:8              109ns ± 0%      29ns ± 0%   -73.60%  (p=0.008 n=5+5)
TrimASCII/1:16             124ns ± 0%      43ns ± 0%   -65.16%  (p=0.008 n=5+5)
TrimASCII/16:1            19.8ns ± 0%    18.6ns ± 0%    -5.90%  (p=0.008 n=5+5)
TrimASCII/16:2             167ns ± 0%      33ns ± 0%   -80.21%  (p=0.008 n=5+5)
TrimASCII/16:4             169ns ± 0%      35ns ± 0%   -79.01%  (p=0.008 n=5+5)
TrimASCII/16:8             177ns ± 0%      43ns ± 0%   -75.88%  (p=0.008 n=5+5)
TrimASCII/16:16            193ns ± 2%      57ns ± 1%   -70.30%  (p=0.008 n=5+5)
TrimASCII/256:1            232ns ± 0%     232ns ± 0%      ~     (p=1.000 n=5+5)
TrimASCII/256:2           1.28µs ± 1%    0.26µs ± 0%   -79.46%  (p=0.008 n=5+5)
TrimASCII/256:4           1.27µs ± 0%    0.27µs ± 0%   -78.95%  (p=0.008 n=5+5)
TrimASCII/256:8           1.28µs ± 0%    0.28µs ± 1%   -78.28%  (p=0.008 n=5+5)
TrimASCII/256:16          1.30µs ± 1%    0.29µs ± 0%   -77.49%  (p=0.008 n=5+5)
TrimASCII/4096:1          3.47µs ± 0%    3.47µs ± 0%    -0.14%  (p=0.008 n=5+5)
TrimASCII/4096:2          18.2µs ± 0%     3.9µs ± 0%   -78.53%  (p=0.008 n=5+5)
TrimASCII/4096:4          18.2µs ± 0%     3.9µs ± 0%   -78.55%  (p=0.008 n=5+5)
TrimASCII/4096:8          18.2µs ± 0%     3.9µs ± 0%   -78.49%  (p=0.008 n=5+5)
TrimASCII/4096:16         18.3µs ± 0%     3.9µs ± 0%   -78.44%  (p=0.008 n=5+5)
TrimByte                  10.6ns ± 1%    10.1ns ± 0%    -5.01%  (p=0.008 n=5+5)
TrimSpace/NoTrim          5.90ns ± 0%    5.89ns ± 0%      ~     (p=0.135 n=5+5)
TrimSpace/ASCII           10.6ns ± 0%     9.9ns ± 0%    -6.21%  (p=0.008 n=5+5)
TrimSpace/SomeNonASCII     127ns ± 0%     126ns ± 0%    -0.96%  (p=0.008 n=5+5)
TrimSpace/JustNonASCII     178ns ± 0%     178ns ± 0%      ~     (p=0.825 n=5+4)

name                    old alloc/op   new alloc/op   delta
Trim                        456B ± 0%        0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:1              0.00B          0.00B           ~     (all equal)
TrimASCII/1:2              48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:4              48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:8              48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:16             48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:1             0.00B          0.00B           ~     (all equal)
TrimASCII/16:2             48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:4             48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:8             48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:16            48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:1            0.00B          0.00B           ~     (all equal)
TrimASCII/256:2            48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:4            48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:8            48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:16           48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:1           0.00B          0.00B           ~     (all equal)
TrimASCII/4096:2           48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:4           48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:8           48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:16          48.0B ± 0%      0.0B           ~     (p=0.079 n=4+5)
TrimByte                   0.00B          0.00B           ~     (all equal)
TrimSpace/NoTrim           0.00B          0.00B           ~     (all equal)
TrimSpace/ASCII            0.00B          0.00B           ~     (all equal)
TrimSpace/SomeNonASCII     0.00B          0.00B           ~     (all equal)
TrimSpace/JustNonASCII     0.00B          0.00B           ~     (all equal)

name                    old allocs/op  new allocs/op  delta
Trim                        18.0 ± 0%       0.0       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:1               0.00           0.00           ~     (all equal)
TrimASCII/1:2               2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:4               2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:8               2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:16              2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:1              0.00           0.00           ~     (all equal)
TrimASCII/16:2              2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:4              2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:8              2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:16             2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:1             0.00           0.00           ~     (all equal)
TrimASCII/256:2             2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:4             2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:8             2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:16            2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:1            0.00           0.00           ~     (all equal)
TrimASCII/4096:2            2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:4            2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:8            2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:16           2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimByte                    0.00           0.00           ~     (all equal)
TrimSpace/NoTrim            0.00           0.00           ~     (all equal)
TrimSpace/ASCII             0.00           0.00           ~     (all equal)
TrimSpace/SomeNonASCII      0.00           0.00           ~     (all equal)
TrimSpace/JustNonASCII      0.00           0.00           ~     (all equal)

bytes:
name                    old time/op    new time/op    delta
TrimSpace/NoTrim          5.89ns ± 0%    5.91ns ± 0%      ~     (p=0.095 n=5+4)
TrimSpace/ASCII           10.3ns ± 1%    10.2ns ± 0%      ~     (p=0.095 n=5+5)
TrimSpace/SomeNonASCII     120ns ± 1%     121ns ± 0%    +1.13%  (p=0.008 n=5+5)
TrimSpace/JustNonASCII     194ns ± 1%     195ns ± 0%      ~     (p=0.143 n=5+5)
TrimASCII/1:1             6.28ns ± 0%    5.95ns ± 0%    -5.26%  (p=0.008 n=5+5)
TrimASCII/1:2             95.8ns ± 1%    18.6ns ± 0%   -80.63%  (p=0.008 n=5+5)
TrimASCII/1:4             98.8ns ± 0%    22.1ns ± 0%   -77.62%  (p=0.008 n=5+5)
TrimASCII/1:8              107ns ± 0%      29ns ± 0%   -72.72%  (p=0.008 n=5+5)
TrimASCII/1:16             123ns ± 0%      44ns ± 1%   -64.30%  (p=0.008 n=5+5)
TrimASCII/16:1            13.2ns ± 0%    12.8ns ± 1%    -2.75%  (p=0.008 n=5+5)
TrimASCII/16:2             169ns ± 0%      33ns ± 0%   -80.33%  (p=0.008 n=5+5)
TrimASCII/16:4             173ns ± 0%      36ns ± 0%   -79.31%  (p=0.008 n=5+5)
TrimASCII/16:8             180ns ± 0%      43ns ± 0%   -76.02%  (p=0.008 n=5+5)
TrimASCII/16:16            197ns ± 2%      58ns ± 0%   -70.73%  (p=0.008 n=5+5)
TrimASCII/256:1            137ns ± 1%     136ns ± 0%    -0.82%  (p=0.016 n=5+5)
TrimASCII/256:2           1.40µs ± 0%    0.26µs ± 0%   -81.02%  (p=0.008 n=5+5)
TrimASCII/256:4           1.40µs ± 0%    0.27µs ± 0%   -80.83%  (p=0.008 n=5+5)
TrimASCII/256:8           1.41µs ± 0%    0.28µs ± 0%   -80.36%  (p=0.008 n=5+5)
TrimASCII/256:16          1.42µs ± 0%    0.29µs ± 0%   -79.48%  (p=0.008 n=5+5)
TrimASCII/4096:1          1.75µs ± 0%    1.75µs ± 0%      ~     (p=0.595 n=5+5)
TrimASCII/4096:2          20.9µs ± 0%     3.9µs ± 0%   -81.29%  (p=0.008 n=5+5)
TrimASCII/4096:4          20.9µs ± 0%     3.9µs ± 0%   -81.27%  (p=0.008 n=5+5)
TrimASCII/4096:8          20.9µs ± 0%     3.9µs ± 0%   -81.22%  (p=0.008 n=5+5)
TrimASCII/4096:16         20.9µs ± 0%     3.9µs ± 0%   -81.21%  (p=0.008 n=5+5)
TrimByte                  9.21ns ± 0%    9.30ns ± 0%    +0.91%  (p=0.008 n=5+5)

name                    old alloc/op   new alloc/op   delta
TrimSpace/NoTrim           0.00B          0.00B           ~     (all equal)
TrimSpace/ASCII            0.00B          0.00B           ~     (all equal)
TrimSpace/SomeNonASCII     0.00B          0.00B           ~     (all equal)
TrimSpace/JustNonASCII     0.00B          0.00B           ~     (all equal)
TrimASCII/1:1              0.00B          0.00B           ~     (all equal)
TrimASCII/1:2              48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:4              48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:8              48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:16             48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:1             0.00B          0.00B           ~     (all equal)
TrimASCII/16:2             48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:4             48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:8             48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:16            48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:1            0.00B          0.00B           ~     (all equal)
TrimASCII/256:2            48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:4            48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:8            48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:16           48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:1           0.00B          0.00B           ~     (all equal)
TrimASCII/4096:2           48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:4           48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:8           48.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:16          49.0B ± 0%      0.0B       -100.00%  (p=0.008 n=5+5)
TrimByte                   0.00B          0.00B           ~     (all equal)

name                    old allocs/op  new allocs/op  delta
TrimSpace/NoTrim            0.00           0.00           ~     (all equal)
TrimSpace/ASCII             0.00           0.00           ~     (all equal)
TrimSpace/SomeNonASCII      0.00           0.00           ~     (all equal)
TrimSpace/JustNonASCII      0.00           0.00           ~     (all equal)
TrimASCII/1:1               0.00           0.00           ~     (all equal)
TrimASCII/1:2               2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:4               2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:8               2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/1:16              2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:1              0.00           0.00           ~     (all equal)
TrimASCII/16:2              2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:4              2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:8              2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/16:16             2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:1             0.00           0.00           ~     (all equal)
TrimASCII/256:2             2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:4             2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:8             2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/256:16            2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:1            0.00           0.00           ~     (all equal)
TrimASCII/4096:2            2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:4            2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:8            2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimASCII/4096:16           2.00 ± 0%      0.00       -100.00%  (p=0.008 n=5+5)
TrimByte                    0.00           0.00           ~     (all equal)

Fixes #46446

Change-Id: I9537c86f888af6285027f67bda4a97aeedb41d4a
Reviewed-on: https://go-review.googlesource.com/c/go/+/332771
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Joe Tsai <joetsai@digital-static.net>
Trust: Joe Tsai <joetsai@digital-static.net>
Trust: Than McIntosh <thanm@google.com>
 2021-10-06 22:42:28 +00:00
Russ Cox
8e36ab0551 bytes, strings: add Cut 
Using Cut is a clearer way to write the vast majority (>70%)
of existing code that calls Index, IndexByte, IndexRune, and SplitN.
There is more discussion on https://golang.org/issue/46336.

Fixes #46336.

Change-Id: Ia418ed7c3706c65bf61e1b2c5baf534cb783e4d3
Reviewed-on: https://go-review.googlesource.com/c/go/+/351710
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
 2021-10-06 15:53:00 +00:00
jiahua wang
078247a407 bytes: add example for (*Buffer).Next 
Change-Id: Ic0a97fd7bb89865448e436e5c092415a29d8badf
Reviewed-on: https://go-review.googlesource.com/c/go/+/352009
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Trust: David Chase <drchase@google.com>
 2021-09-27 16:30:23 +00:00
Joe Tsai
5baf60d472 bytes, strings: optimize Trim for single byte cutsets 
Using the latest version of all modules known by the module proxy,
we determine that for all Trim usages (and related functionality):
* 76.6% have cutsets of len=1, and
* 13.4% have cutsets of len=2.

Given that a vast majority of usages only have a cutset of len=1,
we should more heavily optimize for that situation.
Previously, there was some optimization for cutsets of len=1,
but it's within the internal makeCutsetFunc function.
This is sub-optimal as it incurs an allocation in makeCutsetFunc
for the closure over that single byte.

This CL removes special-casing of one-byte cutsets from makeCutsetFunc
and instead distributes it directly in Trim, TrimRight, and TrimLeft.
Whether we should distribute the entire ASCII cutset logic into Trim
is a future CL that should be discussed and handled separately.
The evidence for multibyte cutsets is not as obviously compelling.

name                old time/op  new time/op  delta
bytes/TrimByte-4    84.1ns ± 2%   7.5ns ± 1%  -91.10%  (p=0.000 n=9+7)
strings/TrimByte-4  86.2ns ± 3%   8.3ns ± 1%  -90.33%  (p=0.000 n=9+10)

Fixes #46446

Change-Id: Ia0e31a8384c3ce111ae35465605bcec45df2ebec
Reviewed-on: https://go-review.googlesource.com/c/go/+/323318
Trust: Joe Tsai <joetsai@digital-static.net>
Run-TryBot: Joe Tsai <joetsai@digital-static.net>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
 2021-08-25 19:29:15 +00:00
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