internal/profile: use internal/lazyregexp for the legacy parser

Per benchinit, this makes a big difference to init times:

	name             old time/op    new time/op    delta
	InternalProfile     185µs ± 1%       6µs ± 1%  -96.51%  (p=0.008 n=5+5)

	name             old alloc/op   new alloc/op   delta
	InternalProfile     101kB ± 0%       4kB ± 0%  -95.72%  (p=0.008 n=5+5)

	name             old allocs/op  new allocs/op  delta
	InternalProfile       758 ± 0%        25 ± 0%  -96.70%  (p=0.008 n=5+5)

The fixed 0.2ms init cost is saved for any importer of net/http/pprof,
but also for cmd/compile, as it supports PGO now.
A Go program parsing profiles might not even need to compile these
regular expressions at all, if it doesn't encounter any legacy files.
I suspect this will be the case with most invocations of cmd/compile.

Updates #26775.

Change-Id: I8374dc64459f0b6bb09bbdf9d0b6c55d7ae1646e
Reviewed-on: https://go-review.googlesource.com/c/go/+/460545
Reviewed-by: Michael Pratt <mpratt@google.com>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
Reviewed-by: Cherry Mui <cherryyz@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 08452c7b1d27f49820ac47a5daf8e3666a8df784..23e0dee1d2f28c302c0367e102495f708dcf95f3 100644 (file)
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -520,7 +520,7 @@ var depsRules = `
        FMT, compress/gzip, encoding/binary, text/tabwriter
        < runtime/pprof;
 
-       OS, compress/gzip, regexp
+       OS, compress/gzip, internal/lazyregexp
        < internal/profile;
 
        html, internal/profile, net/http, runtime/pprof, runtime/trace

diff --git a/src/internal/profile/legacy_profile.go b/src/internal/profile/legacy_profile.go
index b102c95904deaf29f1bd68611dd5b75920ff4a79..373a6c04cab1d1f3fd0d8f506d23b4fdd2670993 100644 (file)
--- a/src/internal/profile/legacy_profile.go
+++ b/src/internal/profile/legacy_profile.go
@@ -11,34 +11,34 @@ import (
        "bufio"
        "bytes"
        "fmt"
+       "internal/lazyregexp"
        "io"
        "math"
-       "regexp"
        "strconv"
        "strings"
 )
 
 var (
-       countStartRE = regexp.MustCompile(`\A(\w+) profile: total \d+\n\z`)
-       countRE      = regexp.MustCompile(`\A(\d+) @(( 0x[0-9a-f]+)+)\n\z`)
+       countStartRE = lazyregexp.New(`\A(\w+) profile: total \d+\n\z`)
+       countRE      = lazyregexp.New(`\A(\d+) @(( 0x[0-9a-f]+)+)\n\z`)
 
-       heapHeaderRE = regexp.MustCompile(`heap profile: *(\d+): *(\d+) *\[ *(\d+): *(\d+) *\] *@ *(heap[_a-z0-9]*)/?(\d*)`)
-       heapSampleRE = regexp.MustCompile(`(-?\d+): *(-?\d+) *\[ *(\d+): *(\d+) *] @([ x0-9a-f]*)`)
+       heapHeaderRE = lazyregexp.New(`heap profile: *(\d+): *(\d+) *\[ *(\d+): *(\d+) *\] *@ *(heap[_a-z0-9]*)/?(\d*)`)
+       heapSampleRE = lazyregexp.New(`(-?\d+): *(-?\d+) *\[ *(\d+): *(\d+) *] @([ x0-9a-f]*)`)
 
-       contentionSampleRE = regexp.MustCompile(`(\d+) *(\d+) @([ x0-9a-f]*)`)
+       contentionSampleRE = lazyregexp.New(`(\d+) *(\d+) @([ x0-9a-f]*)`)
 
-       hexNumberRE = regexp.MustCompile(`0x[0-9a-f]+`)
+       hexNumberRE = lazyregexp.New(`0x[0-9a-f]+`)
 
-       growthHeaderRE = regexp.MustCompile(`heap profile: *(\d+): *(\d+) *\[ *(\d+): *(\d+) *\] @ growthz`)
+       growthHeaderRE = lazyregexp.New(`heap profile: *(\d+): *(\d+) *\[ *(\d+): *(\d+) *\] @ growthz`)
 
-       fragmentationHeaderRE = regexp.MustCompile(`heap profile: *(\d+): *(\d+) *\[ *(\d+): *(\d+) *\] @ fragmentationz`)
+       fragmentationHeaderRE = lazyregexp.New(`heap profile: *(\d+): *(\d+) *\[ *(\d+): *(\d+) *\] @ fragmentationz`)
 
-       threadzStartRE = regexp.MustCompile(`--- threadz \d+ ---`)
-       threadStartRE  = regexp.MustCompile(`--- Thread ([[:xdigit:]]+) \(name: (.*)/(\d+)\) stack: ---`)
+       threadzStartRE = lazyregexp.New(`--- threadz \d+ ---`)
+       threadStartRE  = lazyregexp.New(`--- Thread ([[:xdigit:]]+) \(name: (.*)/(\d+)\) stack: ---`)
 
-       procMapsRE = regexp.MustCompile(`([[:xdigit:]]+)-([[:xdigit:]]+)\s+([-rwxp]+)\s+([[:xdigit:]]+)\s+([[:xdigit:]]+):([[:xdigit:]]+)\s+([[:digit:]]+)\s*(\S+)?`)
+       procMapsRE = lazyregexp.New(`([[:xdigit:]]+)-([[:xdigit:]]+)\s+([-rwxp]+)\s+([[:xdigit:]]+)\s+([[:xdigit:]]+):([[:xdigit:]]+)\s+([[:digit:]]+)\s*(\S+)?`)
 
-       briefMapsRE = regexp.MustCompile(`\s*([[:xdigit:]]+)-([[:xdigit:]]+):\s*(\S+)(\s.*@)?([[:xdigit:]]+)?`)
+       briefMapsRE = lazyregexp.New(`\s*([[:xdigit:]]+)-([[:xdigit:]]+):\s*(\S+)(\s.*@)?([[:xdigit:]]+)?`)
 
        // LegacyHeapAllocated instructs the heapz parsers to use the
        // allocated memory stats instead of the default in-use memory. Note

diff --git a/src/internal/profile/profile.go b/src/internal/profile/profile.go
index 29568aa4b5f7b4593fc1316257eb0d71dd331496..c779bb2b11364d25e8681cebf9adca3ac016c9e8 100644 (file)
--- a/src/internal/profile/profile.go
+++ b/src/internal/profile/profile.go
@@ -11,8 +11,8 @@ import (
        "bytes"
        "compress/gzip"
        "fmt"
+       "internal/lazyregexp"
        "io"
-       "regexp"
        "strings"
        "time"
 )
@@ -192,7 +192,7 @@ func parseUncompressed(data []byte) (*Profile, error) {
        return p, nil
 }
 
-var libRx = regexp.MustCompile(`([.]so$|[.]so[._][0-9]+)`)
+var libRx = lazyregexp.New(`([.]so$|[.]so[._][0-9]+)`)
 
 // setMain scans Mapping entries and guesses which entry is main
 // because legacy profiles don't obey the convention of putting main