有什么更有效的方法，可以返回指向uint或uint的指针？

Question

In Go, what is more efficient to return from a function: returning a uint or returning a *uint?

The function is called in the inner for-loop of a cpu-intensive library.

Answer 1

In general, whenever efficiency is the question, you should run benchmarks.

Let's create very simple examples:

func fuint() uint {
    return 0
}

func fpuint() *uint {
    var i uint
    return &i
}

And the benchmarking code:

func BenchmarkUint(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fuint()
    }
}

func BenchmarkPuint(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fpuint()
    }
}

One thing to look out for: since we have very simple functions, code optimization might render the result useless (e.g. we might see the same result).

So instead we should test by disabling compiler optimizations. So let's test it like this:

go test -gcflags '-N -l' -bench . -benchmem

The test results:

BenchmarkUint-4     500000000        3.21 ns/op      0 B/op     0 allocs/op
BenchmarkPuint-4    100000000       22.4 ns/op       8 B/op     1 allocs/op

Just as we could have guessed: allocating an uint value and returning a pointer to it is slower and requires an allocation (on the heap), while returning a simple uint value does not.

But don't think this is always the case. During this test, we disabled compiler optimizations. When you compile your app to production, you will obviously not disable optimizations, so your real-life examples might not have such big difference, or no difference at all. Test / benchmark your actual code to see if returning a pointer actually makes any noticeable difference.

For reference, here is the result with compiler optimizations enabled (default behavior):

go test -bench . -benchmem

BenchmarkUint-4     2000000000         0.35 ns/op        0 B/op      0 allocs/op
BenchmarkPuint-4    2000000000         0.35 ns/op        0 B/op      0 allocs/op

We see no difference for fuint() and fpuint() at all in the specific examples above.