cmd/compile: optimize large structs

[randall77]

The compiler currently compiles large structs conservatively. If a struct type has more than 4 fields (or a few other conditions), we treat that type as unSSAable. All operations on variables of that type go to the stack, as if their address was taken.

This is suboptimal in various ways. For example:

type T struct {
	a, b, c, d int
}

func f(x *T) {
	t := T{}
	*x = t
}

type U struct {
	a, b, c, d, e int
}

func g(x *U) {
	u := U{}
	*x = u
}

f is compiled optimally, to:

	XORPS	X0, X0
	MOVQ	"".x+8(SP), AX
	MOVUPS	X0, (AX)
	MOVUPS	X0, 16(AX)
	RET

g is quite a bit worse:

	MOVQ	BP, 40(SP)
	LEAQ	40(SP), BP
	MOVQ	$0, "".u(SP)
	XORPS	X0, X0
	MOVUPS	X0, "".u+8(SP)
	MOVUPS	X0, "".u+24(SP)
	MOVQ	"".u(SP), AX
	MOVQ	"".x+56(SP), CX
	MOVQ	AX, (CX)
	LEAQ	8(CX), DI
	LEAQ	"".u+8(SP), SI
	DUFFCOPY	$868
	MOVQ	40(SP), BP
	ADDQ	$48, SP
	RET

We zero a temporary variable on the stack, then copy it to the destination.

We should process large structs through SSA as well. This will require a fair amount of work in the SSA backend to introduce struct builders, selectors of arbitrary width, stack allocation of large types, maybe heap allocation if they are really huge, etc.

Arrays of size > 1 are in a similar state, but they are somewhat harder because non-constant indexes add an additional complication.

[josharian]

Just to ask an obvious question, is the problem that we want to handle all n, or just that n<=4 is too small? If the latter, and a reasonable cap is say 16, it might be easier to just extend the current approach, maybe using a bit of codegen magic. Probably we should Do It Right, but worth asking...

[randall77]

My intent is to handle all n.

[TocarIP]

Looks like this should also help #20859

[gopherbot]

Change https://golang.org/cl/106495 mentions this issue: cmd/compile: add some generic composite type optimizations

[gopherbot]

Change https://golang.org/cl/206937 mentions this issue: cmd/compile: optimize big structs

[zigo101]

It looks, for Go toolchain v1.16, structs with 8 int fields and [8]int values have already been viewed as small-size values.

[randall77]

It definitely compiles to better code now, but I think the underlying issue is still there. I think it just needs a better test case.

package p

type T struct {
	a, b, c, d int
}

type U struct {
	a, b, c, d, e int
}

func f() int {
	t := T{1, 2, 3, 4}
	return t.c
}
func g() int {
	u := U{1, 2, 3, 4, 5}
	return u.c
}

f is compiles to MOVL $3, AX; RET. g compiles to

SUBQ	$48, SP
MOVQ	BP, 40(SP)
LEAQ	40(SP), BP
MOVQ	$1, "".u(SP)
MOVQ	$2, "".u+8(SP)
MOVQ	$3, "".u+16(SP)
MOVQ	$4, "".u+24(SP)
MOVQ	$5, "".u+32(SP)
MOVQ	"".u+16(SP), AX
MOVQ	40(SP), BP
ADDQ	$48, SP
RET

[quasilyte]

I'm interested to know what's the status on this?

The CL206937 was abandoned but it's unclear why.

Are there any extra insights that came from that experiment?

[randall77]

It's not abandoned, it just isn't finished. It had issues. Performance wasn't good, and there were pathological cases, like large fields of even larger structs weren't handled well.

[gopherbot]

Change https://go.dev/cl/611076 mentions this issue: cmd/compile/internal/ssa: bump MaxStruct to 16

[gopherbot]

Change https://go.dev/cl/611075 mentions this issue: cmd/compile: generalize struct load/store