Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

cmd/compile: reduce binary bloat for slice literals of interfaces #29573

Closed
dsnet opened this issue Jan 4, 2019 · 8 comments
Closed

cmd/compile: reduce binary bloat for slice literals of interfaces #29573

dsnet opened this issue Jan 4, 2019 · 8 comments
Labels
FrozenDueToAge NeedsFix The path to resolution is known, but the work has not been done. Performance
Milestone
Go1.14

Comments

@dsnet
Copy link
Member

dsnet commented Jan 4, 2019 •
edited
Loading

Using go1.12

Consider the following snippet:

func makeLiteral() []interface{} {
	return []interface{}{
		(uint32)(0),
		(tar.Format)(0),
		(*tar.Header)(nil),
		(*tar.Reader)(nil),
		(*tar.Writer)(nil),
		(*zip.File)(nil),
		(*zip.FileHeader)(nil),
		(*zip.ReadCloser)(nil),
		(*zip.Reader)(nil),
		(*zip.Writer)(nil),
	}
}
"".makeLiteral STEXT size=688 args=0x18 locals=0x18
	0x0000 00000 (main.go:10)	TEXT	"".makeLiteral(SB), $24-24
	0x0000 00000 (main.go:10)	MOVQ	(TLS), CX
	0x0009 00009 (main.go:10)	CMPQ	SP, 16(CX)
	0x000d 00013 (main.go:10)	JLS	678
	0x0013 00019 (main.go:10)	SUBQ	$24, SP
	0x0017 00023 (main.go:10)	MOVQ	BP, 16(SP)
	0x001c 00028 (main.go:10)	LEAQ	16(SP), BP
	0x0021 00033 (main.go:11)	LEAQ	type.[10]interface {}(SB), AX
	0x0028 00040 (main.go:11)	MOVQ	AX, (SP)
	0x002c 00044 (main.go:11)	CALL	runtime.newobject(SB)
	0x0031 00049 (main.go:11)	MOVQ	8(SP), AX
	0x0036 00054 (main.go:12)	LEAQ	type.uint32(SB), CX
	0x003d 00061 (main.go:12)	MOVQ	CX, (AX)
	0x0040 00064 (main.go:12)	CMPL	runtime.writeBarrier(SB), $0
	0x0047 00071 (main.go:12)	JNE	651
	0x004d 00077 (main.go:12)	LEAQ	"".statictmp_0(SB), CX
	0x0054 00084 (main.go:12)	MOVQ	CX, 8(AX)
	0x0058 00088 (main.go:13)	LEAQ	type.archive/tar.Format(SB), CX
	0x005f 00095 (main.go:13)	MOVQ	CX, 16(AX)
	0x0063 00099 (main.go:13)	CMPL	runtime.writeBarrier(SB), $0
	0x006a 00106 (main.go:13)	JNE	624
	0x0070 00112 (main.go:13)	LEAQ	"".statictmp_1(SB), CX
	0x0077 00119 (main.go:13)	MOVQ	CX, 24(AX)
	0x007b 00123 (main.go:14)	MOVQ	"".statictmp_2(SB), CX
	0x0082 00130 (main.go:14)	LEAQ	type.*archive/tar.Header(SB), DX
	0x0089 00137 (main.go:14)	MOVQ	DX, 32(AX)
	0x008d 00141 (main.go:14)	CMPL	runtime.writeBarrier(SB), $0
	0x0094 00148 (main.go:14)	JNE	601
	0x009a 00154 (main.go:14)	MOVQ	CX, 40(AX)
	0x009e 00158 (main.go:15)	MOVQ	"".statictmp_3(SB), CX
	0x00a5 00165 (main.go:15)	LEAQ	type.*archive/tar.Reader(SB), DX
	0x00ac 00172 (main.go:15)	MOVQ	DX, 48(AX)
	0x00b0 00176 (main.go:15)	CMPL	runtime.writeBarrier(SB), $0
	0x00b7 00183 (main.go:15)	JNE	578
	0x00bd 00189 (main.go:15)	MOVQ	CX, 56(AX)
	0x00c1 00193 (main.go:16)	MOVQ	"".statictmp_4(SB), CX
	0x00c8 00200 (main.go:16)	LEAQ	type.*archive/tar.Writer(SB), DX
	0x00cf 00207 (main.go:16)	MOVQ	DX, 64(AX)
	0x00d3 00211 (main.go:16)	CMPL	runtime.writeBarrier(SB), $0
	0x00da 00218 (main.go:16)	JNE	555
	0x00e0 00224 (main.go:16)	MOVQ	CX, 72(AX)
	0x00e4 00228 (main.go:17)	MOVQ	"".statictmp_5(SB), CX
	0x00eb 00235 (main.go:17)	LEAQ	type.*archive/zip.File(SB), DX
	0x00f2 00242 (main.go:17)	MOVQ	DX, 80(AX)
	0x00f6 00246 (main.go:17)	CMPL	runtime.writeBarrier(SB), $0
	0x00fd 00253 (main.go:17)	JNE	532
	0x0103 00259 (main.go:17)	MOVQ	CX, 88(AX)
	0x0107 00263 (main.go:18)	MOVQ	"".statictmp_6(SB), CX
	0x010e 00270 (main.go:18)	LEAQ	type.*archive/zip.FileHeader(SB), DX
	0x0115 00277 (main.go:18)	MOVQ	DX, 96(AX)
	0x0119 00281 (main.go:18)	CMPL	runtime.writeBarrier(SB), $0
	0x0120 00288 (main.go:18)	JNE	509
	0x0126 00294 (main.go:18)	MOVQ	CX, 104(AX)
	0x012a 00298 (main.go:19)	MOVQ	"".statictmp_7(SB), CX
	0x0131 00305 (main.go:19)	LEAQ	type.*archive/zip.ReadCloser(SB), DX
	0x0138 00312 (main.go:19)	MOVQ	DX, 112(AX)
	0x013c 00316 (main.go:19)	CMPL	runtime.writeBarrier(SB), $0
	0x0143 00323 (main.go:19)	JNE	486
	0x0149 00329 (main.go:19)	MOVQ	CX, 120(AX)
	0x014d 00333 (main.go:20)	MOVQ	"".statictmp_8(SB), CX
	0x0154 00340 (main.go:20)	LEAQ	type.*archive/zip.Reader(SB), DX
	0x015b 00347 (main.go:20)	MOVQ	DX, 128(AX)
	0x0162 00354 (main.go:20)	CMPL	runtime.writeBarrier(SB), $0
	0x0169 00361 (main.go:20)	JNE	463
	0x016b 00363 (main.go:20)	MOVQ	CX, 136(AX)
	0x0172 00370 (main.go:21)	MOVQ	"".statictmp_9(SB), CX
	0x0179 00377 (main.go:21)	LEAQ	type.*archive/zip.Writer(SB), DX
	0x0180 00384 (main.go:21)	MOVQ	DX, 144(AX)
	0x0187 00391 (main.go:21)	CMPL	runtime.writeBarrier(SB), $0
	0x018e 00398 (main.go:21)	JNE	440
	0x0190 00400 (main.go:21)	MOVQ	CX, 152(AX)
	0x0197 00407 (main.go:11)	MOVQ	AX, "".~r0+32(SP)
	0x019c 00412 (main.go:11)	MOVQ	$10, "".~r0+40(SP)
	0x01a5 00421 (main.go:11)	MOVQ	$10, "".~r0+48(SP)
	0x01ae 00430 (main.go:11)	MOVQ	16(SP), BP
	0x01b3 00435 (main.go:11)	ADDQ	$24, SP
	0x01b7 00439 (main.go:11)	RET
	0x01b8 00440 (main.go:21)	LEAQ	152(AX), DI
	0x01bf 00447 (main.go:11)	MOVQ	AX, DX
	0x01c2 00450 (main.go:21)	MOVQ	CX, AX
	0x01c5 00453 (main.go:21)	CALL	runtime.gcWriteBarrier(SB)
	0x01ca 00458 (main.go:11)	MOVQ	DX, AX
	0x01cd 00461 (main.go:21)	JMP	407
	0x01cf 00463 (main.go:20)	LEAQ	136(AX), DI
	0x01d6 00470 (main.go:11)	MOVQ	AX, DX
	0x01d9 00473 (main.go:20)	MOVQ	CX, AX
	0x01dc 00476 (main.go:20)	CALL	runtime.gcWriteBarrier(SB)
	0x01e1 00481 (main.go:21)	MOVQ	DX, AX
	0x01e4 00484 (main.go:20)	JMP	370
	0x01e6 00486 (main.go:19)	LEAQ	120(AX), DI
	0x01ea 00490 (main.go:11)	MOVQ	AX, DX
	0x01ed 00493 (main.go:19)	MOVQ	CX, AX
	0x01f0 00496 (main.go:19)	CALL	runtime.gcWriteBarrier(SB)
	0x01f5 00501 (main.go:20)	MOVQ	DX, AX
	0x01f8 00504 (main.go:19)	JMP	333
	0x01fd 00509 (main.go:18)	LEAQ	104(AX), DI
	0x0201 00513 (main.go:11)	MOVQ	AX, DX
	0x0204 00516 (main.go:18)	MOVQ	CX, AX
	0x0207 00519 (main.go:18)	CALL	runtime.gcWriteBarrier(SB)
	0x020c 00524 (main.go:19)	MOVQ	DX, AX
	0x020f 00527 (main.go:18)	JMP	298
	0x0214 00532 (main.go:17)	LEAQ	88(AX), DI
	0x0218 00536 (main.go:11)	MOVQ	AX, DX
	0x021b 00539 (main.go:17)	MOVQ	CX, AX
	0x021e 00542 (main.go:17)	CALL	runtime.gcWriteBarrier(SB)
	0x0223 00547 (main.go:18)	MOVQ	DX, AX
	0x0226 00550 (main.go:17)	JMP	263
	0x022b 00555 (main.go:16)	LEAQ	72(AX), DI
	0x022f 00559 (main.go:11)	MOVQ	AX, DX
	0x0232 00562 (main.go:16)	MOVQ	CX, AX
	0x0235 00565 (main.go:16)	CALL	runtime.gcWriteBarrier(SB)
	0x023a 00570 (main.go:17)	MOVQ	DX, AX
	0x023d 00573 (main.go:16)	JMP	228
	0x0242 00578 (main.go:15)	LEAQ	56(AX), DI
	0x0246 00582 (main.go:11)	MOVQ	AX, DX
	0x0249 00585 (main.go:15)	MOVQ	CX, AX
	0x024c 00588 (main.go:15)	CALL	runtime.gcWriteBarrier(SB)
	0x0251 00593 (main.go:16)	MOVQ	DX, AX
	0x0254 00596 (main.go:15)	JMP	193
	0x0259 00601 (main.go:14)	LEAQ	40(AX), DI
	0x025d 00605 (main.go:11)	MOVQ	AX, DX
	0x0260 00608 (main.go:14)	MOVQ	CX, AX
	0x0263 00611 (main.go:14)	CALL	runtime.gcWriteBarrier(SB)
	0x0268 00616 (main.go:15)	MOVQ	DX, AX
	0x026b 00619 (main.go:14)	JMP	158
	0x0270 00624 (main.go:13)	LEAQ	24(AX), DI
	0x0274 00628 (main.go:11)	MOVQ	AX, CX
	0x0277 00631 (main.go:13)	LEAQ	"".statictmp_1(SB), AX
	0x027e 00638 (main.go:13)	CALL	runtime.gcWriteBarrier(SB)
	0x0283 00643 (main.go:14)	MOVQ	CX, AX
	0x0286 00646 (main.go:13)	JMP	123
	0x028b 00651 (main.go:12)	LEAQ	8(AX), DI
	0x028f 00655 (main.go:11)	MOVQ	AX, CX
	0x0292 00658 (main.go:12)	LEAQ	"".statictmp_0(SB), AX
	0x0299 00665 (main.go:12)	CALL	runtime.gcWriteBarrier(SB)
	0x029e 00670 (main.go:13)	MOVQ	CX, AX
	0x02a1 00673 (main.go:12)	JMP	88
	0x02a6 00678 (main.go:12)	NOP
	0x02a6 00678 (main.go:10)	CALL	runtime.morestack_noctxt(SB)
	0x02ab 00683 (main.go:10)	JMP	0

