cmd/compile: keeping a subset of a struct value's fields is slow

[mvdan]

What version of Go are you using (go version)?

go version devel +e601c07908 Tue Mar 13 22:02:46 2018 +0000 linux/amd64

What did you do?

https://play.golang.org/p/H9LaiI3BP-U

See the comments as to why I prefer writing the slower version, as it helps maintain the software in the long run.

What did you expect to see?

The two to perform the same, or at least comparably.

What did you see instead?

The second method being easily 10x as slow.

BenchmarkResetUnwanted-4     2000000000      0.72 ns/op     0 B/op     0 allocs/op
BenchmarkKeepWanted-4        200000000       9.72 ns/op     0 B/op     0 allocs/op

I can imagine why this is; naively, the second function does more work. It has to write the entire struct - 7 ints - instead of just three ints, like the first one. However, I'd hope that the compiler can learn to recognise assignments like these to avoid the unnecessary extra work.

[mvdan]

This also seems somewhat common in the standard library:

$ gogrep '*$x = $T{$*_, $k: $x.$v, $*_}' std
compress/flate/dict_decoder.go:40:2: *dd = dictDecoder{hist: dd.hist}
compress/flate/inflate.go:766:2: *f = decompressor{r: makeReader(r), bits: f.bits, codebits: f.codebits, dict: f.dict, step: (*decompressor).nextBlock}
compress/gzip/gunzip.go:104:2: *z = Reader{decompressor: z.decompressor, multistream: true}
compress/zlib/reader.go:130:2: *z = reader{decompressor: z.decompressor}

There may be more occurrences where the code was replaced with the faster version.

[mvdan]

Also, I realise that this example is perhaps a bit extreme, since the subset of the fields I want to keep is contiguous. However, I imagine that this would still bring some gains in real code.

[josharian]

Nice observation. Implements of this optimization need to take care with panics, though—that both the partially-written memory state is correct and that the panic occurs on the correct line (with a multi-line struct literal). Not a show-stopper, just requires some care.

[TocarIP]

Looking at asm fast case uses 3 instructions to store zeros, while slow case does a lot of stuff:
1)Zeros 56 bytes of stack via 4 instructions
2)Does 4 8-byte copies via 8=2*4 instructions
3) Copies struct from stack to global sink

I think this is a known issue: structs with 4+ fields are treated differently , if I reduce number of fields to 2 (1 wanted,1 unwanted) both cases generate the same code. I think @randall77 knows exact issue number for structs with multiple fields.

[randall77]

I'm not sure there's an issue for improving large struct performance. I've been thinking about it, though.

[josharian]

@randall77 probably worth filing one. I've been wondering whether a large struct / large array issue might also help with #23929 in some cases.

[mvdan]

So the performance difference comes from the struct size, not from the different ways to clear some of the fields? Is there an optimization pass or rule that does this, i.e. avoiding the extra writes/work? Even for small structs, I would assume they would generate different code.

[gopherbot]

Change https://golang.org/cl/100837 mentions this issue: cmd/compile: optimize struct partial self-assign

[TocarIP]

It isn't exactly about size, but about number of fields. For <4 fields
*t = Foo{a:t.a} is represented as filed by field assignment.
So something like:

tmp = t.a
t.a = tmp
t.x = 0

Then t.a self assignment gets optimized away and we are left with t.x = 0 for both cases.

[mvdan]

Thanks for the clarification!

[randall77]

Filed #24416 for large struct optimization.

[randall77]

The underlying concern, that code for zeroing a new field might be missed, can be addressed with a test.

func TestResetUnwanted(t *testing.T) {
	// Note: unkeyed constructor. It will not compile if new fields are added.
	x := T{1, 1, 1, 1, 1, 1, 1}
	// Reset unexported fields.
	ResetUnwanted(&x)
	// Reset exported fields with reflect (or any other method to enumerate the "wanted" fields).
	v := reflect.ValueOf(&x).Elem()
	for i := 0; i < v.Type().NumField(); i++ {
		if v.Type().Field(i).PkgPath == "" { // exported field
			v.Field(i).Set(reflect.Zero(v.Field(i).Type()))
		}
	}

	// Everything should now be zero.
	if x != (T{}) {
		t.Errorf("ResetUnwanted missed a field %v\n", x)
	}
}

[gopherbot]

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