Go Optimizations 101 (20220829) by Tapir Liu

Author:Tapir Liu
Language: eng
Format: epub

Structs

Avoid accessing fields of a struct in a loop though pointers to the struct

It is much faster to let CPU instructions process registers than process memory. So, to let the compiler generate less memory-processing assembly instructions for a loop, we should avoid accessing fields of a struct though pointers to the struct in the loop.

For example, in the following code, the function g is much performant than the function f.

package structs import "testing" const N = 1000 type T struct { x int } //go:noinline func f(t *T) { t.x = 0 for i := 0; i < N; i++ { t.x += i } } //go:noinline func g(t *T) { var x = 0 for i := 0; i < N; i++ { x += i } t.x = x } var t = &T{} func Benchmark_f(b *testing.B) { for i := 0; i < b.N; i++ { f(t) } } func Benchmark_g(b *testing.B) { for i := 0; i < b.N; i++ { g(t) } }

The benchmark results:

Benchmark_f-4 2402 ns/op Benchmark_g-4 461.3 ns/op

The function g uses a local variable x to store the sum value and assigns the sum value to the struct field in the end. The official standard Go compiler is smart enough to only generate register-processing assembly instructions for the loop of the function g.

The function f is actually equivalent to the function h declared below.

//go:noinline func h(t *T) { x := &t.x for i := 0; i < N; i++ { *x += i } }

So the suggestion introduced here is actually equivalent to the one introduced in the last chapter (avoid unnecessary pointer dereferences in a loop).

Download

Copyright Disclaimer:
This site does not store any files on its server. We only index and link to content provided by other sites. Please contact the content providers to delete copyright contents if any and email us, we'll remove relevant links or contents immediately.