In my program I have many of these slice literals, some with thousands of entries. The generated code is ~60B/entry, when I expect that this could theoretically be closer to 8B/entry for the *rtype pointer.

\cc @randall77
@randall77
Copy link
Contributor

This is a case where removing the write barrier could help a lot.

To remove the write barrier we need to know 2 things:

  1. The location being written to doesn't have a heap pointer in it.
  2. The pointer being written is not a pointer to a heap object.

The latter is easy, the addresses of globals and nil pointers are not heap pointers.

The former is harder. We are writing to a newly allocated object, so it starts out zeroed, but in order to be sure each write is to a zeroed location we need to understand that all the writes are to distinct parts of the newly allocated object.

This is the kind of thing that https://go-review.googlesource.com/c/go/+/151498 was supposed to help with, but it can't quite prove it's safe to remove the write barrier in this case.

It shouldn't be hard to get this right for the stylized initializations that are done for slice literals and friends. It just needs a bit more analysis in the write barrier insertion pass.

@randall77 randall77 added this to the Go1.13 milestone Jan 4, 2019
@randall77
Copy link
Contributor

Another possibility to solve this issue is to make it so we initialize a statictmp with the desired contents and do just one typedmemmove to initialize the whole backing store.
It looks like the statictmp builder doesn't realize that some concrete->interface conversions can be done at compile time. That we could fix. We already do it for globals, like:

var y int
var x interface{} = &y

@randall77
Copy link
Contributor

Note that this does work currently if the slice literal is at global scope:

var x = []interface{}{
	(uint32)(0),
	(tar.Format)(0),
	(*tar.Header)(nil),
	(*tar.Reader)(nil),
	(*tar.Writer)(nil),
	(*zip.File)(nil),
	(*zip.FileHeader)(nil),
	(*zip.ReadCloser)(nil),
	(*zip.Reader)(nil),
	(*zip.Writer)(nil),
}

@randall77
Copy link
Contributor

Generates just:

"".x SDATA size=24
	0x0000 00 00 00 00 00 00 00 00 0a 00 00 00 00 00 00 00  ................
	0x0010 0a 00 00 00 00 00 00 00                          ........
	rel 0+8 t=1 "".statictmp_0+0
"".statictmp_0 SDATA size=160
	0x0000 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
	0x0010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
	0x0020 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
	0x0030 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
	0x0040 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
	0x0050 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
	0x0060 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
	0x0070 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
	0x0080 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
	0x0090 00 00 00 00 00 00 00 00                          ........
	rel 0+8 t=1 type.uint32+0
	rel 8+8 t=1 "".statictmp_1+0
	rel 16+8 t=1 type.archive/tar.Format+0
	rel 24+8 t=1 "".statictmp_2+0
	rel 32+8 t=1 type.*archive/tar.Header+0
	rel 48+8 t=1 type.*archive/tar.Reader+0
	rel 64+8 t=1 type.*archive/tar.Writer+0
	rel 80+8 t=1 type.*archive/zip.File+0
	rel 96+8 t=1 type.*archive/zip.FileHeader+0
	rel 112+8 t=1 type.*archive/zip.ReadCloser+0
	rel 128+8 t=1 type.*archive/zip.Reader+0
	rel 144+8 t=1 type.*archive/zip.Writer+0
