1. 13 Feb, 2017 14 commits
  2. 12 Feb, 2017 3 commits
    • Alex Brainman's avatar
      path/filepath: add test for directory junction walk · 61bf0d1c
      Alex Brainman authored
      For #10424.
      
      Change-Id: Ie4e87503b0ed04f65d2444652bd1db647d3529f4
      Reviewed-on: https://go-review.googlesource.com/36851Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      61bf0d1c
    • Russ Cox's avatar
      runtime: use two-level list for semaphore address search in semaRoot · 45c6f59e
      Russ Cox authored
      If there are many goroutines contending for two different locks
      and both locks hash to the same semaRoot, the scans to find the
      goroutines for a particular lock can end up being O(n), making
      n lock acquisitions quadratic.
      
      As long as only one actively-used lock hashes to each semaRoot
      there's no problem, since the list operations in that case are O(1).
      But when the second actively-used lock hits the same semaRoot,
      then scans for entries with for a given lock have to scan over the
      entries for the other lock.
      
      Fix this problem by changing the semaRoot to hold only one sudog
      per unique address. In the running example, this drops the length of
      that list from O(n) to 2. Then attach other goroutines waiting on the
      same address to a separate list headed by the sudog in the semaRoot list.
      Those "same address list" operations are still O(1), so now the
      example from above works much better.
      
      There is still an assumption here that in real programs you don't have
      many many goroutines queueing up on many many distinct addresses.
      If we end up with that problem, we can replace the top-level list with
      a treap.
      
      Fixes #17953.
      
      Change-Id: I78c5b1a5053845275ab31686038aa4f6db5720b2
      Reviewed-on: https://go-review.googlesource.com/36792
      Run-TryBot: Russ Cox <rsc@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarIan Lance Taylor <iant@golang.org>
      45c6f59e
    • Cezar Sa Espinola's avatar
      image/png: reduce memory allocs encoding images by reusing buffers · 93a18acf
      Cezar Sa Espinola authored
      This change allows greatly reducing memory allocations with a slightly
      performance improvement as well.
      
      Instances of (*png).Encoder can have a optional BufferPool attached to
      them. This allows reusing temporary buffers used when encoding a new
      image. This buffers include instances to zlib.Writer and bufio.Writer.
      
      Also, buffers for current and previous rows are saved in the encoder
      instance and reused as long as their cap() is enough to fit the current
      image row.
      
      A new benchmark was added to demonstrate the performance improvement
      when setting a BufferPool to an Encoder instance:
      
      $ go test -bench BenchmarkEncodeGray -benchmem
      BenchmarkEncodeGray-4                 	    1000	   2349584 ns/op	 130.75 MB/s	  852230 B/op	      32 allocs/op
      BenchmarkEncodeGrayWithBufferPool-4   	    1000	   2241650 ns/op	 137.04 MB/s	     900 B/op	       3 allocs/op
      
      Change-Id: I4488201ae53cb2ad010c68c1e0118ee12beae14e
      Reviewed-on: https://go-review.googlesource.com/34150Reviewed-by: 's avatarNigel Tao <nigeltao@golang.org>
      Run-TryBot: Nigel Tao <nigeltao@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      93a18acf
  3. 11 Feb, 2017 9 commits
    • Josh Bleecher Snyder's avatar
      cmd/internal/obj/x86: add comments to wrapper prologue insertion · 5030bfdf
      Josh Bleecher Snyder authored
      Make the comments a bit clearer and more accurate,
      in anticipation of updating the code.
      
      Change-Id: I1111e6c3405a8688fcd29b809a48a762ff41edaa
      Reviewed-on: https://go-review.googlesource.com/36833Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      5030bfdf
    • Josh Bleecher Snyder's avatar
      cmd/compile: make panicwrap argument-free · 2c91bb4c
      Josh Bleecher Snyder authored
      When code defines a method on T,
      the compiler generates a corresponding wrapper method on *T.
      The first thing the wrapper does is check whether
      the pointer is nil and if so, call panicwrap.
      This is done to provide a useful error message.
      
      The existing implementation gets its information
      from arguments set up by the compiler.
      However, with some trouble, this information can
      be extracted from the name of the wrapper method itself.
      
      Removing the arguments to panicwrap simplifies and
      shrinks the wrapper method.
      It also means that the call to panicwrap does not
      require any stack space.
      This enables a further optimization on amd64/x86,
      which is to skip the function prologue if nothing
      else in the method requires stack space.
      This is frequently the case in simple, hot methods,
      such as Less and Swap in sort.Interface implementations.
      
      Fixes #19040.
      
      Benchmarks for package sort on amd64:
      
      name                  old time/op  new time/op  delta
      SearchWrappers-8       104ns ± 1%   104ns ± 1%    ~     (p=0.286 n=27+27)
      SortString1K-8         128µs ± 1%   128µs ± 1%  -0.44%  (p=0.004 n=30+30)
      SortString1K_Slice-8   118µs ± 2%   117µs ± 1%    ~     (p=0.106 n=30+30)
      StableString1K-8      18.6µs ± 1%  18.6µs ± 1%    ~     (p=0.446 n=28+26)
      SortInt1K-8           65.9µs ± 1%  60.7µs ± 1%  -7.96%  (p=0.000 n=28+30)
      StableInt1K-8         75.3µs ± 2%  72.8µs ± 1%  -3.41%  (p=0.000 n=30+30)
      StableInt1K_Slice-8   57.7µs ± 1%  57.7µs ± 1%    ~     (p=0.515 n=30+30)
      SortInt64K-8          6.28ms ± 1%  6.01ms ± 1%  -4.19%  (p=0.000 n=28+28)
      SortInt64K_Slice-8    5.04ms ± 1%  5.04ms ± 1%    ~     (p=0.927 n=28+27)
      StableInt64K-8        6.65ms ± 1%  6.38ms ± 1%  -3.97%  (p=0.000 n=26+30)
      Sort1e2-8             37.9µs ± 1%  37.2µs ± 1%  -1.89%  (p=0.000 n=29+27)
      Stable1e2-8           77.0µs ± 1%  74.7µs ± 1%  -3.06%  (p=0.000 n=27+30)
      Sort1e4-8             8.21ms ± 2%  7.98ms ± 1%  -2.77%  (p=0.000 n=29+30)
      Stable1e4-8           24.8ms ± 1%  24.3ms ± 1%  -2.31%  (p=0.000 n=28+30)
      Sort1e6-8              1.27s ± 4%   1.22s ± 1%  -3.42%  (p=0.000 n=30+29)
      Stable1e6-8            5.06s ± 1%   4.92s ± 1%  -2.77%  (p=0.000 n=25+29)
      [Geo mean]             731µs        714µs       -2.29%
      
      Before/after assembly for sort.(*intPairs).Less follows.
      It can be optimized further, but that's for a follow-up CL.
      
      Before:
      
      "".(*intPairs).Less t=1 size=214 args=0x20 locals=0x38
      	0x0000 00000 (<autogenerated>:1)	TEXT	"".(*intPairs).Less(SB), $56-32
      	0x0000 00000 (<autogenerated>:1)	MOVQ	(TLS), CX
      	0x0009 00009 (<autogenerated>:1)	CMPQ	SP, 16(CX)
      	0x000d 00013 (<autogenerated>:1)	JLS	204
      	0x0013 00019 (<autogenerated>:1)	SUBQ	$56, SP
      	0x0017 00023 (<autogenerated>:1)	MOVQ	BP, 48(SP)
      	0x001c 00028 (<autogenerated>:1)	LEAQ	48(SP), BP
      	0x0021 00033 (<autogenerated>:1)	MOVQ	32(CX), BX
      	0x0025 00037 (<autogenerated>:1)	TESTQ	BX, BX
      	0x0028 00040 (<autogenerated>:1)	JEQ	55
      	0x002a 00042 (<autogenerated>:1)	LEAQ	64(SP), DI
      	0x002f 00047 (<autogenerated>:1)	CMPQ	(BX), DI
      	0x0032 00050 (<autogenerated>:1)	JNE	55
      	0x0034 00052 (<autogenerated>:1)	MOVQ	SP, (BX)
      	0x0037 00055 (<autogenerated>:1)	NOP
      	0x0037 00055 (<autogenerated>:1)	FUNCDATA	$0, gclocals·4032f753396f2012ad1784f398b170f4(SB)
      	0x0037 00055 (<autogenerated>:1)	FUNCDATA	$1, gclocals·69c1753bd5f81501d95132d08af04464(SB)
      	0x0037 00055 (<autogenerated>:1)	MOVQ	""..this+64(FP), AX
      	0x003c 00060 (<autogenerated>:1)	TESTQ	AX, AX
      	0x003f 00063 (<autogenerated>:1)	JEQ	$0, 135
      	0x0041 00065 (<autogenerated>:1)	MOVQ	(AX), CX
      	0x0044 00068 (<autogenerated>:1)	MOVQ	8(AX), AX
      	0x0048 00072 (<autogenerated>:1)	MOVQ	"".i+72(FP), DX
      	0x004d 00077 (<autogenerated>:1)	CMPQ	DX, AX
      	0x0050 00080 (<autogenerated>:1)	JCC	$0, 128
      	0x0052 00082 (<autogenerated>:1)	SHLQ	$4, DX
      	0x0056 00086 (<autogenerated>:1)	MOVQ	(CX)(DX*1), DX
      	0x005a 00090 (<autogenerated>:1)	MOVQ	"".j+80(FP), BX
      	0x005f 00095 (<autogenerated>:1)	CMPQ	BX, AX
      	0x0062 00098 (<autogenerated>:1)	JCC	$0, 128
      	0x0064 00100 (<autogenerated>:1)	SHLQ	$4, BX
      	0x0068 00104 (<autogenerated>:1)	MOVQ	(CX)(BX*1), AX
      	0x006c 00108 (<autogenerated>:1)	CMPQ	DX, AX
      	0x006f 00111 (<autogenerated>:1)	SETLT	AL
      	0x0072 00114 (<autogenerated>:1)	MOVB	AL, "".~r2+88(FP)
      	0x0076 00118 (<autogenerated>:1)	MOVQ	48(SP), BP
      	0x007b 00123 (<autogenerated>:1)	ADDQ	$56, SP
      	0x007f 00127 (<autogenerated>:1)	RET
      	0x0080 00128 (<autogenerated>:1)	PCDATA	$0, $1
      	0x0080 00128 (<autogenerated>:1)	CALL	runtime.panicindex(SB)
      	0x0085 00133 (<autogenerated>:1)	UNDEF
      	0x0087 00135 (<autogenerated>:1)	LEAQ	go.string."sort_test"(SB), AX
      	0x008e 00142 (<autogenerated>:1)	MOVQ	AX, (SP)
      	0x0092 00146 (<autogenerated>:1)	MOVQ	$9, 8(SP)
      	0x009b 00155 (<autogenerated>:1)	LEAQ	go.string."intPairs"(SB), AX
      	0x00a2 00162 (<autogenerated>:1)	MOVQ	AX, 16(SP)
      	0x00a7 00167 (<autogenerated>:1)	MOVQ	$8, 24(SP)
      	0x00b0 00176 (<autogenerated>:1)	LEAQ	go.string."Less"(SB), AX
      	0x00b7 00183 (<autogenerated>:1)	MOVQ	AX, 32(SP)
      	0x00bc 00188 (<autogenerated>:1)	MOVQ	$4, 40(SP)
      	0x00c5 00197 (<autogenerated>:1)	PCDATA	$0, $1
      	0x00c5 00197 (<autogenerated>:1)	CALL	runtime.panicwrap(SB)
      	0x00ca 00202 (<autogenerated>:1)	UNDEF
      	0x00cc 00204 (<autogenerated>:1)	NOP
      	0x00cc 00204 (<autogenerated>:1)	PCDATA	$0, $-1
      	0x00cc 00204 (<autogenerated>:1)	CALL	runtime.morestack_noctxt(SB)
      	0x00d1 00209 (<autogenerated>:1)	JMP	0
      
      After:
      
      "".(*intPairs).Swap t=1 size=147 args=0x18 locals=0x8
      	0x0000 00000 (<autogenerated>:1)	TEXT	"".(*intPairs).Swap(SB), $8-24
      	0x0000 00000 (<autogenerated>:1)	MOVQ	(TLS), CX
      	0x0009 00009 (<autogenerated>:1)	SUBQ	$8, SP
      	0x000d 00013 (<autogenerated>:1)	MOVQ	BP, (SP)
      	0x0011 00017 (<autogenerated>:1)	LEAQ	(SP), BP
      	0x0015 00021 (<autogenerated>:1)	MOVQ	32(CX), BX
      	0x0019 00025 (<autogenerated>:1)	TESTQ	BX, BX
      	0x001c 00028 (<autogenerated>:1)	JEQ	43
      	0x001e 00030 (<autogenerated>:1)	LEAQ	16(SP), DI
      	0x0023 00035 (<autogenerated>:1)	CMPQ	(BX), DI
      	0x0026 00038 (<autogenerated>:1)	JNE	43
      	0x0028 00040 (<autogenerated>:1)	MOVQ	SP, (BX)
      	0x002b 00043 (<autogenerated>:1)	NOP
      	0x002b 00043 (<autogenerated>:1)	FUNCDATA	$0, gclocals·e6397a44f8e1b6e77d0f200b4fba5269(SB)
      	0x002b 00043 (<autogenerated>:1)	FUNCDATA	$1, gclocals·69c1753bd5f81501d95132d08af04464(SB)
      	0x002b 00043 (<autogenerated>:1)	MOVQ	""..this+16(FP), AX
      	0x0030 00048 (<autogenerated>:1)	TESTQ	AX, AX
      	0x0033 00051 (<autogenerated>:1)	JEQ	$0, 140
      	0x0035 00053 (<autogenerated>:1)	MOVQ	(AX), CX
      	0x0038 00056 (<autogenerated>:1)	MOVQ	8(AX), AX
      	0x003c 00060 (<autogenerated>:1)	MOVQ	"".i+24(FP), DX
      	0x0041 00065 (<autogenerated>:1)	CMPQ	DX, AX
      	0x0044 00068 (<autogenerated>:1)	JCC	$0, 133
      	0x0046 00070 (<autogenerated>:1)	SHLQ	$4, DX
      	0x004a 00074 (<autogenerated>:1)	MOVQ	8(CX)(DX*1), BX
      	0x004f 00079 (<autogenerated>:1)	MOVQ	(CX)(DX*1), SI
      	0x0053 00083 (<autogenerated>:1)	MOVQ	"".j+32(FP), DI
      	0x0058 00088 (<autogenerated>:1)	CMPQ	DI, AX
      	0x005b 00091 (<autogenerated>:1)	JCC	$0, 133
      	0x005d 00093 (<autogenerated>:1)	SHLQ	$4, DI
      	0x0061 00097 (<autogenerated>:1)	MOVQ	8(CX)(DI*1), AX
      	0x0066 00102 (<autogenerated>:1)	MOVQ	(CX)(DI*1), R8
      	0x006a 00106 (<autogenerated>:1)	MOVQ	R8, (CX)(DX*1)
      	0x006e 00110 (<autogenerated>:1)	MOVQ	AX, 8(CX)(DX*1)
      	0x0073 00115 (<autogenerated>:1)	MOVQ	SI, (CX)(DI*1)
      	0x0077 00119 (<autogenerated>:1)	MOVQ	BX, 8(CX)(DI*1)
      	0x007c 00124 (<autogenerated>:1)	MOVQ	(SP), BP
      	0x0080 00128 (<autogenerated>:1)	ADDQ	$8, SP
      	0x0084 00132 (<autogenerated>:1)	RET
      	0x0085 00133 (<autogenerated>:1)	PCDATA	$0, $1
      	0x0085 00133 (<autogenerated>:1)	CALL	runtime.panicindex(SB)
      	0x008a 00138 (<autogenerated>:1)	UNDEF
      	0x008c 00140 (<autogenerated>:1)	PCDATA	$0, $1
      	0x008c 00140 (<autogenerated>:1)	CALL	runtime.panicwrap(SB)
      	0x0091 00145 (<autogenerated>:1)	UNDEF
      
      Change-Id: I15bb8435f0690badb868799f313ed8817335efd3
      Reviewed-on: https://go-review.googlesource.com/36809
      Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
      Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      2c91bb4c
    • Josh Bleecher Snyder's avatar
      testing: fix copy/paste in docs · 61e963e9
      Josh Bleecher Snyder authored
      Follow-up to CL 36791.
      
      Change-Id: I1c4831e5dfe90c205782e970ada7faff8a009daa
      Reviewed-on: https://go-review.googlesource.com/36890Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      61e963e9
    • Dhananjay Nakrani's avatar
      cmd/compile: Ensure left-to-right assignment · 1cde87b3
      Dhananjay Nakrani authored
      Add temporaries to reorder the assignment for OAS2XXX nodes.
      This makes orderstmt(), rewrite
        a, b, c = ...
      as
        tmp1, tmp2, tmp3 = ...
        a, b, c = tmp1, tmp2, tmp3
      and
        a, ok = ...
      as
        t1, t2 = ...
        a  = t1
        ok = t2
      
      Fixes #13433.
      
      Change-Id: Id0f5956e3a254d0a6f4b89b5f7b0e055b1f0e21f
      Reviewed-on: https://go-review.googlesource.com/34713
      Run-TryBot: Dhananjay Nakrani <dhananjayn@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarKeith Randall <khr@golang.org>
      1cde87b3
    • Paul Jolly's avatar
      doc: improve issue template and contribution guidelines · e0d50a58
      Paul Jolly authored
      Encourage people towards the various help forums as a first port of
      call. Better sign-posting will reduce the incidence or questions being
      asked in the issue tracker that should otherwise be handled elsewhere,
      thereby keeping the issue tracker email traffic more focussed.
      
      Change-Id: I13b2e498d88be010fca421067ae6fb579a46d6b7
      Reviewed-on: https://go-review.googlesource.com/34250Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      e0d50a58
    • Alberto Donizetti's avatar
      strings: make parameters names less confusing · 272ec231
      Alberto Donizetti authored
      Using 'sep' as parameter name for strings functions that take a
      separator argument is fine, but for functions like Index or Count that
      look for a substring it's better to use 'substr' (like Contains
      already does).
      
      Fixes #19039
      
      Change-Id: Idd557409c8fea64ce830ab0e3fec37d3d56a79f0
      Reviewed-on: https://go-review.googlesource.com/36874
      Run-TryBot: Alberto Donizetti <alb.donizetti@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      272ec231
    • Remi Gillig's avatar
      path/filepath: fix TestWinSplitListTestsAreValid on some systems · 2ceeb7b0
      Remi Gillig authored
      The environment variables used in those tests override the default
      OS ones. However, one of them (SystemRoot) seems to be required on
      some Windows systems for invoking cmd.exe properly.
      
      This fixes #4930 and #6568.
      
      Change-Id: I23dfb67c1de86020711a3b59513f6adcbba12561
      Reviewed-on: https://go-review.googlesource.com/36873Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      2ceeb7b0
    • Jaana Burcu Dogan's avatar
      cmd/nm: extend help text to document the flags · 60d7d247
      Jaana Burcu Dogan authored
      Change-Id: Ia2852666ef44e7ef0bba2360e92caccc83fd0e5c
      Reviewed-on: https://go-review.googlesource.com/36796Reviewed-by: 's avatarIan Lance Taylor <iant@golang.org>
      Run-TryBot: Ian Lance Taylor <iant@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      60d7d247
    • Josh Bleecher Snyder's avatar
      testing: only call ReadMemStats if necessary when benchmarking · 948b21a3
      Josh Bleecher Snyder authored
      When running benchmarks with -cpuprofile,
      the entire process gets profiled,
      and ReadMemStats is surprisingly expensive.
      Running the sort benchmarks right now with
      -cpuprofile shows almost half of all execution
      time in ReadMemStats.
      
      Since ReadMemStats is not required if the benchmark
      does not need allocation stats, simply skip it.
      This will make cpu profiles nicer to read
      and significantly speed up the process of running benchmarks.
      It might also make sense to toggle cpu profiling
      on/off as we begin/end individual benchmarks,
      but that wouldn't get us the time savings of
      skipping ReadMemStats, so this CL is useful in itself.
      
      Change-Id: I425197b1ee11be4bc91d22b929e2caf648ebd7c5
      Reviewed-on: https://go-review.googlesource.com/36791
      Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarIan Lance Taylor <iant@golang.org>
      948b21a3
  4. 10 Feb, 2017 14 commits