Permalink
Switch branches/tags
weekly.2012-03-27 weekly.2012-03-22 weekly.2012-03-13 weekly.2012-03-04 weekly.2012-02-22 weekly.2012-02-14 weekly.2012-02-07 weekly.2012-01-27 weekly.2012-01-20 weekly.2012-01-15 weekly.2011-12-22 weekly.2011-12-14 weekly.2011-12-06 weekly.2011-12-02 weekly.2011-12-01 weekly.2011-11-18 weekly.2011-11-09 weekly.2011-11-08 weekly.2011-11-02 weekly.2011-11-01 weekly.2011-10-26 weekly.2011-10-25 weekly.2011-10-18 weekly.2011-10-06 weekly.2011-09-21 weekly.2011-09-16 weekly.2011-09-07 weekly.2011-09-01 weekly.2011-08-17 weekly.2011-08-10 weekly.2011-07-29 weekly.2011-07-19 weekly.2011-07-07 weekly.2011-06-23 weekly.2011-06-16 weekly.2011-06-09 weekly.2011-06-02 weekly.2011-05-22 weekly.2011-04-27 weekly.2011-04-13 weekly.2011-04-04 weekly.2011-03-28 weekly.2011-03-15 weekly.2011-03-07.1 weekly.2011-03-07 weekly.2011-02-24 weekly.2011-02-15 weekly.2011-02-01.1 weekly.2011-02-01 weekly.2011-01-20 weekly.2011-01-19 weekly.2011-01-12 weekly.2011-01-06 weekly.2010-12-22 weekly.2010-12-15.1 weekly.2010-12-15 weekly.2010-12-08 weekly.2010-12-02 weekly.2010-11-23 weekly.2010-11-10 weekly.2010-11-02 weekly.2010-10-27 weekly.2010-10-20 weekly.2010-10-13.1 weekly.2010-10-13 weekly.2010-09-29 weekly.2010-09-22 weekly.2010-09-15 weekly.2010-09-06 weekly.2010-08-25 weekly.2010-08-11 weekly.2010-08-04 weekly.2010-07-29 weekly.2010-07-14 weekly.2010-07-01 weekly.2010-06-21 weekly.2010-06-09 weekly.2010-05-27 weekly.2010-05-04 weekly.2010-04-27 weekly.2010-04-13 weekly.2010-03-30 weekly.2010-03-22 weekly.2010-03-15 weekly.2010-03-04 weekly.2010-02-23 weekly.2010-02-17 weekly.2010-02-04 weekly.2010-01-27 weekly.2010-01-13 weekly.2010-01-05 weekly.2009-12-22 weekly.2009-12-09 weekly.2009-12-07 weekly.2009-11-17 weekly.2009-11-12 weekly.2009-11-10.1 weekly.2009-11-10 weekly.2009-11-06 weekly
Nothing to show
Commits on Oct 6, 2017
  1. cmd/compile: optimize signed non-negative div/mod by a power of 2

    valyala authored and randall77 committed Sep 22, 2017
    This CL optimizes assembly for len() or cap() division
    by a power of 2 constants:
    
        func lenDiv(s []int) int {
            return len(s) / 16
        }
    
    amd64 assembly before the CL:
    
        MOVQ    "".s+16(SP), AX
        MOVQ    AX, CX
        SARQ    $63, AX
        SHRQ    $60, AX
        ADDQ    CX, AX
        SARQ    $4, AX
        MOVQ    AX, "".~r1+32(SP)
        RET
    
    amd64 assembly after the CL:
    
        MOVQ    "".s+16(SP), AX
        SHRQ    $4, AX
        MOVQ    AX, "".~r1+32(SP)
        RET
    
    The CL relies on the fact that len() and cap() result cannot
    be negative.
    
    Trigger stats for the added SSA rules on linux/amd64 when running
    make.bash:
    
         46 Div64
         12 Mod64
    
    The added SSA rules may trigger on more cases in the future
    when SSA values will be populated with the info on their
    lower bounds.
    
    For instance:
    
        func f(i int16) int16 {
            if i < 3 {
                return -1
            }
    
            // Lower bound of i is 3 here -> i is non-negative,
            // so unsigned arithmetics may be used here.
            return i % 16
        }
    
    Change-Id: I8bc6be5a03e71157ced533c01416451ff6f1a7f0
    Reviewed-on: https://go-review.googlesource.com/65530
    Reviewed-by: Keith Randall <khr@golang.org>
