1. 03 Oct, 2018 16 commits
  2. 02 Oct, 2018 24 commits
    • Brad Fitzpatrick's avatar
      net/http: make Transport send WebSocket upgrade requests over HTTP/1 · a73d8f5a
      Brad Fitzpatrick authored
      WebSockets requires HTTP/1 in practice (no spec or implementations
      work over HTTP/2), so if we get an HTTP request that looks like it's
      trying to initiate WebSockets, use HTTP/1, like browsers do.
      
      This is part of a series of commits to make WebSockets work over
      httputil.ReverseProxy. See #26937.
      
      Updates #26937
      
      Change-Id: I6ad3df9b0a21fddf62fa7d9cacef48e7d5d9585b
      Reviewed-on: https://go-review.googlesource.com/c/137437
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarDmitri Shuralyov <dmitshur@golang.org>
      a73d8f5a
    • Aleksandr Razumov's avatar
      net/http: rewind request body unconditionally · 3aa3c052
      Aleksandr Razumov authored
      When http2 fails with ErrNoCachedConn the request is retried with body
      that has already been read.
      
      Fixes #25009
      
      Change-Id: I51ed5c8cf469dd8b17c73fff6140ab80162bf267
      Reviewed-on: https://go-review.googlesource.com/c/131755
      Run-TryBot: Iskander Sharipov <iskander.sharipov@intel.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      3aa3c052
    • Austin Clements's avatar
      runtime: eliminate gchelper mechanism · 0906d648
      Austin Clements authored
      Now that we do no mark work during mark termination, we no longer need
      the gchelper mechanism.
      
      Updates #26903.
      Updates #17503.
      
      Change-Id: Ie94e5c0f918cfa047e88cae1028fece106955c1b
      Reviewed-on: https://go-review.googlesource.com/c/134785
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      0906d648
    • Austin Clements's avatar
      runtime: eliminate work.markrootdone and second root marking pass · 550dfc8a
      Austin Clements authored
      Before STW and concurrent GC were unified, there could be either one
      or two root marking passes per GC cycle. There were several tasks we
      had to make sure happened once and only once (whether that was at the
      beginning of concurrent mark for concurrent GC or during mark
      termination for STW GC). We kept track of this in work.markrootdone.
      
      Now that STW and concurrent GC both use the concurrent marking code
      and we've eliminated all work done by the second root marking pass, we
      only ever need a single root marking pass. Hence, we can eliminate
      work.markrootdone and all of the code that's conditional on it.
      
      Updates #26903.
      
      Change-Id: I654a0f5e21b9322279525560a31e64b8d33b790f
      Reviewed-on: https://go-review.googlesource.com/c/134784
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      550dfc8a
    • Austin Clements's avatar
      runtime: flush mcaches lazily · 873bd47d
      Austin Clements authored
      Currently, all mcaches are flushed during STW mark termination as a
      root marking job. This is currently necessary because all spans must
      be out of these caches before sweeping begins to avoid races with
      allocation and to ensure the spans are in the state expected by
      sweeping. We do it as a root marking job because mcache flushing is
      somewhat expensive and O(GOMAXPROCS) and this parallelizes the work
      across the Ps. However, it's also the last remaining root marking job
      performed during mark termination.
      
      This CL moves mcache flushing out of mark termination and performs it
      lazily. We keep track of the last sweepgen at which each mcache was
      flushed and as each P is woken from STW, it observes that its mcache
      is out-of-date and flushes it.
      
      The introduces a complication for spans cached in stale mcaches. These
      may now be observed by background or proportional sweeping or when
      attempting to add a finalizer, but aren't in a stable state. For
      example, they are likely to be on the wrong mcentral list. To fix
      this, this CL extends the sweepgen protocol to also capture whether a
      span is cached and, if so, whether or not its cache is stale. This
      protocol blocks asynchronous sweeping from touching cached spans and
      makes it the responsibility of mcache flushing to sweep the flushed
      spans.
      
      This eliminates the last mark termination root marking job, which
      means we can now eliminate that entire infrastructure.
      
      Updates #26903. This implements lazy mcache flushing.
      
      Change-Id: Iadda7aabe540b2026cffc5195da7be37d5b4125e
      Reviewed-on: https://go-review.googlesource.com/c/134783
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      873bd47d
    • Austin Clements's avatar
      runtime: eliminate blocking GC work drains · 457c8f4f
      Austin Clements authored
      Now work.helperDrainBlock is always false, so we can remove it and
      code paths that only ran when it was true. That means we no longer use
      the gcDrainBlock mode of gcDrain, so we can eliminate that. That means
      we no longer use gcWork.get, so we can eliminate that. That means we
      no longer use getfull, so we can eliminate that.
      
      Updates #26903. This is a follow-up to unifying STW GC and concurrent GC.
      
      Change-Id: I8dbcf8ce24861df0a6149e0b7c5cd0eadb5c13f6
      Reviewed-on: https://go-review.googlesource.com/c/134782
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      457c8f4f
    • Austin Clements's avatar
      runtime: clean up remaining mark work check · 143b13ae
      Austin Clements authored
      Now that STW GC marking is unified with concurrent marking, there
      should never be mark work remaining in mark termination. Hence, we can
      make that check unconditional.
      
      Updates #26903. This is a follow-up to unifying STW GC and concurrent GC.
      
      Change-Id: I43a21df5577635ab379c397a7405ada68d331e03
      Reviewed-on: https://go-review.googlesource.com/c/134781
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      143b13ae
    • Austin Clements's avatar
      runtime: implement STW GC in terms of concurrent GC · 1678b2c5
      Austin Clements authored
      Currently, STW GC works very differently from concurrent GC. The
      largest differences in that in concurrent GC, all marking work is done
      by background mark workers during the mark phase, while in STW GC, all
      marking work is done by gchelper during the mark termination phase.
      
      This is a consequence of the evolution of Go's GC from a STW GC by
      incrementally moving work from STW mark termination into concurrent
      mark. However, at this point, the STW code paths exist only as a
      debugging mode. Having separate code paths for this increases the
      maintenance burden and complexity of the garbage collector. At the
      same time, these code paths aren't tested nearly as well, making it
      far more likely that they will bit-rot.
      
      This CL reverses the relationship between STW GC, by re-implementing
      STW GC in terms of concurrent GC.
      
      This builds on the new scheduled support for disabling user goroutine
      scheduling. During sweep termination, it disables user scheduling, so
      when the GC starts the world again for concurrent mark, it's really
      only "concurrent" with itself.
      
      There are several code paths that were specific to STW GC that are now
      vestigial. We'll remove these in the follow-up CLs.
      
      Updates #26903.
      
      Change-Id: Ia3883d2fcf7ab1d89bdc9c8ee54bf9bffb32c096
      Reviewed-on: https://go-review.googlesource.com/c/134780
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      1678b2c5
    • Austin Clements's avatar
      runtime: support disabling goroutine scheduling by class · 6e9fb11b
      Austin Clements authored
      This adds support for disabling the scheduling of user goroutines
      while allowing system goroutines like the garbage collector to
      continue running. User goroutines pass through the usual state
      transitions, but if we attempt to actually schedule one, it will get
      put on a deferred scheduling list.
      
      Updates #26903. This is preparation for unifying STW GC and concurrent
      GC.
      
      Updates #25578. This same mechanism can form the basis for disabling
      all but a single user goroutine for the purposes of debugger function
      call injection.
      
      Change-Id: Ib72a808e00c25613fe6982f5528160d3de3dbbc6
      Reviewed-on: https://go-review.googlesource.com/c/134779
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      6e9fb11b
    • Austin Clements's avatar
      runtime: add a more stable isSystemGoroutine mode · 29b21ec4
      Austin Clements authored
      Currently, isSystemGoroutine varies on whether it considers the
      finalizer goroutine a user goroutine or a system goroutine. For the
      next CL, we're going to want to always consider the finalier goroutine
      a user goroutine, so add a flag that indicates that.
      
      Updates #26903. This is preparation for unifying STW GC and concurrent
      GC.
      
      Change-Id: Iafc92e519c13d9f8d879332cb5f0d12164104c33
      Reviewed-on: https://go-review.googlesource.com/c/134778
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      29b21ec4
    • Austin Clements's avatar
      runtime: remove GODEBUG=gcrescanstacks=1 mode · 198440cc
      Austin Clements authored
      Currently, setting GODEBUG=gcrescanstacks=1 enables a debugging mode
      where the garbage collector re-scans goroutine stacks during mark
      termination. This was introduced in Go 1.8 to debug the hybrid write
      barrier, but I don't think we ever used it.
      
      Now it's one of the last sources of mark work during mark termination.
      This CL removes it.
      
      Updates #26903. This is preparation for unifying STW GC and concurrent
      GC.
      
      Updates #17503.
      
      Change-Id: I6ae04d3738aa9c448e6e206e21857a33ecd12acf
      Reviewed-on: https://go-review.googlesource.com/c/134777
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      198440cc
    • Austin Clements's avatar
      runtime: avoid using STW GC mechanism for checkmarks mode · ecc36596
      Austin Clements authored
      Currently, checkmarks mode uses the full STW GC infrastructure to
      perform mark checking. We're about to remove that infrastructure and,
      furthermore, since checkmarks is about doing the simplest thing
      possible to check concurrent GC, it's valuable for it to be simpler.
      
      Hence, this CL makes checkmarks even simpler by making it non-parallel
      and divorcing it from the STW GC infrastructure (including the
      gchelper mechanism).
      
      Updates #26903. This is preparation for unifying STW GC and concurrent
      GC.
      
      Change-Id: Iad21158123e025e3f97d7986d577315e994bd43e
      Reviewed-on: https://go-review.googlesource.com/c/134776
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      ecc36596
    • Austin Clements's avatar
      runtime: remove gcStart's mode argument · 918ed88e
      Austin Clements authored
      This argument is always gcBackgroundMode since only
      debug.gcstoptheworld can trigger a STW GC at this point. Remove the
      unnecessary argument.
      
      Updates #26903. This is preparation for unifying STW GC and concurrent
      GC.
      
      Change-Id: Icb4ba8f10f80c2b69cf51a21e04fa2c761b71c94
      Reviewed-on: https://go-review.googlesource.com/c/134775
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      918ed88e
    • Austin Clements's avatar
      runtime: don't disable GC work caching during mark termination · e25ef352
      Austin Clements authored
      Currently, we disable GC work caching during mark termination. This is
      no longer necessary with the new mark completion detection because
      
      1. There's no way for any of the GC mark termination helpers to have
      any real work queued and,
      
      2. Mark termination has to explicitly flush every P's buffers anyway
      in order to flush Ps that didn't run a GC mark termination helper.
      
      Hence, remove the code that disposes gcWork buffers during mark
      termination.
      
      Updates #26903. This is a follow-up to eliminating mark 2.
      
      Change-Id: I81f002ee25d5c10f42afd39767774636519007f9
      Reviewed-on: https://go-review.googlesource.com/c/134320
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      e25ef352
    • Austin Clements's avatar
      runtime: eliminate gcBlackenPromptly mode · d398dbdf
      Austin Clements authored
      Now that there is no mark 2 phase, gcBlackenPromptly is no longer
      used.
      
      Updates #26903. This is a follow-up to eliminating mark 2.
      
      Change-Id: Ib9c534f21b36b8416fcf3cab667f186167b827f8
      Reviewed-on: https://go-review.googlesource.com/c/134319
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      d398dbdf
    • Austin Clements's avatar
      runtime: eliminate mark 2 and fix mark termination race · 9108ae77
      Austin Clements authored
      The mark 2 phase was originally introduced as a way to reduce the
      chance of entering STW mark termination while there was still marking
      work to do. It works by flushing and disabling all local work caches
      so that all enqueued work becomes immediately globally visible.
      However, mark 2 is not only slow–disabling caches makes marking and
      the write barrier both much more expensive–but also imperfect. There
      is still a rare but possible race (~once per all.bash) that can cause
      GC to enter mark termination while there is still marking work. This
      race is detailed at
      https://github.com/golang/proposal/blob/master/design/17503-eliminate-rescan.md#appendix-mark-completion-race
      The effect of this is that mark termination must still cope with the
      possibility that there may be work remaining after a concurrent mark
      phase. Dealing with this increases STW pause time and increases the
      complexity of mark termination.
      
      Furthermore, a similar but far more likely race can cause early
      transition from mark 1 to mark 2. This is unfortunate because it
      causes performance instability because of the cost of mark 2.
      
      This CL fixes this by replacing mark 2 with a distributed termination
      detection algorithm. This algorithm is correct, so it eliminates the
      mark termination race, and doesn't require disabling local caches. It
      ensures that there are no grey objects upon entering mark termination.
      With this change, we're one step closer to eliminating marking from
      mark termination entirely (it's still used by STW GC and checkmarks
      mode).
      
      This CL does not eliminate the gcBlackenPromptly global flag, though
      it is always set to false now. It will be removed in a cleanup CL.
      
      This led to only minor variations in the go1 benchmarks
      (https://perf.golang.org/search?q=upload:20180909.1) and compilebench
      benchmarks (https://perf.golang.org/search?q=upload:20180910.2).
      
      This significantly improves performance of the garbage benchmark, with
      no impact on STW times:
      
      name                        old time/op    new time/op   delta
      Garbage/benchmem-MB=64-12    2.21ms ± 1%   2.05ms ± 1%   -7.38% (p=0.000 n=18+19)
      Garbage/benchmem-MB=1024-12  2.30ms ±16%   2.20ms ± 7%   -4.51% (p=0.001 n=20+20)
      
      name                        old STW-ns/GC  new STW-ns/GC  delta
      Garbage/benchmem-MB=64-12      138k ±44%     141k ±23%     ~    (p=0.309 n=19+20)
      Garbage/benchmem-MB=1024-12    159k ±25%     178k ±98%     ~    (p=0.798 n=16+18)
      
      name                        old STW-ns/op  new STW-ns/op                delta
      Garbage/benchmem-MB=64-12     4.42k ±44%    4.24k ±23%     ~    (p=0.531 n=19+20)
      Garbage/benchmem-MB=1024-12     591 ±24%      636 ±111%    ~    (p=0.309 n=16+18)
      
      (https://perf.golang.org/search?q=upload:20180910.1)
      
      Updates #26903.
      Updates #17503.
      
      Change-Id: Icbd1e12b7a12a76f423c9bf033b13cb363e4cd19
      Reviewed-on: https://go-review.googlesource.com/c/134318
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      9108ae77
    • Austin Clements's avatar
      runtime: track whether any buffer has been flushed from gcWork · a2a2901b
      Austin Clements authored
      Nothing currently consumes the flag, but we'll use it in the
      distributed termination detection algorithm.
      
      Updates #26903. This is preparation for eliminating mark 2.
      
      Change-Id: I5e149a05b1c878fe1009150da21f8bd8ae2b9b6a
      Reviewed-on: https://go-review.googlesource.com/c/134317
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      a2a2901b
    • Austin Clements's avatar
      runtime: remove GODEBUG=gctrace=2 mode · edc2d170
      Austin Clements authored
      It turns out if you set GODEBUG=gctrace=2, it enables an obscure
      debugging mode that, in addition to printing gctrace statistics, also
      does a second STW GC following each regular GC. This debugging mode
      has long since lost its value (you could maybe use it to analyze
      floating garbage, except that we don't print the gctrace line on the
      second GC), and it interferes substantially with the operation of the
      GC by messing up the statistics used to schedule GCs.
      
      It's also a source of mark termination GC work when we're in
      concurrent GC mode, so it's going to interfere with eliminating mark
      2. And it's going to get in the way of unifying STW and concurrent GC.
      
      This CL removes this debugging mode.
      
      Updates #26903. This is preparation for eliminating mark 2 and
      unifying STW GC and concurrent GC.
      
      Change-Id: Ib5bce05d8c4d5b6559c89a65165d49532165df07
      Reviewed-on: https://go-review.googlesource.com/c/134316
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      edc2d170
    • Austin Clements's avatar
      runtime: flush write barrier buffer to create work · 9c634ea8
      Austin Clements authored
      Currently, if the gcWork runs out of work, we'll fall out of the GC
      worker, even though flushing the write barrier buffer could produce
      more work. While this is not a correctness issue, it can lead to
      premature mark 2 or mark termination.
      
      Fix this by flushing the write barrier buffer if the local gcWork runs
      out of work and then checking the local gcWork again.
      
      This reduces the number of premature mark terminations during all.bash
      by about a factor of 10.
      
      Updates #26903. This is preparation for eliminating mark 2.
      
      Change-Id: I48577220b90c86bfd28d498e8603bc379a8cd617
      Reviewed-on: https://go-review.googlesource.com/c/134315
      Run-TryBot: Austin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRick Hudson <rlh@golang.org>
      9c634ea8
    • Daniel Theophanes's avatar
      database/sql: correctly report MaxIdleClosed stat · 7db509e6
      Daniel Theophanes authored
      Previously the MaxIdleClosed counter was incremented when added
      to the free connection list, rather then when it wasn't added
      to the free connection list. Flip this logic to correct.
      
      Fixes #27792
      
      Change-Id: I405302c14fb985369dab48fbe845e5651afc4ccf
      Reviewed-on: https://go-review.googlesource.com/c/138578
      Run-TryBot: Daniel Theophanes <kardianos@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      7db509e6
    • Carlos Eduardo Seo's avatar
      cmd/compile: instrinsify math/bits.Mul on ppc64x · 9aed4cc3
      Carlos Eduardo Seo authored
      Add SSA rules to intrinsify Mul/Mul64 on ppc64x.
      
      benchmark             old ns/op     new ns/op     delta
      BenchmarkMul-40       8.80          0.93          -89.43%
      BenchmarkMul32-40     1.39          1.39          +0.00%
      BenchmarkMul64-40     5.39          0.93          -82.75%
      
      Updates #24813
      
      Change-Id: I6e95bfbe976a2278bd17799df184a7fbc0e57829
      Reviewed-on: https://go-review.googlesource.com/138917Reviewed-by: default avatarLynn Boger <laboger@linux.vnet.ibm.com>
      9aed4cc3
    • Robert Griesemer's avatar
      cmd/compile: update fmt_test (fix build for long-running tests) · f5e58442
      Robert Griesemer authored
      Follow-up on https://golang.org/cl/136397.
      
      Change-Id: Ib0df690847c7c92d8de406dadc16a10507bfda39
      Reviewed-on: https://go-review.googlesource.com/c/139059Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      f5e58442
    • Richard Musiol's avatar
      misc/wasm: add mention of polyfill for Edge support · e5489cfc
      Richard Musiol authored
      Edge supports WebAssembly but not TextEncoder or TextDecoder.
      This change adds a comment pointing to a polyfill that could
      be used. The polyfill is not added by default, because we want to
      let the user decide if/how to include the polyfill.
      
      Fixes #27295
      
      Change-Id: I375f58f2168665f549997b368428c398dfbbca1c
      Reviewed-on: https://go-review.googlesource.com/139037Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      e5489cfc
    • Brad Fitzpatrick's avatar
      Revert "misc/wasm: add polyfill for TextEncoder/TextDecoder for Edge support" · ed969a0c
      Brad Fitzpatrick authored
      This reverts CL 131718, commit a0e7f127.
      
      Reason for revert: adds request overhead & dependency on third-party service for all users regardless of whether it's necessary.
      
      Updates #27295
      
      Change-Id: I4a8a9b0c8e4a3198c884dfbd90ba36734f70a9a9
      Reviewed-on: https://go-review.googlesource.com/138937Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      ed969a0c