1. 06 Mar, 2017 8 commits
  2. 05 Mar, 2017 2 commits
  3. 04 Mar, 2017 12 commits
    • Josh Bleecher Snyder's avatar
      cmd/internal/src: cache prefixed filenames · 57e03861
      Josh Bleecher Snyder authored
      CL 37234 introduced string concatenation into some hot code. 
      This CL does that work earlier and caches the result.
      
      Updates #19386
      
      Performance impact vs master:
      
      name       old time/op      new time/op      delta
      Template        223ms ± 5%       216ms ± 5%   -2.98%  (p=0.001 n=20+20)
      Unicode        98.7ms ± 4%      99.0ms ± 4%     ~     (p=0.749 n=20+19)
      GoTypes         631ms ± 4%       626ms ± 4%     ~     (p=0.253 n=20+20)
      Compiler        2.91s ± 1%       2.87s ± 3%   -1.11%  (p=0.005 n=18+20)
      SSA             4.48s ± 2%       4.36s ± 2%   -2.77%  (p=0.000 n=20+20)
      Flate           130ms ± 2%       129ms ± 6%     ~     (p=0.428 n=19+20)
      GoParser        160ms ± 4%       157ms ± 3%   -1.62%  (p=0.005 n=20+18)
      Reflect         395ms ± 2%       394ms ± 4%     ~     (p=0.445 n=20+20)
      Tar             120ms ± 5%       118ms ± 6%     ~     (p=0.101 n=19+20)
      XML             224ms ± 3%       223ms ± 3%     ~     (p=0.544 n=19+19)
      
      name       old user-ns/op   new user-ns/op   delta
      Template   291user-ms ± 5%  265user-ms ± 5%   -9.02%  (p=0.000 n=20+19)
      Unicode    140user-ms ± 3%  139user-ms ± 8%     ~     (p=0.904 n=20+20)
      GoTypes    844user-ms ± 3%  849user-ms ± 3%     ~     (p=0.251 n=20+18)
      Compiler   4.06user-s ± 5%  3.98user-s ± 2%     ~     (p=0.056 n=20+20)
      SSA        6.89user-s ± 5%  6.50user-s ± 3%   -5.61%  (p=0.000 n=20+20)
      Flate      164user-ms ± 5%  163user-ms ± 4%     ~     (p=0.365 n=20+19)
      GoParser   206user-ms ± 6%  204user-ms ± 4%     ~     (p=0.534 n=20+18)
      Reflect    501user-ms ± 4%  505user-ms ± 5%     ~     (p=0.383 n=20+20)
      Tar        151user-ms ± 3%  152user-ms ± 7%     ~     (p=0.798 n=17+20)
      XML        283user-ms ± 7%  280user-ms ± 5%     ~     (p=0.301 n=20+20)
      
      name       old alloc/op     new alloc/op     delta
      Template       42.5MB ± 0%      40.2MB ± 0%   -5.59%  (p=0.000 n=20+20)
      Unicode        31.7MB ± 0%      31.0MB ± 0%   -2.19%  (p=0.000 n=20+18)
      GoTypes         124MB ± 0%       117MB ± 0%   -5.90%  (p=0.000 n=20+20)
      Compiler        533MB ± 0%       490MB ± 0%   -8.07%  (p=0.000 n=20+20)
      SSA             989MB ± 0%       893MB ± 0%   -9.74%  (p=0.000 n=20+20)
      Flate          27.8MB ± 0%      26.1MB ± 0%   -5.92%  (p=0.000 n=20+20)
      GoParser       34.3MB ± 0%      32.1MB ± 0%   -6.43%  (p=0.000 n=19+20)
      Reflect        84.6MB ± 0%      81.4MB ± 0%   -3.84%  (p=0.000 n=20+20)
      Tar            28.8MB ± 0%      27.7MB ± 0%   -3.89%  (p=0.000 n=20+20)
      XML            47.2MB ± 0%      44.2MB ± 0%   -6.45%  (p=0.000 n=20+19)
      
      name       old allocs/op    new allocs/op    delta
      Template         420k ± 1%        381k ± 1%   -9.35%  (p=0.000 n=20+20)
      Unicode          338k ± 1%        324k ± 1%   -4.29%  (p=0.000 n=20+19)
      GoTypes         1.28M ± 0%       1.15M ± 0%  -10.30%  (p=0.000 n=20+20)
      Compiler        5.06M ± 0%       4.41M ± 0%  -12.92%  (p=0.000 n=20+20)
      SSA             9.14M ± 0%       7.91M ± 0%  -13.46%  (p=0.000 n=19+20)
      Flate            267k ± 0%        241k ± 1%   -9.53%  (p=0.000 n=20+20)
      GoParser         347k ± 1%        312k ± 0%  -10.15%  (p=0.000 n=19+20)
      Reflect         1.07M ± 0%       1.00M ± 0%   -6.86%  (p=0.000 n=20+20)
      Tar              274k ± 1%        256k ± 1%   -6.73%  (p=0.000 n=20+20)
      XML              448k ± 0%        398k ± 0%  -11.17%  (p=0.000 n=20+18)
      
      
      Performance impact when applied together with CL 37234
      atop CL 37234's parent commit (i.e. as if it were
      a part of CL 37234), to show that this commit
      makes CL 37234 completely performance-neutral:
      
      name       old time/op      new time/op      delta
      Template        222ms ±14%       222ms ±14%    ~     (p=1.000 n=14+15)
      Unicode         104ms ±18%       106ms ±18%    ~     (p=0.650 n=13+14)
      GoTypes         653ms ± 7%       638ms ± 5%    ~     (p=0.145 n=14+12)
      Compiler        3.10s ± 1%       3.13s ±10%    ~     (p=1.000 n=2+2)
      SSA             4.73s ±11%       4.68s ±11%    ~     (p=0.567 n=15+15)
      Flate           136ms ± 4%       133ms ± 7%    ~     (p=0.231 n=12+14)
      GoParser        163ms ±11%       169ms ±10%    ~     (p=0.352 n=14+14)
      Reflect         415ms ±15%       423ms ±20%    ~     (p=0.715 n=15+14)
      Tar             133ms ±17%       130ms ±23%    ~     (p=0.252 n=14+15)
      XML             236ms ±16%       235ms ±14%    ~     (p=0.874 n=14+14)
      
      name       old user-ns/op   new user-ns/op   delta
      Template   271user-ms ±10%  271user-ms ±10%    ~     (p=0.780 n=14+15)
      Unicode    143user-ms ± 5%  146user-ms ±11%    ~     (p=0.432 n=12+14)
      GoTypes    864user-ms ± 5%  866user-ms ± 9%    ~     (p=0.905 n=14+13)
      Compiler   4.17user-s ± 1%  4.26user-s ± 7%    ~     (p=1.000 n=2+2)
      SSA        6.79user-s ± 8%  6.79user-s ± 6%    ~     (p=0.902 n=15+15)
      Flate      169user-ms ± 8%  164user-ms ± 5%  -3.13%  (p=0.014 n=14+14)
      GoParser   212user-ms ± 7%  217user-ms ±22%    ~     (p=1.000 n=13+15)
      Reflect    521user-ms ± 7%  533user-ms ±15%    ~     (p=0.511 n=14+14)
      Tar        165user-ms ±17%  161user-ms ±15%    ~     (p=0.345 n=15+15)
      XML        294user-ms ±11%  292user-ms ±10%    ~     (p=0.839 n=14+14)
      
      name       old alloc/op     new alloc/op     delta
      Template       39.9MB ± 0%      39.9MB ± 0%    ~     (p=0.621 n=15+14)
      Unicode        31.0MB ± 0%      31.0MB ± 0%    ~     (p=0.098 n=13+15)
      GoTypes         117MB ± 0%       117MB ± 0%    ~     (p=0.775 n=15+15)
      Compiler        488MB ± 0%       488MB ± 0%    ~     (p=0.333 n=2+2)
      SSA             892MB ± 0%       892MB ± 0%  +0.03%  (p=0.000 n=15+15)
      Flate          26.1MB ± 0%      26.1MB ± 0%    ~     (p=0.098 n=15+15)
      GoParser       31.8MB ± 0%      31.8MB ± 0%    ~     (p=0.525 n=15+13)
      Reflect        81.2MB ± 0%      81.2MB ± 0%  +0.06%  (p=0.001 n=12+14)
      Tar            27.5MB ± 0%      27.5MB ± 0%    ~     (p=0.595 n=15+15)
      XML            44.1MB ± 0%      44.1MB ± 0%    ~     (p=0.486 n=15+15)
      
      name       old allocs/op    new allocs/op    delta
      Template         378k ± 1%        378k ± 0%    ~     (p=0.949 n=15+14)
      Unicode          324k ± 0%        324k ± 1%    ~     (p=0.057 n=14+15)
      GoTypes         1.15M ± 0%       1.15M ± 0%    ~     (p=0.461 n=15+15)
      Compiler        4.39M ± 0%       4.39M ± 0%    ~     (p=0.333 n=2+2)
      SSA             7.90M ± 0%       7.90M ± 0%  +0.06%  (p=0.008 n=15+15)
      Flate            240k ± 1%        241k ± 0%    ~     (p=0.233 n=15+15)
      GoParser         309k ± 1%        309k ± 0%    ~     (p=0.867 n=15+12)
      Reflect         1.00M ± 0%       1.00M ± 0%    ~     (p=0.139 n=12+15)
      Tar              254k ± 1%        253k ± 1%    ~     (p=0.345 n=15+15)
      XML              398k ± 0%        397k ± 1%    ~     (p=0.267 n=15+15)
      
      
      Change-Id: Ic999a0f456a371c99eebba0f9747263a13836e33
      Reviewed-on: https://go-review.googlesource.com/37766
      Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      57e03861
    • Kevin Burke's avatar
      os/user: add non-cgo versions of Lookup, LookupId · c2eb0619
      Kevin Burke authored
      If you cross compile for a Unix target and call user.Lookup("root")
      or user.LookupId("0"), we'll try to read the answer out of
      /etc/passwd instead of returning an "unimplemented" error.
      
      The equivalent cgo function calls getpwuid_r in glibc, which
      may reach out to the NSS database or allow callers to register
      extensions. The pure Go implementation only reads from /etc/passwd.
      
      Change-Id: I56a302d634b15ba5097f9f0d6a758c68e486ba6d
      Reviewed-on: https://go-review.googlesource.com/37664Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      c2eb0619
    • Giovanni Bajo's avatar
      cmd/compile: improve generic rules for BCE based on AND operations. · 4fc45ae8
      Giovanni Bajo authored
      Match more patterns generated by the compiler where the index for
      a bound check is bounded through a AND operation, with different
      register sizes.
      
      These rules trigger a dozen of times in a bootstrap.
      
      Change-Id: Ic9fff16f21d08580f19a366c3ee1a372e58357d1
      Reviewed-on: https://go-review.googlesource.com/37442
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarKeith Randall <khr@golang.org>
      4fc45ae8
    • Austin Clements's avatar
      runtime: make ReadMemStats STW for < 25µs · 4a7cf960
      Austin Clements authored
      Currently ReadMemStats stops the world for ~1.7 ms/GB of heap because
      it collects statistics from every single span. For large heaps, this
      can be quite costly. This is particularly unfortunate because many
      production infrastructures call this function regularly to collect and
      report statistics.
      
      Fix this by tracking the necessary cumulative statistics in the
      mcaches. ReadMemStats still has to stop the world to stabilize these
      statistics, but there are only O(GOMAXPROCS) mcaches to collect
      statistics from, so this pause is only 25µs even at GOMAXPROCS=100.
      
      Fixes #13613.
      
      Change-Id: I3c0a4e14833f4760dab675efc1916e73b4c0032a
      Reviewed-on: https://go-review.googlesource.com/34937
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarRick Hudson <rlh@golang.org>
      4a7cf960
    • Austin Clements's avatar
      runtime: remove unused gcstats · 3399fd25
      Austin Clements authored
      The gcstats structure is no longer consumed by anything and no longer
      tracks statistics that are particularly relevant to the concurrent
      garbage collector. Remove it. (Having statistics is probably a good
      idea, but these aren't the stats we need these days and we don't have
      a way to get them out of the runtime.)
      
      In preparation for #13613.
      
      Change-Id: Ib63e2f9067850668f9dcbfd4ed89aab4a6622c3f
      Reviewed-on: https://go-review.googlesource.com/34936
      Run-TryBot: Austin Clements <austin@google.com>
      Reviewed-by: 's avatarRick Hudson <rlh@golang.org>
      3399fd25
    • Elias Naur's avatar
      misc/ios,cmd/go, runtime/cgo: fix iOS test harness (again) · 7523baed
      Elias Naur authored
      The iOS test harness was recently changed in response to lldb bugs
      to replace breakpoints with the SIGUSR2 signal (CL 34926), and to
      pass the current directory in the test binary arguments (CL 35152).
      Both the signal sending and working directory setup is done from
      the go test driver.
      
      However, the new method doesn't work with tests where a C program is
      the test driver instead of go test: the current working directory
      will not be changed and SIGUSR2 is not raised.
      
      Instead of copying that logic into any C test program, rework the
      test harness (again) to move the setup logic to the early runtime
      cgo setup code. That way, the harness will run even in the library
      build modes.
      
      Then, use the app Info.plist file to pass the working
      directory, removing the need to alter the arguments after running.
      
      Finally, use the SIGINT signal instead of SIGUSR2 to avoid
      manipulating the signal masks or handlers.
      
      Fixes the testcarchive tests on iOS.
      
      With this CL, both darwin/arm and darwin/arm64 passes all.bash.
      
      This CL replaces CL 34926, CL 35152 as well as the fixup CL
      35123 and CL 35255. They are reverted in CLs earlier in the
      relation chain.
      
      Change-Id: I8485c7db1404fbd8daa261efd1ea89e905121a3e
      Reviewed-on: https://go-review.googlesource.com/36090
      Run-TryBot: Elias Naur <elias.naur@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarDavid Crawshaw <crawshaw@golang.org>
      7523baed
    • Elias Naur's avatar
      Revert "cmd/go, misc: switch from breakpoint to SIGUSR2" · fec40bd1
      Elias Naur authored
      This reverts commit 333f764d.
      
      Replaced by a improved strategy later in the CL relation chain.
      
      Change-Id: I70a1d2f0aa5aa0d3d0ec85b5a956c6fb60d88908
      Reviewed-on: https://go-review.googlesource.com/36069
      Run-TryBot: Elias Naur <elias.naur@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarDavid Crawshaw <crawshaw@golang.org>
      fec40bd1
    • Josh Bleecher Snyder's avatar
      cmd/compile: cull UINF · 03e2a4d1
      Josh Bleecher Snyder authored
      It was used with Node.Ullman, which is now gone.
      
      Change-Id: I83b167645659ae7ef70043b7915d642e42ca524f
      Reviewed-on: https://go-review.googlesource.com/37761
      Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
      Reviewed-by: 's avatarMatthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      03e2a4d1
    • Dmitri Shuralyov's avatar
      go/build: fix lack of error for Import of nonexistent local import path · e646d073
      Dmitri Shuralyov authored
      When calling build.Import, normally, an error is returned if the
      directory doesn't exist. However, that didn't happen for local
      import paths when build.FindOnly ImportMode was used.
      
      This change fixes that, and adds tests. It also makes the error
      value more consistent in all scenarios where it occurs.
      
      When calling build.Import with a local import path, the package
      can only exist in a single deterministic directory. That makes
      it possible verify that directory exists earlier in the path,
      and return a "cannot find package" error if it doesn't.
      Previously, this occurred only when build.FindOnly ImportMode
      was not set. It occurred quite late, after getting past Found
      label, to line that calls ctxt.readDir. Doing so would return
      an error like "no such file or directory" when the directory
      does not exist.
      
      Fixes #17863.
      Updates #17888 (relevant issue I ran into while working on this CL).
      
      Change-Id: If6a6996ac6176ac203a88bd31419748f88d89d7c
      Reviewed-on: https://go-review.googlesource.com/33158Reviewed-by: 's avatarIan Lance Taylor <iant@golang.org>
      Run-TryBot: Ian Lance Taylor <iant@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      e646d073
    • Elias Naur's avatar
      Revert "cmd/go: add comment about SIGUSR2 on iOS" · 2dc714e1
      Elias Naur authored
      This reverts commit 4f0aac52.
      
      Replaced by a improved strategy later in the CL relation chain.
      
      Change-Id: Iff0333f172443bb5b01a42ad06b01edeb6aa15bc
      Reviewed-on: https://go-review.googlesource.com/36068
      Run-TryBot: Elias Naur <elias.naur@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarDavid Crawshaw <crawshaw@golang.org>
      2dc714e1
    • Elias Naur's avatar
      Revert "cmd/go, misc: rework cwd handling for iOS tests" · 3ce5371a
      Elias Naur authored
      This reverts commit 593ea3b3.
      
      Replaced by a improved strategy later in the CL relation chain.
      
      Change-Id: I6963e4d1bf38e7028cf545a953e28054d83548
      Change-Id: I6963e4d1bf38e7028cf545a953e28054d8354870
      Reviewed-on: https://go-review.googlesource.com/36067Reviewed-by: 's avatarDavid Crawshaw <crawshaw@golang.org>
      3ce5371a
    • Elias Naur's avatar
      Revert "all: test adjustments for the iOS builder" · 2b780af0
      Elias Naur authored
      This reverts commit 467109bf.
      
      Replaced by a improved strategy later in the CL relation chain.
      
      Change-Id: Ib90813b5a6c4716b563c8496013d2d57f9c022b8
      Reviewed-on: https://go-review.googlesource.com/36066Reviewed-by: 's avatarDavid Crawshaw <crawshaw@golang.org>
      Run-TryBot: Elias Naur <elias.naur@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      2b780af0
  4. 03 Mar, 2017 18 commits
    • Matthew Dempsky's avatar
      cmd/compile/internal/gc: replace Node.Ullman with Node.HasCall · 870d079c
      Matthew Dempsky authored
      Since switching to SSA, the only remaining use for the Ullman field
      was in tracking whether or not an expression contained a function
      call. Give it a new name and encode it in our fancy new bitset field.
      
      Passes toolstash-check.
      
      Change-Id: I95b7f9cb053856320c0d66efe14996667e6011c2
      Reviewed-on: https://go-review.googlesource.com/37721
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarJosh Bleecher Snyder <josharian@gmail.com>
      870d079c
    • David Lazar's avatar
      cmd/compile: include position info in exported function bodies · 9fd359a2
      David Lazar authored
      This gives accurate line numbers to inlined functions from another
      package. Previously AST nodes from another package would get the line
      number of the import statement for that package.
      
      The following benchmark results show how the size of package export data
      is impacted by this change. These benchmarks were created by compiling
      the go1 benchmark and running `go tool pack x` to extract the export
      data from the resulting .a files.
      
      name                                          old bytes   new bytes    delta
      bufio                                         3.59k ± 0%   4.17k ± 0%  +16.25%
      bytes                                         5.51k ± 0%   6.40k ± 0%  +16.21%
      compress/bzip2                                2.69k ± 0%   3.21k ± 0%  +19.74%
      compress/flate                                5.14k ± 0%   5.57k ± 0%   +8.43%
      compress/gzip                                 8.91k ± 0%  10.46k ± 0%  +17.32%
      container/list                                1.76k ± 0%   2.13k ± 0%  +21.51%
      context                                       4.51k ± 0%   5.47k ± 0%  +21.43%
      crypto                                        1.11k ± 0%   1.13k ± 0%   +1.90%
      crypto/aes                                      475 ± 0%     475 ± 0%   +0.00%
      crypto/cipher                                 1.18k ± 0%   1.18k ± 0%   +0.00%
      crypto/des                                      502 ± 0%     502 ± 0%   +0.00%
      crypto/dsa                                    5.96k ± 0%   6.54k ± 0%   +9.82%
      crypto/ecdsa                                  6.93k ± 0%   7.69k ± 0%  +10.91%
      crypto/elliptic                               6.53k ± 0%   7.17k ± 0%   +9.72%
      crypto/hmac                                     464 ± 0%     464 ± 0%   +0.00%
      crypto/internal/cipherhw                        313 ± 0%     313 ± 0%   +0.00%
      crypto/md5                                      695 ± 0%     711 ± 0%   +2.30%
      crypto/rand                                   5.62k ± 0%   6.21k ± 0%  +10.44%
      crypto/rc4                                      512 ± 0%     512 ± 0%   +0.00%
      crypto/rsa                                    7.31k ± 0%   8.10k ± 0%  +10.86%
      crypto/sha1                                     760 ± 0%     777 ± 0%   +2.24%
      crypto/sha256                                   523 ± 0%     523 ± 0%   +0.00%
      crypto/sha512                                   663 ± 0%     663 ± 0%   +0.00%
      crypto/subtle                                   873 ± 0%    1007 ± 0%  +15.35%
      crypto/tls                                    29.6k ± 0%   33.8k ± 0%  +14.03%
      crypto/x509                                   18.7k ± 0%   21.0k ± 0%  +12.56%
      crypto/x509/pkix                              10.6k ± 0%   12.2k ± 0%  +15.22%
      encoding                                        473 ± 0%     473 ± 0%   +0.00%
      encoding/asn1                                 1.42k ± 0%   1.50k ± 0%   +5.99%
      encoding/base64                               1.69k ± 0%   1.80k ± 0%   +6.88%
      encoding/binary                               2.76k ± 0%   3.51k ± 0%  +27.09%
      encoding/gob                                  13.5k ± 0%   15.2k ± 0%  +12.98%
      encoding/hex                                    857 ± 0%     881 ± 0%   +2.80%
      encoding/json                                 12.5k ± 0%   14.9k ± 0%  +19.37%
      encoding/pem                                    484 ± 0%     484 ± 0%   +0.00%
      errors                                          361 ± 0%     370 ± 0%   +2.49%
      flag                                          10.5k ± 0%   12.1k ± 0%  +14.92%
      fmt                                           1.42k ± 0%   1.42k ± 0%   +0.00%
      go/ast                                        15.8k ± 0%   17.5k ± 0%  +10.31%
      go/parser                                     8.13k ± 0%   9.86k ± 0%  +21.28%
      go/scanner                                    3.94k ± 0%   4.53k ± 0%  +14.73%
      go/token                                      3.53k ± 0%   3.75k ± 0%   +6.11%
      hash                                            507 ± 0%     507 ± 0%   +0.00%
      hash/crc32                                      685 ± 0%     685 ± 0%   +0.00%
      internal/nettrace                               474 ± 0%     474 ± 0%   +0.00%
      internal/poll                                 7.23k ± 0%   8.38k ± 0%  +15.90%
      internal/race                                   511 ± 0%     515 ± 0%   +0.78%
      internal/singleflight                           969 ± 0%    1075 ± 0%  +10.94%
      internal/syscall/unix                           427 ± 0%     427 ± 0%   +0.00%
      io                                            3.52k ± 0%   3.69k ± 0%   +4.82%
      io/ioutil                                     8.48k ± 0%   9.90k ± 0%  +16.72%
      log                                           5.06k ± 0%   5.98k ± 0%  +18.15%
      math                                          4.02k ± 0%   4.35k ± 0%   +8.26%
      math/big                                      9.28k ± 0%   9.94k ± 0%   +7.13%
      math/bits                                     3.47k ± 0%   4.33k ± 0%  +24.83%
      math/rand                                     1.30k ± 0%   1.32k ± 0%   +2.00%
      mime                                          2.98k ± 0%   3.70k ± 0%  +24.21%
      mime/multipart                                3.68k ± 0%   4.22k ± 0%  +14.65%
      mime/quotedprintable                          2.26k ± 0%   2.65k ± 0%  +17.60%
      net                                           23.0k ± 0%   25.7k ± 0%  +11.74%
      net/http                                      59.1k ± 0%   66.7k ± 0%  +13.00%
      net/http/httptest                             35.3k ± 0%   40.9k ± 0%  +15.80%
      net/http/httptrace                            15.3k ± 0%   17.6k ± 0%  +15.26%
      net/http/internal                             2.77k ± 0%   3.27k ± 0%  +17.89%
      net/textproto                                 4.60k ± 0%   5.25k ± 0%  +14.22%
      net/url                                       1.73k ± 0%   1.84k ± 0%   +6.59%
      os                                            14.3k ± 0%   16.4k ± 0%  +14.86%
      path                                            589 ± 0%     606 ± 0%   +2.89%
      path/filepath                                 5.07k ± 0%   6.17k ± 0%  +21.79%
      reflect                                       6.43k ± 0%   6.81k ± 0%   +5.90%
      regexp                                        5.88k ± 0%   6.46k ± 0%   +9.77%
      regexp/syntax                                 3.24k ± 0%   3.29k ± 0%   +1.73%
      runtime                                       13.1k ± 0%   14.9k ± 0%  +13.73%
      runtime/cgo                                     229 ± 0%     229 ± 0%   +0.00%
      runtime/debug                                 4.23k ± 0%   5.15k ± 0%  +21.79%
      runtime/internal/atomic                         905 ± 0%     905 ± 0%   +0.00%
      runtime/internal/sys                          2.04k ± 0%   2.20k ± 0%   +7.64%
      runtime/pprof                                 4.73k ± 0%   5.65k ± 0%  +19.41%
      runtime/trace                                   354 ± 0%     354 ± 0%   +0.00%
      sort                                          1.68k ± 0%   1.85k ± 0%  +10.17%
      strconv                                       1.85k ± 0%   1.95k ± 0%   +5.51%
      strings                                       3.98k ± 0%   4.53k ± 0%  +13.91%
      sync                                          1.52k ± 0%   1.58k ± 0%   +4.28%
      sync/atomic                                   1.60k ± 0%   1.74k ± 0%   +8.50%
      syscall                                       53.3k ± 0%   54.3k ± 0%   +1.84%
      testing                                       8.77k ± 0%  10.09k ± 0%  +14.96%
      testing/internal/testdeps                       598 ± 0%     600 ± 0%   +0.33%
      text/tabwriter                                3.63k ± 0%   4.41k ± 0%  +21.64%
      text/template                                 15.7k ± 0%   18.1k ± 0%  +15.67%
      text/template/parse                           9.12k ± 0%  10.35k ± 0%  +13.48%
      time                                          6.38k ± 0%   7.14k ± 0%  +11.81%
      unicode                                       4.62k ± 0%   4.66k ± 0%   +0.98%
      unicode/utf16                                   707 ± 0%     791 ± 0%  +11.88%
      unicode/utf8                                  1.06k ± 0%   1.20k ± 0%  +12.63%
      vendor/golang_org/x/crypto/chacha20poly1305   1.26k ± 0%   1.43k ± 0%  +13.54%
      vendor/golang_org/x/crypto/curve25519           392 ± 0%     392 ± 0%   +0.00%
      vendor/golang_org/x/crypto/poly1305             426 ± 0%     426 ± 0%   +0.00%
      vendor/golang_org/x/net/http2/hpack           4.75k ± 0%   5.77k ± 0%  +21.42%
      vendor/golang_org/x/net/idna                    355 ± 0%     355 ± 0%   +0.00%
      vendor/golang_org/x/net/lex/httplex             616 ± 0%     644 ± 0%   +4.55%
      vendor/golang_org/x/net/proxy                 7.76k ± 0%   9.58k ± 0%  +23.37%
      vendor/golang_org/x/text/transform            1.31k ± 0%   1.32k ± 0%   +0.46%
      vendor/golang_org/x/text/unicode/norm         5.89k ± 0%   6.84k ± 0%  +16.06%
      vendor/golang_org/x/text/width                1.24k ± 0%   1.27k ± 0%   +2.66%
      [Geo mean]                                    2.51k        2.74k        +9.14%
      
      Change-Id: I9ded911bb0ff63c530795fc85253d76b56d8abbc
      Reviewed-on: https://go-review.googlesource.com/37239
      Run-TryBot: David Lazar <lazard@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarAustin Clements <austin@google.com>
      9fd359a2
    • David Lazar's avatar
      cmd/compile: add flag for debugging PC-value tables · 0824ae6d
      David Lazar authored
      For example, `-d pctab=pctoinline` prints the PC-inline table and
      inlining tree for every function.
      
      Change-Id: Ia6b9ce4d83eed0b494318d40ffe06481ec5d58ab
      Reviewed-on: https://go-review.googlesource.com/37235
      Run-TryBot: David Lazar <lazard@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarAustin Clements <austin@google.com>
      0824ae6d
    • David Lazar's avatar
      cmd/internal/obj: avoid duplicate file name symbols · 301149b9
      David Lazar authored
      The meaning of Version=1 was overloaded: it was reserved for file name
      symbols (to avoid conflicts with non-file name symbols), but was also
      used to mean "give me a fresh version number for this symbol."
      
      With the new inlining tree, the same file name symbol can appear in
      multiple entries, but each one would become a distinct symbol with its
      own version number.
      
      Now, we avoid duplicating symbols by using Version=0 for file name
      symbols and we avoid conflicts with other symbols by prefixing the
      symbol name with "gofile..".
      
      Change-Id: I8d0374053b8cdb6a9ca7fb71871b69b4dd369a9c
      Reviewed-on: https://go-review.googlesource.com/37234
      Run-TryBot: David Lazar <lazard@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarAustin Clements <austin@google.com>
      Reviewed-by: 's avatarRuss Cox <rsc@golang.org>
      301149b9
    • David Lazar's avatar
      runtime: use inlining tables to generate accurate tracebacks · 781fd399
      David Lazar authored
      The code in https://play.golang.org/p/aYQPrTtzoK now produces the
      following stack trace:
      
      goroutine 1 [running]:
      main.(*point).negate(...)
      	/tmp/go/main.go:8
      main.main()
      	/tmp/go/main.go:14 +0x23
      
      Previously the stack trace missed the inlined call:
      
      goroutine 1 [running]:
      main.main()
      	/tmp/go/main.go:14 +0x23
      
      Fixes #10152.
      Updates #19348.
      
      Change-Id: Ib43c67012f53da0ef1a1e69bcafb65b57d9cecb2
      Reviewed-on: https://go-review.googlesource.com/37233
      Run-TryBot: David Lazar <lazard@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarAustin Clements <austin@google.com>
      781fd399
    • David Lazar's avatar
      cmd/compile: copy literals when inlining · 1c6ef9ae
      David Lazar authored
      Without this, literals keep their original source positions through
      inlining, which results in strange jumps in line numbers of inlined
      function bodies. By copying literals, inlining can update their source
      position like other nodes.
      
      Fixes #15453.
      
      Change-Id: Iad5d9bbfe183883794213266dc30e31bab89ee69
      Reviewed-on: https://go-review.googlesource.com/37232
      Run-TryBot: David Lazar <lazard@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarMatthew Dempsky <mdempsky@google.com>
      Reviewed-by: 's avatarRuss Cox <rsc@golang.org>
      1c6ef9ae
    • David Lazar's avatar
      cmd/compile,link: generate PC-value tables with inlining information · 699175a1
      David Lazar authored
      In order to generate accurate tracebacks, the runtime needs to know the
      inlined call stack for a given PC. This creates two tables per function
      for this purpose. The first table is the inlining tree (stored in the
      function's funcdata), which has a node containing the file, line, and
      function name for every inlined call. The second table is a PC-value
      table that maps each PC to a node in the inlining tree (or -1 if the PC
      is not the result of inlining).
      
      To give the appearance that inlining hasn't happened, the runtime also
      needs the original source position information of inlined AST nodes.
      Previously the compiler plastered over the line numbers of inlined AST
      nodes with the line number of the call. This meant that the PC-line
      table mapped each PC to line number of the outermost call in its inlined
      call stack, with no way to access the innermost line number.
      
      Now the compiler retains line numbers of inlined AST nodes and writes
      the innermost source position information to the PC-line and PC-file
      tables. Some tools and tests expect to see outermost line numbers, so we
      provide the OutermostLine function for displaying line info.
      
      To keep track of the inlined call stack for an AST node, we extend the
      src.PosBase type with an index into a global inlining tree. Every time
      the compiler inlines a call, it creates a node in the global inlining
      tree for the call, and writes its index to the PosBase of every inlined
      AST node. The parent of this node is the inlining tree index of the
      call. -1 signifies no parent.
      
      For each function, the compiler creates a local inlining tree and a
      PC-value table mapping each PC to an index in the local tree.  These are
      written to an object file, which is read by the linker.  The linker
      re-encodes these tables compactly by deduplicating function names and
      file names.
      
      This change increases the size of binaries by 4-5%. For example, this is
      how the go1 benchmark binary is impacted by this change:
      
      section             old bytes   new bytes   delta
      .text               3.49M ± 0%  3.49M ± 0%   +0.06%
      .rodata             1.12M ± 0%  1.21M ± 0%   +8.21%
      .gopclntab          1.50M ± 0%  1.68M ± 0%  +11.89%
      .debug_line          338k ± 0%   435k ± 0%  +28.78%
      Total               9.21M ± 0%  9.58M ± 0%   +4.01%
      
      Updates #19348.
      
      Change-Id: Ic4f180c3b516018138236b0c35e0218270d957d3
      Reviewed-on: https://go-review.googlesource.com/37231
      Run-TryBot: David Lazar <lazard@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarAustin Clements <austin@google.com>
      699175a1
    • Aliaksandr Valialkin's avatar
      cmd/compile: pack bool fields in Node, Name, Func and Type structs to bitsets · ed70f37e
      Aliaksandr Valialkin authored
      This reduces compiler memory usage by up to 4% - see compilebench
      results below.
      
      name       old time/op     new time/op     delta
      Template       245ms ± 4%      241ms ± 2%  -1.88%  (p=0.029 n=10+10)
      Unicode        126ms ± 3%      124ms ± 3%    ~     (p=0.105 n=10+10)
      GoTypes        805ms ± 2%      813ms ± 3%    ~     (p=0.515 n=8+10)
      Compiler       3.95s ± 2%      3.83s ± 1%  -2.96%  (p=0.000 n=9+10)
      MakeBash       47.4s ± 4%      46.6s ± 1%  -1.59%  (p=0.028 n=9+10)
      
      name       old user-ns/op  new user-ns/op  delta
      Template        324M ± 5%       326M ± 3%    ~     (p=0.935 n=10+10)
      Unicode         186M ± 5%       178M ±10%    ~     (p=0.067 n=9+10)
      GoTypes        1.08G ± 7%      1.09G ± 4%    ~     (p=0.956 n=10+10)
      Compiler       5.34G ± 4%      5.31G ± 1%    ~     (p=0.501 n=10+8)
      
      name       old alloc/op    new alloc/op    delta
      Template      41.0MB ± 0%     39.8MB ± 0%  -3.03%  (p=0.000 n=10+10)
      Unicode       32.3MB ± 0%     31.0MB ± 0%  -4.13%  (p=0.000 n=10+10)
      GoTypes        119MB ± 0%      116MB ± 0%  -2.39%  (p=0.000 n=10+10)
      Compiler       499MB ± 0%      487MB ± 0%  -2.48%  (p=0.000 n=10+10)
      
      name       old allocs/op   new allocs/op   delta
      Template        380k ± 1%       379k ± 1%    ~     (p=0.436 n=10+10)
      Unicode         324k ± 1%       324k ± 0%    ~     (p=0.853 n=10+10)
      GoTypes        1.15M ± 0%      1.15M ± 0%    ~     (p=0.481 n=10+10)
      Compiler       4.41M ± 0%      4.41M ± 0%  -0.12%  (p=0.007 n=10+10)
      
      name       old text-bytes  new text-bytes  delta
      HelloSize       623k ± 0%       623k ± 0%    ~     (all equal)
      CmdGoSize      6.64M ± 0%      6.64M ± 0%    ~     (all equal)
      
      name       old data-bytes  new data-bytes  delta
      HelloSize      5.81k ± 0%      5.81k ± 0%    ~     (all equal)
      CmdGoSize       238k ± 0%       238k ± 0%    ~     (all equal)
      
      name       old bss-bytes   new bss-bytes   delta
      HelloSize       134k ± 0%       134k ± 0%    ~     (all equal)
      CmdGoSize       152k ± 0%       152k ± 0%    ~     (all equal)
      
      name       old exe-bytes   new exe-bytes   delta
      HelloSize       967k ± 0%       967k ± 0%    ~     (all equal)
      CmdGoSize      10.2M ± 0%      10.2M ± 0%    ~     (all equal)
      
      Change-Id: I1f40af738254892bd6c8ba2eb43390b175753d52
      Reviewed-on: https://go-review.googlesource.com/37445Reviewed-by: 's avatarMatthew Dempsky <mdempsky@google.com>
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      ed70f37e
    • Johan Brandhorst's avatar
      net/http/httptest: add Client and Certificate methods to Server · fbf4dd91
      Johan Brandhorst authored
      Adds a function for easily accessing the x509.Certificate
      of a Server, if there is one. Also adds a helper function
      for getting a http.Client suitable for use with the server.
      
      This makes the steps required to test a httptest
      TLS server simpler.
      
      Fixes #18411
      
      Change-Id: I2e78fe1e54e31bed9c641be2d9a099f698c7bbde
      Reviewed-on: https://go-review.googlesource.com/34639Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      fbf4dd91
    • Matthew Dempsky's avatar
      cmd/compile/internal/ssa: remove Hmul{8,16}{,u} ops · 02e36f8c
      Matthew Dempsky authored
      Change-Id: I90865921584ae4bdfb6c220d439b14593d72b6f9
      Reviewed-on: https://go-review.googlesource.com/37752
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarCherry Zhang <cherryyz@google.com>
      02e36f8c
    • Cherry Zhang's avatar
      cmd/compile: remove zeroing after newobject · c8eaeb8c
      Cherry Zhang authored
      The Zero op right after newobject has been removed. But this rule
      does not cover Store of constant zero (for SSA-able types). Add
      rules to cover Store op as well.
      
      Updates #19027.
      
      Change-Id: I5d2b62eeca0aa9ce8dc7205b264b779de01c660b
      Reviewed-on: https://go-review.googlesource.com/36836
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarKeith Randall <khr@golang.org>
      c8eaeb8c
    • Cherry Zhang's avatar
      cmd/compile: fix optimization of Zero newobject on amd64p32 · 9b480521
      Cherry Zhang authored
      On amd64p32, PtrSize and RegSize don't agree, and function return
      value is aligned with RegSize. Fix this rule. Other architectures
      are not affected, where PtrSize and RegSize are the same.
      
      Change-Id: If187d3dfde3dc3b931b8e97db5eeff49a781551b
      Reviewed-on: https://go-review.googlesource.com/37720
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarKeith Randall <khr@golang.org>
      9b480521
    • Matthew Dempsky's avatar
      cmd/compile/internal/gc: remove OHMUL Op · d8a0f748
      Matthew Dempsky authored
      Previously the compiler rewrote constant division into OHMUL
      operations, but that rewriting was moved to SSA in CL 37015. Now OHMUL
      is unused, so we can get rid of it.
      
      Change-Id: Ib6fc7c2b6435510bafb5735b3b4f42cfd8ed8cdb
      Reviewed-on: https://go-review.googlesource.com/37750
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarCherry Zhang <cherryyz@google.com>
      Reviewed-by: 's avatarKeith Randall <khr@golang.org>
      d8a0f748
    • Austin Clements's avatar
      runtime: clarify access to mheap_.busy · 77f64c50
      Austin Clements authored
      There are two accesses to mheap_.busy that are guarded by checks
      against len(mheap_.free). This works because both lists are (and must
      be) the same length, but it makes the code less clear. Change these to
      use len(mheap_.busy) so the access more clearly parallels the check.
      
      Fixes #18944.
      
      Change-Id: I9bacbd3663988df351ed4396ae9018bc71018311
      Reviewed-on: https://go-review.googlesource.com/36354
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarRick Hudson <rlh@golang.org>
      77f64c50
    • Austin Clements's avatar
      runtime: simplify sweep allocation counting · b50b7285
      Austin Clements authored
      Currently sweep counts the number of allocated objects, computes the
      number of free objects from that, then re-computes the number of
      allocated objects from that. Simplify and clean this up by skipping
      these intermediate steps.
      
      Change-Id: I3ed98e371eb54bbcab7c8530466c4ab5fde35f0a
      Reviewed-on: https://go-review.googlesource.com/34935
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarMarvin Stenger <marvin.stenger94@gmail.com>
      Reviewed-by: 's avatarRick Hudson <rlh@golang.org>
      b50b7285
    • Austin Clements's avatar
      runtime: don't rescan finalizers queue during mark termination · f1ba75f8
      Austin Clements authored
      Currently we scan the finalizers queue both during concurrent mark and
      during mark termination. This costs roughly 20ns per queued finalizer
      and about 1ns per unused finalizer queue slot (allocated queue length
      never decreases), which can drive up STW time if there are many
      finalizers.
      
      However, we only add finalizers to this queue during sweeping, which
      means that the second scan will never find anything new. Hence, we can
      fix this by simply not scanning the finalizers queue during mark
      termination. This brings the STW time under the 100µs goal even with
      1,000,000 queued finalizers.
      
      Fixes #18869.
      
      Change-Id: I4ce5620c66fb7f13ebeb39ca313ce57047d1d0fb
      Reviewed-on: https://go-review.googlesource.com/36013
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarRick Hudson <rlh@golang.org>
      f1ba75f8
    • Austin Clements's avatar
      runtime: remove wbufptr · 98da2d1f
      Austin Clements authored
      Since workbuf is now marked go:notinheap, the write barrier-preventing
      wrapper type wbufptr is no longer necessary. Remove it.
      
      Change-Id: I3e5b5803a1547d65de1c1a9c22458a38e08549b7
      Reviewed-on: https://go-review.googlesource.com/35971
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarRick Hudson <rlh@golang.org>
      98da2d1f
    • Austin Clements's avatar
      cmd/compile: accept string debug flags · 8eb14e9d
      Austin Clements authored
      The compiler's -d flag accepts string-valued flags, but currently only
      for SSA debug flags. Extend it to support string values for other
      flags. This also makes the syntax somewhat more sane so flag=value and
      flag:value now both accept integers and strings.
      
      Change-Id: Idd144d8479a430970cc1688f824bffe0a56ed2df
      Reviewed-on: https://go-review.googlesource.com/37345
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarDavid Chase <drchase@google.com>
      8eb14e9d