1. 13 Sep, 2016 11 commits
    • Michael Munday's avatar
      cmd/compile: add SSA backend for s390x and enable by default · 6ec993ad
      Michael Munday authored
      The new SSA backend modifies the ABI slightly: R0 is now a usable
      general purpose register.
      
      Fixes #16677.
      
      Change-Id: I367435ce921e0c7e79e021c80cf8ef5d1d1466cf
      Reviewed-on: https://go-review.googlesource.com/28978
      Run-TryBot: Michael Munday <munday@ca.ibm.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      6ec993ad
    • Brad Fitzpatrick's avatar
      net/http: make Transport support international domain names · b7e53038
      Brad Fitzpatrick authored
      This CL makes code like this work:
      
           res, err := http.Get("https://фу.бар/баз")
      
      So far, IDNA support is limited to the http1 and http2 Transports.
      The http package is currently responsible for converting domain names
      into Punycode before calling the net layer. The http package also has
      to Punycode-ify the hostname for the Host & :authority headers for
      HTTP/1 and HTTP/2, respectively.
      
      No automatic translation from Punycode back to Unicode is performed,
      per Go's historical behavior. Docs are updated where relevant.  No
      changes needed to the Server package. Things are already in ASCII
      at that point.
      
      No changes to the net package, at least yet.
      
      Updates x/net/http2 to git rev 57c7820 for https://golang.org/cl/29071
      
      Updates #13835
      
      Change-Id: I1e9a74c60d00a197ea951a9505da5c3c3187099b
      Reviewed-on: https://go-review.googlesource.com/29072Reviewed-by: default avatarChris Broadfoot <cbro@golang.org>
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      b7e53038
    • Brad Fitzpatrick's avatar
      net/http: update bundled x/net/http2 · 802cb592
      Brad Fitzpatrick authored
      Updates x/net/http2 (and x/net/lex/httplex) to git rev 749a502 for:
      
         http2: don't sniff first Request.Body byte in Transport until we have a conn
         https://golang.org/cl/29074
         Fixes #17071
      
         http2: add Transport support for unicode domain names
         https://golang.org/cl/29071
         Updates #13835
      
         http2: don't send bogus :path pseudo headers if Request.URL.Opaque is set
         https://golang.org/cl/27632
           +
         http2: fix bug where '*' as a valid :path value in Transport
         https://golang.org/cl/29070
         Updates #16847
      
         http2: fix all vet warnings
         https://golang.org/cl/28344
         Updates #16228
         Updates #11041
      
      Also uses the new -underscore flag to x/tools/cmd/bundle from
      https://golang.org/cl/29086
      
      Change-Id: Ica0f6bf6e33266237e37527a166a783d78c059c4
      Reviewed-on: https://go-review.googlesource.com/29110
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarChris Broadfoot <cbro@golang.org>
      802cb592
    • Josh Bleecher Snyder's avatar
      runtime: limit the number of map overflow buckets · 9980b70c
      Josh Bleecher Snyder authored
      Consider repeatedly adding many items to a map
      and then deleting them all, as in #16070. The map
      itself doesn't need to grow above the high water
      mark of number of items. However, due to random
      collisions, the map can accumulate overflow
      buckets.
      
      Prior to this CL, those overflow buckets were
      never removed, which led to a slow memory leak.
      
      The problem with removing overflow buckets is
      iterators. The obvious approach is to repack
      keys and values and eliminate unused overflow
      buckets. However, keys, values, and overflow
      buckets cannot be manipulated without disrupting
      iterators.
      
      This CL takes a different approach, which is to
      reuse the existing map growth mechanism,
      which is well established, well tested, and
      safe in the presence of iterators.
      When a map has accumulated enough overflow buckets
      we trigger map growth, but grow into a map of the
      same size as before. The old overflow buckets will
      be left behind for garbage collection.
      
      For the code in #16070, instead of climbing
      (very slowly) forever, memory usage now cycles
      between 264mb and 483mb every 15 minutes or so.
      
      To avoid increasing the size of maps,
      the overflow bucket counter is only 16 bits.
      For large maps, the counter is incremented
      stochastically.
      
      Fixes #16070
      
      Change-Id: If551d77613ec6836907efca58bda3deee304297e
      Reviewed-on: https://go-review.googlesource.com/25049
      Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      9980b70c
    • Robert Griesemer's avatar
      cmd/compile: reduce allocs some more · 0cd3ecb0
      Robert Griesemer authored
      Also: update fmt_test.go.
      
      Together with the previous commits, we are now at or below c85b77c2
      levels in terms of allocation for the benchmark described in #16897
      (old = c85b77c2, new = this commit):
      
      name       old time/op     new time/op     delta
      Template       297ms ± 5%      284ms ± 3%  -4.53%  (p=0.000 n=27+29)
      Unicode        159ms ± 5%      151ms ± 5%  -4.91%  (p=0.000 n=28+30)
      GoTypes        985ms ± 5%      935ms ± 2%  -5.13%  (p=0.000 n=28+29)
      
      name       old alloc/op    new alloc/op    delta
      Template      46.8MB ± 0%     45.7MB ± 0%  -2.37%  (p=0.000 n=30+30)
      Unicode       37.8MB ± 0%     37.9MB ± 0%  +0.29%  (p=0.000 n=29+30)
      GoTypes        143MB ± 0%      138MB ± 0%  -3.64%  (p=0.000 n=29+30)
      
      name       old allocs/op   new allocs/op   delta
      Template        444k ± 0%       440k ± 0%  -0.94%  (p=0.000 n=30+30)
      Unicode         369k ± 0%       369k ± 0%  +0.19%  (p=0.000 n=29+30)
      GoTypes        1.35M ± 0%      1.34M ± 0%  -1.24%  (p=0.000 n=30+30)
      
      For #16897.
      
      Change-Id: Iedbeb408e2f1e68dd4a3201bf8813c8066ebf7ed
      Reviewed-on: https://go-review.googlesource.com/29089Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      0cd3ecb0
    • Lynn Boger's avatar
      cmd/asm: ppc64le support for ISEL for use by SSA · b6946fb1
      Lynn Boger authored
      This adds the support for the ppc64le isel instruction so
      it can be used by SSA.
      
      Fixed #16771
      
      Change-Id: Ia2517f0834ff5e7ad927e218b84493e0106ab4a7
      Reviewed-on: https://go-review.googlesource.com/28611Reviewed-by: default avatarDavid Chase <drchase@google.com>
      Run-TryBot: David Chase <drchase@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      b6946fb1
    • Paul Borman's avatar
      text/template: improve lexer performance in finding left delimiters. · 07b80113
      Paul Borman authored
      The existing implementation calls l.next for each run up to the next
      instance of the left delimiter ({{).  For ascii text, this is multiple
      function calls per byte.  Change to use strings.Index to find the left
      delimiter.  The performace improvement ranges from 1:1 (no text outside
      of {{}}'s) to multiple times faster (9:1 was seen on 8K of text with no
      {{ }}'s).
      
      Change-Id: I2f82bea63b78b6714f09a725f7b2bbb00a3448a3
      Reviewed-on: https://go-review.googlesource.com/24863Reviewed-by: default avatarRob Pike <r@golang.org>
      Run-TryBot: Rob Pike <r@golang.org>
      07b80113
    • Michael Hudson-Doyle's avatar
      cmd/link: fix -buildmode=pie / -linkshared combination · 8f9671d1
      Michael Hudson-Doyle authored
      main.main and main.init were not being marked as reachable.
      
      Fixes #17076
      
      Change-Id: Ib3e29bd35ba6252962e6ba89173ca321ed6849b9
      Reviewed-on: https://go-review.googlesource.com/28996Reviewed-by: default avatarDavid Crawshaw <crawshaw@golang.org>
      Run-TryBot: David Crawshaw <crawshaw@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      8f9671d1
    • Cherry Zhang's avatar
      cmd/compile, runtime/internal/atomic: intrinsify And8, Or8 on ARM64 · 38d35e71
      Cherry Zhang authored
      Also add assembly implementation, in case intrinsics is disabled.
      
      Change-Id: Iff0a8a8ce326651bd29f6c403f5ec08dd3629993
      Reviewed-on: https://go-review.googlesource.com/28979
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      38d35e71
    • Robert Griesemer's avatar
      cmd/compile: remove another bytes.Buffer use in fmt.go · 09686a58
      Robert Griesemer authored
      Missed in prior commit.
      
      Change-Id: Ib3a41fb4e4d41feeb28c316fe70a329c73e72379
      Reviewed-on: https://go-review.googlesource.com/29088
      Run-TryBot: Robert Griesemer <gri@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      09686a58
    • Robert Griesemer's avatar
      cmd/compile: reduce allocs to c85b77c2 (pre-fmt.go change) levels · 37d452c3
      Robert Griesemer authored
      Linker and reflect info generation (reflect.go) relies on formatting
      of types (tconv). The fmt.Format based approach introduces extra
      allocations, which matter in those cases. Resurrected sconv and tconv
      code from commit c85b77c2 (fmt.go only); and adjusted it slightly.
      The formatter-based approach is still used throughout the rest of the
      compiler, but reflect.go now uses the tconv method that simply returns
      the desired string.
      
      (The timing data below may not be accurate; I've included it only for
      comparison with the numbers in issue #16897).
      
      name       old time/op     new time/op     delta
      Template       297ms ± 2%      288ms ± 3%  -3.12%        (p=0.000 n=27+29)
      Unicode        155ms ± 5%      150ms ± 5%  -3.26%        (p=0.000 n=30+30)
      GoTypes        1.00s ± 3%      0.95s ± 3%  -4.51%        (p=0.000 n=28+29)
      
      name       old alloc/op    new alloc/op    delta
      Template      46.8MB ± 0%     46.5MB ± 0%  -0.65%        (p=0.000 n=28+30)
      Unicode       37.9MB ± 0%     37.8MB ± 0%  -0.24%        (p=0.000 n=29+30)
      GoTypes        144MB ± 0%      143MB ± 0%  -0.68%        (p=0.000 n=30+30)
      
      name       old allocs/op   new allocs/op   delta
      Template        469k ± 0%       446k ± 0%  -5.01%        (p=0.000 n=29+30)
      Unicode         375k ± 0%       369k ± 0%  -1.62%        (p=0.000 n=30+28)
      GoTypes        1.47M ± 0%      1.37M ± 0%  -6.29%        (p=0.000 n=30+30)
      
      The code for sconv/tconv in fmt.go now closely match the code from c85b77c2
      again; except that the functions are now methods. Removing the use of
      the bytes.Buffer in tconv and special-caseing interface{} has helped a
      small amount as well:
      
      name       old time/op     new time/op     delta
      Template       299ms ± 3%      288ms ± 3%  -3.83%        (p=0.000 n=29+29)
      Unicode        156ms ± 5%      150ms ± 5%  -3.56%        (p=0.000 n=30+30)
      GoTypes        960ms ± 2%      954ms ± 3%  -0.58%        (p=0.037 n=26+29)
      
      name       old alloc/op    new alloc/op    delta
      Template      46.6MB ± 0%     46.5MB ± 0%  -0.22%        (p=0.000 n=30+30)
      Unicode       37.8MB ± 0%     37.8MB ± 0%    ~           (p=0.075 n=30+30)
      GoTypes        143MB ± 0%      143MB ± 0%  -0.31%        (p=0.000 n=30+30)
      
      name       old allocs/op   new allocs/op   delta
      Template        447k ± 0%       446k ± 0%  -0.28%        (p=0.000 n=30+30)
      Unicode         369k ± 0%       369k ± 0%  -0.03%        (p=0.032 n=30+28)
      GoTypes        1.38M ± 0%      1.37M ± 0%  -0.35%        (p=0.000 n=29+30)
      
      Comparison between c85b77c2 and now (see issue #16897):
      
      name       old time/op     new time/op     delta
      Template       307ms ± 4%      288ms ± 3%  -6.24%  (p=0.000 n=29+29)
      Unicode        164ms ± 4%      150ms ± 5%  -8.20%  (p=0.000 n=30+30)
      GoTypes        1.01s ± 3%      0.95s ± 3%  -5.72%  (p=0.000 n=30+29)
      
      name       old alloc/op    new alloc/op    delta
      Template      46.8MB ± 0%     46.5MB ± 0%  -0.66%  (p=0.000 n=29+30)
      Unicode       37.8MB ± 0%     37.8MB ± 0%  -0.13%  (p=0.000 n=30+30)
      GoTypes        143MB ± 0%      143MB ± 0%  -0.11%  (p=0.000 n=30+30)
      
      name       old allocs/op   new allocs/op   delta
      Template        444k ± 0%       446k ± 0%  +0.48%  (p=0.000 n=30+30)
      Unicode         369k ± 0%       369k ± 0%  +0.09%  (p=0.000 n=30+28)
      GoTypes        1.35M ± 0%      1.37M ± 0%  +1.47%  (p=0.000 n=30+30)
      
      There's still a small increase (< 1.5%) for GoTypes but pending a complete
      rewrite of fmt.go, this seems ok again.
      
      Fixes #16897.
      
      Change-Id: I7e0e56cd1b9f981252eded917f5752259d402354
      Reviewed-on: https://go-review.googlesource.com/29087
      Run-TryBot: Robert Griesemer <gri@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      37d452c3
  2. 12 Sep, 2016 23 commits
  3. 11 Sep, 2016 6 commits