"".statictmp_1 SNOPTRBSS size=4
"".statictmp_2 SNOPTRBSS size=8

@gopherbot
Copy link
Contributor

Change https://golang.org/cl/156363 mentions this issue: cmd/compile: better write barrier removal when initializing new objects

This was referenced Jan 5, 2019
Open
Open
@gopherbot
Copy link
Contributor

Change https://golang.org/cl/157799 mentions this issue: runtime: keep FuncForPC from crashing for PCs between functions

gopherbot pushed a commit that referenced this issue Mar 18, 2019
@randall77
cmd/compile: better write barrier removal when initializing new objects
ca36af2 
When initializing a new object, we're often writing
1) to a location that doesn't have a pointer to a heap object
2) a pointer that doesn't point to a heap object

When both those conditions are true, we can avoid the write barrier.

This CL detects case 1 by looking for writes to known-zeroed
locations.  The results of runtime.newobject are zeroed, and we
perform a simple tracking of which parts of that object are written so
we can determine what part remains zero at each write.

This CL detects case 2 by looking for addresses of globals (including
the types and itabs which are used in interfaces) and for nil pointers.

Makes cmd/go 0.3% smaller. Some particular cases, like the slice
literal in #29573, can get much smaller.

TODO: we can remove actual zero writes also with this mechanism.

Update #29573

Change-Id: Ie74a3533775ea88da0495ba02458391e5db26cb9
Reviewed-on: https://go-review.googlesource.com/c/go/+/156363
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
@julieqiu julieqiu added the NeedsFix The path to resolution is known, but the work has not been done. label May 28, 2019
@andybons andybons modified the milestones: Go1.13, Go1.14 Jul 8, 2019
@thanm
Copy link
Contributor