Commits on Sep 12, 2017
  1. runtime: optimize siftupTimer and siftdownTimer a bit

    valyala authored and ianlancetaylor committed Sep 12, 2017
    Write the moving timer only once, since it is overwritten
    by swapped timers on all the iterations except the last one.
    
    Additionally, explicitly pass timers heap into siftupTimer
    and siftdownTimer in order to make the code more clear.
    
    Relevant benchmark results on linux/amd64:
    
    Stop                      700µs ± 7%   608µs ± 1%  -13.13%  (p=0.000 n=10+10)
    Stop-2                    440µs ± 4%   376µs ± 4%  -14.48%  (p=0.000 n=10+10)
    Stop-4                    339µs ± 2%   330µs ± 3%   -2.66%  (p=0.015 n=10+10)
    SimultaneousAfterFunc     702µs ± 9%   709µs ± 1%     ~     (p=0.436 n=9+9)
    SimultaneousAfterFunc-2   573µs ± 2%   546µs ± 2%   -4.71%  (p=0.000 n=10+10)
    SimultaneousAfterFunc-4   387µs ± 1%   368µs ± 1%   -4.89%  (p=0.000 n=8+10)
    StartStop                 268µs ± 0%   270µs ± 0%   +0.91%  (p=0.000 n=9+9)
    StartStop-2               155µs ± 6%   145µs ± 6%   -6.70%  (p=0.000 n=10+10)
    StartStop-4               125µs ± 1%   124µs ± 1%     ~     (p=0.065 n=10+9)
    
    Change-Id: I3685835b5e3e82844e2e5e73ee03a1e22100bf0e
    Reviewed-on: https://go-review.googlesource.com/63110
    Reviewed-by: Ian Lance Taylor <iant@golang.org>
    Run-TryBot: Ian Lance Taylor <iant@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
  2. runtime: improve timers scalability on multi-CPU systems

    valyala authored and ianlancetaylor committed Jan 6, 2017
    Use per-P timers, so each P may work with its own timers.
    
    This CL improves performance on multi-CPU systems
    in the following cases:
    
    - When serving high number of concurrent connections
      with read/write deadlines set (for instance, highly loaded
      net/http server).
    
    - When using high number of concurrent timers. These timers
      may be implicitly created via context.WithDeadline
      or context.WithTimeout.
    
    Production servers should usually set timeout on connections
    and external requests in order to prevent from resource leakage.
    See https://blog.cloudflare.com/the-complete-guide-to-golang-net-http-timeouts/
    
    Below are relevant benchmark results for various GOMAXPROCS values
    on linux/amd64:
    
    context package:
    
    name                                     old time/op  new time/op  delta
    WithTimeout/concurrency=40      4.92µs ± 0%  5.17µs ± 1%  +5.07%  (p=0.000 n=9+9)
    WithTimeout/concurrency=4000    6.03µs ± 1%  6.49µs ± 0%  +7.63%  (p=0.000 n=8+10)
    WithTimeout/concurrency=400000  8.58µs ± 7%  9.02µs ± 4%  +5.02%  (p=0.019 n=10+10)
    
    name                                     old time/op  new time/op  delta
    WithTimeout/concurrency=40-2      3.70µs ± 1%  2.78µs ± 4%  -24.90%  (p=0.000 n=8+9)
    WithTimeout/concurrency=4000-2    4.49µs ± 4%  3.67µs ± 5%  -18.26%  (p=0.000 n=10+10)
    WithTimeout/concurrency=400000-2  6.16µs ±10%  5.15µs ±13%  -16.30%  (p=0.000 n=10+10)
    
    name                                     old time/op  new time/op  delta
    WithTimeout/concurrency=40-4      3.58µs ± 1%  2.64µs ± 2%  -26.13%  (p=0.000 n=9+10)
    WithTimeout/concurrency=4000-4    4.17µs ± 0%  3.32µs ± 1%  -20.36%  (p=0.000 n=10+10)
    WithTimeout/concurrency=400000-4  5.57µs ± 9%  4.83µs ±10%  -13.27%  (p=0.001 n=10+10)
    
    time package:
    
    name                     old time/op  new time/op  delta
    AfterFunc                6.15ms ± 3%  6.07ms ± 2%     ~     (p=0.133 n=10+9)
    AfterFunc-2              3.43ms ± 1%  3.56ms ± 1%   +3.91%  (p=0.000 n=10+9)
    AfterFunc-4              5.04ms ± 2%  2.36ms ± 0%  -53.20%  (p=0.000 n=10+9)
    After                    6.54ms ± 2%  6.49ms ± 3%     ~     (p=0.393 n=10+10)
    After-2                  3.68ms ± 1%  3.87ms ± 0%   +5.14%  (p=0.000 n=9+9)
    After-4                  6.66ms ± 1%  2.87ms ± 1%  -56.89%  (p=0.000 n=10+10)
    Stop                      698µs ± 2%   689µs ± 1%   -1.26%  (p=0.011 n=10+10)
    Stop-2                    729µs ± 2%   434µs ± 3%  -40.49%  (p=0.000 n=10+10)
    Stop-4                    837µs ± 3%   333µs ± 2%  -60.20%  (p=0.000 n=10+10)
    SimultaneousAfterFunc     694µs ± 1%   692µs ± 7%     ~     (p=0.481 n=10+10)
    SimultaneousAfterFunc-2   714µs ± 3%   569µs ± 2%  -20.33%  (p=0.000 n=10+10)
    SimultaneousAfterFunc-4   782µs ± 2%   386µs ± 2%  -50.67%  (p=0.000 n=10+10)
    StartStop                 267µs ± 3%   274µs ± 0%   +2.64%  (p=0.000 n=8+9)
    StartStop-2               238µs ± 2%   140µs ± 3%  -40.95%  (p=0.000 n=10+8)
    StartStop-4               320µs ± 1%   125µs ± 1%  -61.02%  (p=0.000 n=9+9)
    Reset                    75.0µs ± 1%  77.5µs ± 2%   +3.38%  (p=0.000 n=10+10)
    Reset-2                   150µs ± 2%    40µs ± 5%  -73.09%  (p=0.000 n=10+9)
    Reset-4                   226µs ± 1%    33µs ± 1%  -85.42%  (p=0.000 n=10+10)
    Sleep                     857µs ± 6%   878µs ± 9%     ~     (p=0.079 n=10+9)
    Sleep-2                   617µs ± 4%   585µs ± 2%   -5.21%  (p=0.000 n=10+10)
    Sleep-4                   689µs ± 3%   465µs ± 4%  -32.53%  (p=0.000 n=10+10)
    Ticker                   55.9ms ± 2%  55.9ms ± 2%     ~     (p=0.971 n=10+10)
    Ticker-2                 28.7ms ± 2%  28.1ms ± 1%   -2.06%  (p=0.000 n=10+10)
    Ticker-4                 14.6ms ± 0%  13.6ms ± 1%   -6.80%  (p=0.000 n=9+10)
    
    Fixes #15133
    
    Change-Id: I6f4b09d2db8c5bec93146db6501b44dbfe5c0ac4
    Reviewed-on: https://go-review.googlesource.com/34784
    Reviewed-by: Austin Clements <austin@google.com>
Commits on Aug 29, 2017
  1. cmd/vet: unexported Stringer and error fields cannot be formatted

    valyala authored and robpike committed Jun 5, 2017
    According to CL 31817, fmt cannot invoke String or Error methods
    on unexported struct fields.
    
    Fixes #17798.
    
    Change-Id: I0d516577298bc36daa9a94313c3874d64dc079e6
    Reviewed-on: https://go-review.googlesource.com/44831
    Reviewed-by: Rob Pike <r@golang.org>
Commits on Aug 25, 2017
  1. strconv: optimize Atoi for common case

    valyala authored and griesemer committed Jun 2, 2017
    Benchmark results on GOOS=linux:
    
    GOARCH=amd64
    
    name              old time/op  new time/op  delta
    Atoi/Pos/7bit-4   20.1ns ± 2%   8.6ns ± 1%  -57.34%  (p=0.000 n=10+10)
    Atoi/Pos/26bit-4  25.8ns ± 7%  11.9ns ± 0%  -53.91%  (p=0.000 n=10+8)
    Atoi/Pos/31bit-4  27.3ns ± 2%  13.2ns ± 1%  -51.56%  (p=0.000 n=10+10)
    Atoi/Pos/56bit-4  37.2ns ± 5%  18.2ns ± 1%  -51.26%  (p=0.000 n=10+10)
    Atoi/Pos/63bit-4  38.7ns ± 1%  38.6ns ± 1%     ~     (p=0.297 n=9+10)
    Atoi/Neg/7bit-4   17.6ns ± 1%   7.2ns ± 0%  -59.22%  (p=0.000 n=10+10)
    Atoi/Neg/26bit-4  24.4ns ± 1%  12.4ns ± 1%  -49.28%  (p=0.000 n=10+10)
    Atoi/Neg/31bit-4  26.9ns ± 0%  14.0ns ± 1%  -47.88%  (p=0.000 n=7+10)
    Atoi/Neg/56bit-4  36.2ns ± 1%  19.5ns ± 0%  -46.24%  (p=0.000 n=10+9)
    Atoi/Neg/63bit-4  38.9ns ± 1%  38.8ns ± 1%     ~     (p=0.385 n=9+10)
    
    GOARCH=386
    
    name              old time/op  new time/op  delta
    Atoi/Pos/7bit-4   89.6ns ± 1%   8.2ns ± 1%  -90.84%  (p=0.000 n=9+10)
    Atoi/Pos/26bit-4   187ns ± 2%    12ns ± 1%  -93.71%  (p=0.000 n=10+9)
    Atoi/Pos/31bit-4   225ns ± 1%   225ns ± 1%     ~     (p=0.995 n=10+10)
    Atoi/Neg/7bit-4   86.2ns ± 1%   8.5ns ± 1%  -90.14%  (p=0.000 n=10+10)
    Atoi/Neg/26bit-4   183ns ± 1%    13ns ± 1%  -92.77%  (p=0.000 n=9+10)
    Atoi/Neg/31bit-4   223ns ± 0%   223ns ± 0%     ~     (p=0.247 n=8+9)
    
    Fixes #20557
    
    Change-Id: Ib6245d88cffd4b037419e2bf8e4a71b86c6d773f
    Reviewed-on: https://go-review.googlesource.com/44692
    Reviewed-by: Robert Griesemer <gri@golang.org>
    Reviewed-by: Keith Randall <khr@golang.org>
Commits on Jun 28, 2017
  1. sync: deflake TestPool and TestPoolNew

    valyala authored and bradfitz committed May 25, 2017
    Prevent possible goroutine rescheduling to another P between
    Put and Get calls by locking the goroutine to OS thread.
    
    Inspired by the CL 42770.
    
    Fixes #20198.
    
    Change-Id: I18e24fcad1630658713e6b9d80d90d7941f604be
    Reviewed-on: https://go-review.googlesource.com/44310
    Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
    Reviewed-by: Ian Lance Taylor <iant@golang.org>
    Reviewed-by: Austin Clements <austin@google.com>