thanm commented Sep 10, 2019 •
edited
Loading

Drive-by comment: I note that when compiling with tip, the generated code looks better (no longer includes write barriers):

"".makeLiteral STEXT size=304 args=0x18 locals=0x18
	0x0000 00000 (issue29573.go:8)	TEXT	"".MakeLiteral(SB), ABIInternal, $24-24
	0x0000 00000 (issue29573.go:8)	MOVQ	(TLS), CX
	0x0009 00009 (issue29573.go:8)	CMPQ	SP, 16(CX)
	0x000d 00013 (issue29573.go:8)	JLS	294
	0x0013 00019 (issue29573.go:8)	SUBQ	$24, SP
	0x0017 00023 (issue29573.go:8)	MOVQ	BP, 16(SP)
	0x001c 00028 (issue29573.go:8)	LEAQ	16(SP), BP
	0x0021 00033 (issue29573.go:8)	FUNCDATA	$0, gclocals·9fb7f0986f647f17cb53dda1484e0f7a(SB)
	0x0021 00033 (issue29573.go:8)	FUNCDATA	$1, gclocals·69c1753bd5f81501d95132d08af04464(SB)
	0x0021 00033 (issue29573.go:8)	FUNCDATA	$2, gclocals·bfec7e55b3f043d1941c093912808913(SB)
	0x0021 00033 (issue29573.go:9)	PCDATA	$0, $1
	0x0021 00033 (issue29573.go:9)	PCDATA	$1, $0
	0x0021 00033 (issue29573.go:9)	LEAQ	type.[10]interface {}(SB), AX
	0x0028 00040 (issue29573.go:9)	PCDATA	$0, $0
	0x0028 00040 (issue29573.go:9)	MOVQ	AX, (SP)
	0x002c 00044 (issue29573.go:9)	CALL	runtime.newobject(SB)
	0x0031 00049 (issue29573.go:9)	PCDATA	$0, $1
	0x0031 00049 (issue29573.go:9)	MOVQ	8(SP), AX
	0x0036 00054 (issue29573.go:10)	PCDATA	$0, $2
	0x0036 00054 (issue29573.go:10)	LEAQ	type.uint32(SB), CX
	0x003d 00061 (issue29573.go:10)	PCDATA	$0, $1
	0x003d 00061 (issue29573.go:10)	MOVQ	CX, (AX)
	0x0040 00064 (issue29573.go:10)	PCDATA	$0, $2
	0x0040 00064 (issue29573.go:10)	LEAQ	""..stmp_0(SB), CX
	0x0047 00071 (issue29573.go:10)	PCDATA	$0, $1
	0x0047 00071 (issue29573.go:10)	MOVQ	CX, 8(AX)
	0x004b 00075 (issue29573.go:11)	PCDATA	$0, $2
	0x004b 00075 (issue29573.go:11)	LEAQ	type.archive/tar.Format(SB), CX
	0x0052 00082 (issue29573.go:11)	PCDATA	$0, $1
	0x0052 00082 (issue29573.go:11)	MOVQ	CX, 16(AX)
	0x0056 00086 (issue29573.go:11)	PCDATA	$0, $2
	0x0056 00086 (issue29573.go:11)	LEAQ	""..stmp_1(SB), CX
	0x005d 00093 (issue29573.go:11)	PCDATA	$0, $1
	0x005d 00093 (issue29573.go:11)	MOVQ	CX, 24(AX)
	0x0061 00097 (issue29573.go:12)	PCDATA	$0, $2
	0x0061 00097 (issue29573.go:12)	LEAQ	type.*archive/tar.Header(SB), CX
	0x0068 00104 (issue29573.go:12)	PCDATA	$0, $1
	0x0068 00104 (issue29573.go:12)	MOVQ	CX, 32(AX)
	0x006c 00108 (issue29573.go:12)	MOVQ	$0, 40(AX)
	0x0074 00116 (issue29573.go:13)	PCDATA	$0, $2
	0x0074 00116 (issue29573.go:13)	LEAQ	type.*archive/tar.Reader(SB), CX
	0x007b 00123 (issue29573.go:13)	PCDATA	$0, $1
	0x007b 00123 (issue29573.go:13)	MOVQ	CX, 48(AX)
	0x007f 00127 (issue29573.go:13)	MOVQ	$0, 56(AX)
	0x0087 00135 (issue29573.go:14)	PCDATA	$0, $2
	0x0087 00135 (issue29573.go:14)	LEAQ	type.*archive/tar.Writer(SB), CX
	0x008e 00142 (issue29573.go:14)	PCDATA	$0, $1
	0x008e 00142 (issue29573.go:14)	MOVQ	CX, 64(AX)
	0x0092 00146 (issue29573.go:14)	MOVQ	$0, 72(AX)
	0x009a 00154 (issue29573.go:15)	PCDATA	$0, $2
	0x009a 00154 (issue29573.go:15)	LEAQ	type.*archive/zip.File(SB), CX
	0x00a1 00161 (issue29573.go:15)	PCDATA	$0, $1
	0x00a1 00161 (issue29573.go:15)	MOVQ	CX, 80(AX)
	0x00a5 00165 (issue29573.go:15)	MOVQ	$0, 88(AX)
	0x00ad 00173 (issue29573.go:16)	PCDATA	$0, $2
	0x00ad 00173 (issue29573.go:16)	LEAQ	type.*archive/zip.FileHeader(SB), CX
	0x00b4 00180 (issue29573.go:16)	PCDATA	$0, $1
	0x00b4 00180 (issue29573.go:16)	MOVQ	CX, 96(AX)
	0x00b8 00184 (issue29573.go:16)	MOVQ	$0, 104(AX)
	0x00c0 00192 (issue29573.go:17)	PCDATA	$0, $2
	0x00c0 00192 (issue29573.go:17)	LEAQ	type.*archive/zip.ReadCloser(SB), CX
	0x00c7 00199 (issue29573.go:17)	PCDATA	$0, $1
	0x00c7 00199 (issue29573.go:17)	MOVQ	CX, 112(AX)
	0x00cb 00203 (issue29573.go:17)	MOVQ	$0, 120(AX)
	0x00d3 00211 (issue29573.go:18)	PCDATA	$0, $2
	0x00d3 00211 (issue29573.go:18)	LEAQ	type.*archive/zip.Reader(SB), CX
	0x00da 00218 (issue29573.go:18)	PCDATA	$0, $1
	0x00da 00218 (issue29573.go:18)	MOVQ	CX, 128(AX)
	0x00e1 00225 (issue29573.go:18)	MOVQ	$0, 136(AX)
	0x00ec 00236 (issue29573.go:19)	PCDATA	$0, $2
	0x00ec 00236 (issue29573.go:19)	LEAQ	type.*archive/zip.Writer(SB), CX
	0x00f3 00243 (issue29573.go:19)	PCDATA	$0, $1
	0x00f3 00243 (issue29573.go:19)	MOVQ	CX, 144(AX)
	0x00fa 00250 (issue29573.go:19)	MOVQ	$0, 152(AX)
	0x0105 00261 (issue29573.go:9)	PCDATA	$0, $0
	0x0105 00261 (issue29573.go:9)	PCDATA	$1, $1
	0x0105 00261 (issue29573.go:9)	MOVQ	AX, "".~r0+32(SP)
	0x010a 00266 (issue29573.go:9)	MOVQ	$10, "".~r0+40(SP)
	0x0113 00275 (issue29573.go:9)	MOVQ	$10, "".~r0+48(SP)
	0x011c 00284 (issue29573.go:9)	MOVQ	16(SP), BP
	0x0121 00289 (issue29573.go:9)	ADDQ	$24, SP
	0x0125 00293 (issue29573.go:9)	RET
	0x0126 00294 (issue29573.go:9)	NOP
	0x0126 00294 (issue29573.go:8)	PCDATA	$1, $-1
	0x0126 00294 (issue29573.go:8)	PCDATA	$0, $-1
	0x0126 00294 (issue29573.go:8)	CALL	runtime.morestack_noctxt(SB)
	0x012b 00299 (issue29573.go:8)	JMP	0

Can this bug be closed out as a result?

@dsnet
Copy link
Member Author

dsnet commented Sep 11, 2019

Yep. Can confirm this is much better.

@dsnet dsnet closed this as completed Sep 11, 2019
@golang golang locked and limited conversation to collaborators Sep 10, 2020
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Assignees
No one assigned
Labels
FrozenDueToAge NeedsFix The path to resolution is known, but the work has not been done. Performance
Projects
None yet
Milestone
Go1.14
Development

No branches or pull requests
6 participants
@andybons @julieqiu @dsnet @randall77 @gopherbot @thanm