Commits on May 30, 2017
  1. cmd/vet: add a test for embedded stringer

    valyala authored and robpike committed May 29, 2017
    This should help narrowing down the possible cause of #20514.
    
    Updates #20514.
    
    Change-Id: Ie997400c9749aace7783bd585b23dbb4cefc181d
    Reviewed-on: https://go-review.googlesource.com/44375
    Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
    Reviewed-by: Rob Pike <r@golang.org>
    Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Apr 26, 2017
  1. runtime: align mcentral by cache line size

    valyala authored and ianlancetaylor committed Apr 24, 2017
    This may improve perormance during concurrent access
    to mheap.central array from multiple CPU cores.
    
    Change-Id: I8f48dd2e72aa62e9c32de07ae60fe552d8642782
    Reviewed-on: https://go-review.googlesource.com/41550
    Reviewed-by: Austin Clements <austin@google.com>
    Reviewed-by: Ian Lance Taylor <iant@golang.org>
    Run-TryBot: Ian Lance Taylor <iant@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Apr 20, 2017
  1. sync: align poolLocal to CPU cache line size

    valyala authored and ianlancetaylor committed Apr 18, 2017
    Make poolLocal size multiple of 128, so it aligns to CPU cache line
    on the most common architectures.
    
    This also has the following benefits:
    
    - It may help compiler substituting integer multiplication
      by bit shift inside indexLocal.
    - It shrinks poolLocal size from 176 bytes to 128 bytes on amd64,
      so now it fits two cache lines (or a single cache line on certain
      Intel CPUs - see https://software.intel.com/en-us/articles/optimizing-application-performance-on-intel-coret-microarchitecture-using-hardware-implemented-prefetchers).
    
    No measurable performance changes on linux/amd64 and linux/386.
    
    Change-Id: I11df0f064718a662e77a85d88b8a15a8919f25e9
    Reviewed-on: https://go-review.googlesource.com/40918
    Reviewed-by: Dmitry Vyukov <dvyukov@google.com>
    Run-TryBot: Dmitry Vyukov <dvyukov@google.com>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Apr 19, 2017
  1. cmd/vet: skip unreachable "if" and "case" code in shift check.

    valyala authored and robpike committed Mar 13, 2017
    Such dead code is legitimate when dealing with arch-specific
    types (int, uint, uintptr).
    
    The CL removes the majority of 'too small for shift' false positives
    from such a code.
    
    Change-Id: I62c5635a1d3774ab2d71d3d7056f0589f214cbe5
    Reviewed-on: https://go-review.googlesource.com/38065
    Run-TryBot: Rob Pike <r@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
    Reviewed-by: Rob Pike <r@golang.org>
Commits on Apr 18, 2017
  1. sync: improve Pool performance

    valyala authored and ianlancetaylor committed Apr 17, 2017
    Rewrite indexLocal to achieve higher performance.
    
    Performance results on linux/amd64:
    
    name            old time/op  new time/op  delta
    Pool-4          19.1ns ± 2%  10.1ns ± 1%  -47.15%  (p=0.000 n=10+8)
    PoolOverflow-4  3.11µs ± 1%  2.10µs ± 2%  -32.66%  (p=0.000 n=10+10)
    
    Performance results on linux/386:
    
    name            old time/op  new time/op  delta
    Pool-4          20.0ns ± 2%  13.1ns ± 1%  -34.59%  (p=0.000 n=10+9)
    PoolOverflow-4  3.51µs ± 1%  2.49µs ± 0%  -28.99%  (p=0.000 n=10+8)
    
    Change-Id: I7d57a2d4cd47ec43d09ca1267bde2e3f05a9faa9
    Reviewed-on: https://go-review.googlesource.com/40913
    Reviewed-by: Ian Lance Taylor <iant@golang.org>
    Run-TryBot: Ian Lance Taylor <iant@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Mar 22, 2017
  1. strconv: optimize decimal ints formatting with smallsString

    valyala authored and griesemer committed Mar 16, 2017
    Benchmark results for GOARCH=amd64:
    
    name                                     old time/op  new time/op  delta
    FormatInt-4                              2.51µs ± 2%  2.40µs ± 2%   -4.51%  (p=0.000 n=9+10)
    AppendInt-4                              1.67µs ± 2%  1.61µs ± 3%   -3.74%  (p=0.000 n=9+9)
    FormatUint-4                              698ns ± 2%   643ns ± 3%   -7.95%  (p=0.000 n=10+8)
    AppendUint-4                              478ns ± 1%   418ns ± 2%  -12.61%  (p=0.000 n=8+10)
    AppendUintVarlen/1-4                     9.30ns ± 6%  9.15ns ± 1%     ~     (p=0.199 n=9+10)
    AppendUintVarlen/12-4                    9.12ns ± 0%  9.16ns ± 2%     ~     (p=0.307 n=9+9)
    AppendUintVarlen/123-4                   18.6ns ± 2%  18.7ns ± 0%     ~     (p=0.091 n=10+6)
    AppendUintVarlen/1234-4                  19.1ns ± 4%  17.7ns ± 1%   -7.35%  (p=0.000 n=10+9)
    AppendUintVarlen/12345-4                 21.5ns ± 3%  20.7ns ± 3%   -3.78%  (p=0.002 n=9+10)
    AppendUintVarlen/123456-4                23.5ns ± 3%  20.9ns ± 1%  -11.14%  (p=0.000 n=10+9)
    AppendUintVarlen/1234567-4               25.0ns ± 2%  23.6ns ± 7%   -5.48%  (p=0.004 n=9+10)
    AppendUintVarlen/12345678-4              26.8ns ± 2%  23.4ns ± 2%  -12.79%  (p=0.000 n=9+10)
    AppendUintVarlen/123456789-4             29.8ns ± 3%  26.5ns ± 5%  -11.03%  (p=0.000 n=10+10)
    AppendUintVarlen/1234567890-4            31.6ns ± 3%  26.9ns ± 3%  -14.95%  (p=0.000 n=10+9)
    AppendUintVarlen/12345678901-4           33.8ns ± 3%  29.3ns ± 5%  -13.21%  (p=0.000 n=10+10)
    AppendUintVarlen/123456789012-4          35.5ns ± 4%  29.2ns ± 4%  -17.82%  (p=0.000 n=10+10)
    AppendUintVarlen/1234567890123-4         37.6ns ± 4%  31.4ns ± 3%  -16.48%  (p=0.000 n=10+10)
    AppendUintVarlen/12345678901234-4        39.8ns ± 6%  32.0ns ± 7%  -19.60%  (p=0.000 n=10+10)
    AppendUintVarlen/123456789012345-4       40.7ns ± 0%  34.4ns ± 4%  -15.55%  (p=0.000 n=6+10)
    AppendUintVarlen/1234567890123456-4      45.4ns ± 6%  35.1ns ± 4%  -22.66%  (p=0.000 n=10+10)
    AppendUintVarlen/12345678901234567-4     45.1ns ± 1%  36.7ns ± 4%  -18.77%  (p=0.000 n=9+10)
    AppendUintVarlen/123456789012345678-4    46.9ns ± 0%  36.4ns ± 3%  -22.49%  (p=0.000 n=9+10)
    AppendUintVarlen/1234567890123456789-4   50.6ns ± 6%  38.8ns ± 3%  -23.28%  (p=0.000 n=10+10)
    AppendUintVarlen/12345678901234567890-4  51.3ns ± 2%  38.4ns ± 0%  -25.00%  (p=0.000 n=9+8)
    
    Benchmark results for GOARCH=386:
    
    name                                     old time/op  new time/op  delta
    FormatInt-4                              6.21µs ± 0%  6.14µs ± 0%  -1.11%  (p=0.008 n=5+5)
    AppendInt-4                              4.95µs ± 0%  4.85µs ± 0%  -1.99%  (p=0.016 n=5+4)
    FormatUint-4                             1.89µs ± 1%  1.83µs ± 1%  -2.94%  (p=0.008 n=5+5)
    AppendUint-4                             1.59µs ± 0%  1.57µs ± 2%  -1.72%  (p=0.040 n=5+5)
    FormatIntSmall-4                         8.48ns ± 0%  8.48ns ± 0%    ~     (p=0.905 n=5+5)
    AppendIntSmall-4                         12.2ns ± 0%  12.2ns ± 0%    ~     (all equal)
    AppendUintVarlen/1-4                     10.6ns ± 1%  10.7ns ± 0%    ~     (p=0.238 n=5+4)
    AppendUintVarlen/12-4                    10.7ns ± 0%  10.7ns ± 1%    ~     (p=0.333 n=4+5)
    AppendUintVarlen/123-4                   29.9ns ± 1%  30.2ns ± 0%  +1.07%  (p=0.016 n=5+4)
    AppendUintVarlen/1234-4                  32.4ns ± 1%  30.4ns ± 0%  -6.30%  (p=0.008 n=5+5)
    AppendUintVarlen/12345-4                 35.1ns ± 2%  34.9ns ± 0%    ~     (p=0.238 n=5+5)
    AppendUintVarlen/123456-4                36.6ns ± 0%  35.3ns ± 0%  -3.55%  (p=0.029 n=4+4)
    AppendUintVarlen/1234567-4               38.9ns ± 0%  39.6ns ± 0%  +1.80%  (p=0.029 n=4+4)
    AppendUintVarlen/12345678-4              41.3ns ± 0%  40.1ns ± 0%  -2.91%  (p=0.000 n=5+4)
    AppendUintVarlen/123456789-4             44.9ns ± 1%  44.8ns ± 0%    ~     (p=0.667 n=5+5)
    AppendUintVarlen/1234567890-4            65.6ns ± 0%  66.2ns ± 1%  +0.88%  (p=0.016 n=4+5)
    AppendUintVarlen/12345678901-4           77.9ns ± 0%  76.3ns ± 0%  -2.00%  (p=0.000 n=4+5)
    AppendUintVarlen/123456789012-4          80.7ns ± 0%  79.1ns ± 1%  -2.01%  (p=0.008 n=5+5)
    AppendUintVarlen/1234567890123-4         83.6ns ± 0%  80.2ns ± 1%  -4.07%  (p=0.008 n=5+5)
    AppendUintVarlen/12345678901234-4        86.2ns ± 1%  83.3ns ± 0%  -3.39%  (p=0.008 n=5+5)
    AppendUintVarlen/123456789012345-4       88.5ns ± 0%  83.7ns ± 0%  -5.42%  (p=0.008 n=5+5)
    AppendUintVarlen/1234567890123456-4      90.6ns ± 0%  88.3ns ± 0%  -2.54%  (p=0.008 n=5+5)
    AppendUintVarlen/12345678901234567-4     92.7ns ± 0%  89.0ns ± 1%  -4.01%  (p=0.008 n=5+5)
    AppendUintVarlen/123456789012345678-4    95.6ns ± 1%  92.6ns ± 0%  -3.18%  (p=0.016 n=5+4)
    AppendUintVarlen/1234567890123456789-4    118ns ± 0%   114ns ± 0%    ~     (p=0.079 n=4+5)
    AppendUintVarlen/12345678901234567890-4   138ns ± 0%   136ns ± 0%  -1.45%  (p=0.008 n=5+5)
    
    Updates #19445
    
    Change-Id: Iafbe5c074898187c150dc3854e5b9fc19c10be05
    Reviewed-on: https://go-review.googlesource.com/38255
    Run-TryBot: Robert Griesemer <gri@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
    Reviewed-by: Robert Griesemer <gri@golang.org>
Commits on Mar 16, 2017
  1. strconv: optimize formatting for small decimal ints

    valyala authored and griesemer committed Mar 9, 2017
    Avoid memory allocations by returning pre-calculated strings
    for decimal ints in the range 0..99.
    
    Benchmark results:
    
    name              old time/op    new time/op    delta
    FormatInt-4         2.45µs ± 1%    2.40µs ± 1%    -1.86%  (p=0.000 n=8+9)
    AppendInt-4         1.67µs ± 1%    1.65µs ± 0%    -0.92%  (p=0.000 n=10+10)
    FormatUint-4         676ns ± 3%     669ns ± 1%      ~     (p=0.146 n=10+10)
    AppendUint-4         467ns ± 2%     474ns ± 0%    +1.58%  (p=0.000 n=10+10)
    FormatIntSmall-4    29.6ns ± 2%     3.3ns ± 0%   -88.98%  (p=0.000 n=10+9)
    AppendIntSmall-4    16.0ns ± 1%     8.5ns ± 0%   -46.98%  (p=0.000 n=10+9)
    
    name              old alloc/op   new alloc/op   delta
    FormatInt-4           576B ± 0%      576B ± 0%      ~     (all equal)
    AppendInt-4          0.00B          0.00B           ~     (all equal)
    FormatUint-4          224B ± 0%      224B ± 0%      ~     (all equal)
    AppendUint-4         0.00B          0.00B           ~     (all equal)
    FormatIntSmall-4     2.00B ± 0%     0.00B       -100.00%  (p=0.000 n=10+10)
    AppendIntSmall-4     0.00B          0.00B           ~     (all equal)
    
    name              old allocs/op  new allocs/op  delta
    FormatInt-4           37.0 ± 0%      35.0 ± 0%    -5.41%  (p=0.000 n=10+10)
    AppendInt-4           0.00           0.00           ~     (all equal)
    FormatUint-4          6.00 ± 0%      6.00 ± 0%      ~     (all equal)
    AppendUint-4          0.00           0.00           ~     (all equal)
    FormatIntSmall-4      1.00 ± 0%      0.00       -100.00%  (p=0.000 n=10+10)
    AppendIntSmall-4      0.00           0.00           ~     (all equal)
    
    Fixes #19445
    
    Change-Id: Ib1f8922f2e0b13743c847ee9e703d1dab77f705c
    Reviewed-on: https://go-review.googlesource.com/37963
    Reviewed-by: Robert Griesemer <gri@golang.org>
    Run-TryBot: Robert Griesemer <gri@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Mar 13, 2017
  1. cmd/vet: check shift calculations with "unsafe" package

    valyala authored and josharian committed Mar 13, 2017
    vet should properly handle shift calculations via "unsafe"
    package after the CL 37950.
    
    Change-Id: I7737f2e656a5166337a17b92db46a0997f2a4e0e
    Reviewed-on: https://go-review.googlesource.com/38064
    Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
    Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Mar 11, 2017
  1. cmd/vet: eliminate "might be too small for shift" warnings

    valyala authored and josharian committed Mar 8, 2017
    Determine int, uint and uintptr bit sizes from GOARCH environment
    variable if it is set. Otherwise use host-specific sizes.
    
    Fixes #19321
    
    Change-Id: I494b8e4b49b59d32794f50ff2ce06ba040cb8460
    Reviewed-on: https://go-review.googlesource.com/37950
    Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
    Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>
Commits on Mar 9, 2017
  1. cmd/compile/internal/gc: shrink Sym by 8 bytes on amd64

    valyala authored and bradfitz committed Mar 6, 2017
    Move 8-bit flags field after 32-bit Block field
    
    Change-Id: I8e5e9a2285477aac2402a839a105e710d5340224
    Reviewed-on: https://go-review.googlesource.com/37848
    Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
    Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Commits on Mar 6, 2017
  1. cmd/compile/internal/gc: convert Sym.Flags to bitset8

    valyala authored and mdempsky committed Mar 6, 2017
    This makes Sym flags consistent with the rest of the code after
    the CL 37445.
    
    No functional changes.
    
    Passes toolstash -cmp.
    
    Change-Id: Ica919f2ab98581371c717fff9a70aeb11058ca17
    Reviewed-on: https://go-review.googlesource.com/37847
    Reviewed-by: Matthew Dempsky <mdempsky@google.com>
    Run-TryBot: Matthew Dempsky <mdempsky@google.com>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Mar 3, 2017
  1. cmd/compile: pack bool fields in Node, Name, Func and Type structs to…

    valyala authored and mdempsky committed Feb 27, 2017
    … bitsets
    
    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/37445
    Reviewed-by: Matthew Dempsky <mdempsky@google.com>
    Run-TryBot: Matthew Dempsky <mdempsky@google.com>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Feb 8, 2017
  1. bytes, strings: optimize Split*

    valyala authored and bradfitz committed Feb 7, 2017
    The relevant benchmark results on linux/amd64:
    
    bytes:
    
    SplitSingleByteSeparator-4   25.7ms ± 5%   9.1ms ± 4%  -64.40%  (p=0.000 n=10+10)
    SplitMultiByteSeparator-4    13.8ms ±20%   4.3ms ± 8%  -69.23%  (p=0.000 n=10+10)
    SplitNSingleByteSeparator-4  1.88µs ± 9%  0.88µs ± 4%  -53.25%  (p=0.000 n=10+10)
    SplitNMultiByteSeparator-4   4.83µs ±10%  1.32µs ± 9%  -72.65%  (p=0.000 n=10+10)
    
    strings:
    
    name                         old time/op  new time/op  delta
    SplitSingleByteSeparator-4   21.4ms ± 8%   8.5ms ± 5%  -60.19%  (p=0.000 n=10+10)
    SplitMultiByteSeparator-4    13.2ms ± 9%   3.9ms ± 4%  -70.29%  (p=0.000 n=10+10)
    SplitNSingleByteSeparator-4  1.54µs ± 5%  0.75µs ± 7%  -51.21%  (p=0.000 n=10+10)
    SplitNMultiByteSeparator-4   3.57µs ± 8%  1.01µs ±11%  -71.76%  (p=0.000 n=10+10)
    
    Fixes #18973
    
    Change-Id: Ie4bc010c6cc389001e72eab530497c81e5b26f34
    Reviewed-on: https://go-review.googlesource.com/36510
    Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
    Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Dec 24, 2016
  1. cmd/vet: fix copylocks false positive on len(array) and cap(array).

    valyala authored and robpike committed Dec 19, 2016
    This is a follow-up for https://golang.org/cl/24340.
    
    Updates #14664.
    Fixes #18374.
    
    Change-Id: I2831556a9014d30ec70d5f91943d18c33db5b390
    Reviewed-on: https://go-review.googlesource.com/34630
    Reviewed-by: Rob Pike <r@golang.org>
    Run-TryBot: Rob Pike <r@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Oct 5, 2016
  1. cmd/vet: skip printf check for non-constant format string during fail…

    valyala authored and robpike committed Sep 10, 2016
    …ed import
    
    Fixes #17006
    
    Change-Id: I3c2060ca5384a4b9782a7d804305d2cf4388dd5a
    Reviewed-on: https://go-review.googlesource.com/29014
    Run-TryBot: Rob Pike <r@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
    Reviewed-by: Rob Pike <r@golang.org>
Commits on Sep 6, 2016
  1. regexp: reduce mallocs in Regexp.Find* and Regexp.ReplaceAll*.

    valyala authored and bradfitz committed May 11, 2016
    This improves Regexp.Find* and Regexp.ReplaceAll* speed:
    
    name                  old time/op    new time/op    delta
    Find-4                   345ns ± 1%     314ns ± 1%    -8.94%    (p=0.000 n=9+8)
    FindString-4             341ns ± 1%     308ns ± 0%    -9.85%   (p=0.000 n=10+9)
    FindSubmatch-4           440ns ± 1%     404ns ± 0%    -8.27%   (p=0.000 n=10+8)
    FindStringSubmatch-4     426ns ± 0%     387ns ± 0%    -9.07%   (p=0.000 n=10+9)
    ReplaceAll-4            1.75µs ± 1%    1.67µs ± 0%    -4.45%   (p=0.000 n=9+10)
    
    name                  old alloc/op   new alloc/op   delta
    Find-4                   16.0B ± 0%     0.0B ±NaN%  -100.00%  (p=0.000 n=10+10)
    FindString-4             16.0B ± 0%     0.0B ±NaN%  -100.00%  (p=0.000 n=10+10)
    FindSubmatch-4           80.0B ± 0%     48.0B ± 0%   -40.00%  (p=0.000 n=10+10)
    FindStringSubmatch-4     64.0B ± 0%     32.0B ± 0%   -50.00%  (p=0.000 n=10+10)
    ReplaceAll-4              152B ± 0%      104B ± 0%   -31.58%  (p=0.000 n=10+10)
    
    name                  old allocs/op  new allocs/op  delta
    Find-4                    1.00 ± 0%     0.00 ±NaN%  -100.00%  (p=0.000 n=10+10)
    FindString-4              1.00 ± 0%     0.00 ±NaN%  -100.00%  (p=0.000 n=10+10)
    FindSubmatch-4            2.00 ± 0%      1.00 ± 0%   -50.00%  (p=0.000 n=10+10)
    FindStringSubmatch-4      2.00 ± 0%      1.00 ± 0%   -50.00%  (p=0.000 n=10+10)
    ReplaceAll-4              8.00 ± 0%      5.00 ± 0%   -37.50%  (p=0.000 n=10+10)
    
    Fixes #15643
    
    Change-Id: I594fe51172373e2adb98d1d25c76ca2cde54ff48
    Reviewed-on: https://go-review.googlesource.com/23030
    Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
    Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Aug 29, 2016
  1. cmd/vet: check for copying of array of locks

    valyala authored and robpike committed Jun 22, 2016
    Updates #14664
    
    Change-Id: I1f7b1116cfe91466816c760f136ce566da3e80a9
    Reviewed-on: https://go-review.googlesource.com/24340
    Run-TryBot: Rob Pike <r@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
    Reviewed-by: Rob Pike <r@golang.org>
  2. cmd/vet: properly handle indexed arguments in printf

    valyala authored and robpike committed Jun 23, 2016
    Fixes #15884
    
    Change-Id: I33d98db861d74e3c37a546efaf83ce6f2f76d335
    Reviewed-on: https://go-review.googlesource.com/24391
    Run-TryBot: Rob Pike <r@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
    Reviewed-by: Rob Pike <r@golang.org>
Commits on May 24, 2016
  1. cmd/vet: do not check print-like functions with unknown type

    valyala authored and robpike committed May 24, 2016
    Fixes #15787
    
    Change-Id: I559ba886527b474dbdd44fe884c78973b3012377
    Reviewed-on: https://go-review.googlesource.com/23351
    Run-TryBot: Rob Pike <r@golang.org>
    Reviewed-by: Rob Pike <r@golang.org>
Commits on May 12, 2016
  1. go/types: fix certain vet warnings

    valyala authored and bradfitz committed May 12, 2016
    Updates #11041
    
    Change-Id: I4e1c670d2b7fc04927d77c6f933cee39b7d48b6e
    Reviewed-on: https://go-review.googlesource.com/23083
    Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
    Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
  2. testing: fix vet warning

    valyala authored and bradfitz committed May 12, 2016
    Updates #11041
    
    Change-Id: I32a381854e6a4fd791db380150efab57e6dfc38c
    Reviewed-on: https://go-review.googlesource.com/23081
    Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
  3. cmd: fixed certain vet warnings

    valyala authored and bradfitz committed May 12, 2016
    Updates #11041
    
    Change-Id: I7f2583d08f344d6622027c5e8a5de1f5d2f2881c
    Reviewed-on: https://go-review.googlesource.com/23082
    Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
    Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
  4. reflect: fix vet warnings

    valyala authored and bradfitz committed May 12, 2016
    Updated #11041
    
    Change-Id: I4a110ba8fefb367a1049b4a65dd20c39eb890ea2
    Reviewed-on: https://go-review.googlesource.com/23080
    Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
    Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on May 6, 2016
  1. cmd/vet: check sync.* types' copying

    valyala authored and ianlancetaylor committed Apr 14, 2016
    Embed noLock struct into the following types, so `go vet -copylocks` catches
    their copying additionally to types containing sync.Mutex:
      - sync.Cond
      - sync.WaitGroup
      - sync.Pool
      - atomic.Value
    
    Fixes #14582
    
    Change-Id: Icb543ef5ad10524ad239a15eec8a9b334b0e0660
    Reviewed-on: https://go-review.googlesource.com/22015
    Reviewed-by: Russ Cox <rsc@golang.org>
    Run-TryBot: Russ Cox <rsc@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Apr 28, 2016
  1. cmd/vet: improve checking unkeyed fields in composite literals

    valyala authored and robpike committed Apr 23, 2016
    - Simplified the code.
    
    - Removed types for slice aliases from composite literals' whitelist, since they
    are properly handled by vet.
    
    Fixes #15408
    Updates #9171
    Updates #11041
    
    Change-Id: Ia1806c9eb3f327c09d2e28da4ffdb233b5a159b0
    Reviewed-on: https://go-review.googlesource.com/22318
    Run-TryBot: Rob Pike <r@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
    Reviewed-by: Rob Pike <r@golang.org>
Commits on Apr 7, 2016
  1. math/big: re-use memory in Int.GCD

    valyala authored and bradfitz committed Apr 4, 2016
    This improves TLS handshake performance.
    
    benchmark                                 old ns/op     new ns/op     delta
    BenchmarkGCD10x10/WithoutXY-4             965           968           +0.31%
    BenchmarkGCD10x10/WithXY-4                1813          1391          -23.28%
    BenchmarkGCD10x100/WithoutXY-4            1093          1075          -1.65%
    BenchmarkGCD10x100/WithXY-4               2348          1676          -28.62%
    BenchmarkGCD10x1000/WithoutXY-4           1569          1565          -0.25%
    BenchmarkGCD10x1000/WithXY-4              4262          3242          -23.93%
    BenchmarkGCD10x10000/WithoutXY-4          6069          6066          -0.05%
    BenchmarkGCD10x10000/WithXY-4             12123         11331         -6.53%
    BenchmarkGCD10x100000/WithoutXY-4         52664         52610         -0.10%
    BenchmarkGCD10x100000/WithXY-4            97494         95649         -1.89%
    BenchmarkGCD100x100/WithoutXY-4           5244          5228          -0.31%
    BenchmarkGCD100x100/WithXY-4              22572         18630         -17.46%
    BenchmarkGCD100x1000/WithoutXY-4          6143          6233          +1.47%
    BenchmarkGCD100x1000/WithXY-4             24652         19357         -21.48%
    BenchmarkGCD100x10000/WithoutXY-4         15725         15804         +0.50%
    BenchmarkGCD100x10000/WithXY-4            60552         55973         -7.56%
    BenchmarkGCD100x100000/WithoutXY-4        107008        107853        +0.79%
    BenchmarkGCD100x100000/WithXY-4           349597        340994        -2.46%
    BenchmarkGCD1000x1000/WithoutXY-4         63785         64434         +1.02%
    BenchmarkGCD1000x1000/WithXY-4            373186        334035        -10.49%
    BenchmarkGCD1000x10000/WithoutXY-4        78038         78241         +0.26%
    BenchmarkGCD1000x10000/WithXY-4           543692        507034        -6.74%
    BenchmarkGCD1000x100000/WithoutXY-4       205607        207727        +1.03%
    BenchmarkGCD1000x100000/WithXY-4          2488113       2415323       -2.93%
    BenchmarkGCD10000x10000/WithoutXY-4       1731340       1714992       -0.94%
    BenchmarkGCD10000x10000/WithXY-4          10601046      7111329       -32.92%
    BenchmarkGCD10000x100000/WithoutXY-4      2239155       2212173       -1.21%
    BenchmarkGCD10000x100000/WithXY-4         30097040      26538887      -11.82%
    BenchmarkGCD100000x100000/WithoutXY-4     119845326     119863916     +0.02%
    BenchmarkGCD100000x100000/WithXY-4        768006543     426795966     -44.43%
    
    benchmark                                 old allocs     new allocs     delta
    BenchmarkGCD10x10/WithoutXY-4             5              5              +0.00%
    BenchmarkGCD10x10/WithXY-4                17             9              -47.06%
    BenchmarkGCD10x100/WithoutXY-4            6              6              +0.00%
    BenchmarkGCD10x100/WithXY-4               21             9              -57.14%
    BenchmarkGCD10x1000/WithoutXY-4           6              6              +0.00%
    BenchmarkGCD10x1000/WithXY-4              30             12             -60.00%
    BenchmarkGCD10x10000/WithoutXY-4          6              6              +0.00%
    BenchmarkGCD10x10000/WithXY-4             26             12             -53.85%
    BenchmarkGCD10x100000/WithoutXY-4         6              6              +0.00%
    BenchmarkGCD10x100000/WithXY-4            28             12             -57.14%
    BenchmarkGCD100x100/WithoutXY-4           5              5              +0.00%
    BenchmarkGCD100x100/WithXY-4              183            61             -66.67%
    BenchmarkGCD100x1000/WithoutXY-4          8              8              +0.00%
    BenchmarkGCD100x1000/WithXY-4             170            47             -72.35%
    BenchmarkGCD100x10000/WithoutXY-4         8              8              +0.00%
    BenchmarkGCD100x10000/WithXY-4            200            67             -66.50%
    BenchmarkGCD100x100000/WithoutXY-4        8              8              +0.00%
    BenchmarkGCD100x100000/WithXY-4           188            65             -65.43%
    BenchmarkGCD1000x1000/WithoutXY-4         5              5              +0.00%
    BenchmarkGCD1000x1000/WithXY-4            2435           1193           -51.01%
    BenchmarkGCD1000x10000/WithoutXY-4        8              8              +0.00%
    BenchmarkGCD1000x10000/WithXY-4           2211           1076           -51.33%
    BenchmarkGCD1000x100000/WithoutXY-4       8              8              +0.00%
    BenchmarkGCD1000x100000/WithXY-4          2271           1108           -51.21%
    BenchmarkGCD10000x10000/WithoutXY-4       5              5              +0.00%
    BenchmarkGCD10000x10000/WithXY-4          23183          11605          -49.94%
    BenchmarkGCD10000x100000/WithoutXY-4      8              8              +0.00%
    BenchmarkGCD10000x100000/WithXY-4         23421          11717          -49.97%
    BenchmarkGCD100000x100000/WithoutXY-4     5              5              +0.00%
    BenchmarkGCD100000x100000/WithXY-4        232976         116815         -49.86%
    
    benchmark                                 old bytes      new bytes     delta
    BenchmarkGCD10x10/WithoutXY-4             208            208           +0.00%
    BenchmarkGCD10x10/WithXY-4                736            432           -41.30%
    BenchmarkGCD10x100/WithoutXY-4            256            256           +0.00%
    BenchmarkGCD10x100/WithXY-4               896            432           -51.79%
    BenchmarkGCD10x1000/WithoutXY-4           368            368           +0.00%
    BenchmarkGCD10x1000/WithXY-4              1856           1152          -37.93%
    BenchmarkGCD10x10000/WithoutXY-4          1616           1616          +0.00%
    BenchmarkGCD10x10000/WithXY-4             7920           7376          -6.87%
    BenchmarkGCD10x100000/WithoutXY-4         13776          13776         +0.00%
    BenchmarkGCD10x100000/WithXY-4            68800          68176         -0.91%
    BenchmarkGCD100x100/WithoutXY-4           208            208           +0.00%
    BenchmarkGCD100x100/WithXY-4              6960           2112          -69.66%
    BenchmarkGCD100x1000/WithoutXY-4          544            560           +2.94%
    BenchmarkGCD100x1000/WithXY-4             7280           2400          -67.03%
    BenchmarkGCD100x10000/WithoutXY-4         2896           2912          +0.55%
    BenchmarkGCD100x10000/WithXY-4            15280          10002         -34.54%
    BenchmarkGCD100x100000/WithoutXY-4        27344          27365         +0.08%
    BenchmarkGCD100x100000/WithXY-4           88288          83427         -5.51%
    BenchmarkGCD1000x1000/WithoutXY-4         544            544           +0.00%
    BenchmarkGCD1000x1000/WithXY-4            178288         40043         -77.54%
    BenchmarkGCD1000x10000/WithoutXY-4        3344           3136          -6.22%
    BenchmarkGCD1000x10000/WithXY-4           188720         54432         -71.16%
    BenchmarkGCD1000x100000/WithoutXY-4       27792          27592         -0.72%
    BenchmarkGCD1000x100000/WithXY-4          373872         239447        -35.95%
    BenchmarkGCD10000x10000/WithoutXY-4       4288           4288          +0.00%
    BenchmarkGCD10000x10000/WithXY-4          11935584       481875        -95.96%
    BenchmarkGCD10000x100000/WithoutXY-4      31296          28834         -7.87%
    BenchmarkGCD10000x100000/WithXY-4         13237088       1662620       -87.44%
    BenchmarkGCD100000x100000/WithoutXY-4     40768          40768         +0.00%
    BenchmarkGCD100000x100000/WithXY-4        1165518864     14256010      -98.78%
    
    Change-Id: I652b3244bd074a03f3bc9a87c282330f9e5f1507
    Reviewed-on: https://go-review.googlesource.com/21506
    Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
    Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
Commits on Apr 6, 2016
  1. icmd/vet: improved checking for variadic Println-like functions

    valyala authored and robpike committed Apr 5, 2016
    - Automatically determine the first argument to check.
    - Skip checking matching non-variadic functions.
    - Skip checking matching functions accepting non-interface{}
      variadic arguments.
    - Removed fragile 'magic' code for special cases such as math.Log
      and error interface.
    
    Fixes #15067
    Fixes #15099
    
    Change-Id: Ib313557f18b12b36daa493f4b02c598b9503b55b
    Reviewed-on: https://go-review.googlesource.com/21513
    Run-TryBot: Rob Pike <r@golang.org>
    Reviewed-by: Rob Pike <r@golang.org>
Commits on Mar 30, 2016
  1. cmd/vet: allow lock types inside built-in new()

    valyala authored and robpike committed Mar 28, 2016
    Updates #14839
    Fixes #14994
    
    Change-Id: I9bb51bad19105a17c80d690c5486e5dd007ac84a
    Reviewed-on: https://go-review.googlesource.com/21222
    Run-TryBot: Rob Pike <r@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
    Reviewed-by: Rob Pike <r@golang.org>
Commits on Mar 29, 2016
  1. cmd/vet: improve detecting printf-like format argument

    valyala authored and robpike committed Mar 22, 2016
    Previously format argument was detected via scanning func type args.
    This didn't work when func type couldn't be determined if the func
    is declared in the external package. Fall back to scanning for
    the first string call argument in this case.
    
    Fixes #14754
    
    Change-Id: I571cc29684cc641bc87882002ef474cf1481e9e2
    Reviewed-on: https://go-review.googlesource.com/21023
    Run-TryBot: Rob Pike <r@golang.org>
    TryBot-Result: Gobot Gobot <gobot@golang.org>
    Reviewed-by: Rob Pike <r@golang.org>