Goroutines的基准

Question

Pretty new to the Golang here and bumped into a problem when benchmarking with goroutines.

The code I have is here:

    type store struct{}

    func (n *store) WriteSpan(span interface{}) error {
        return nil
    }

    func smallTest(times int, b *testing.B) {
        writer := store{}
        var wg sync.WaitGroup
        numGoroutines := times
        wg.Add(numGoroutines)
        b.ResetTimer()
        b.ReportAllocs()
        for n := 0; n < numGoroutines; n++ {
            go func() {
                writer.WriteSpan(nil)
                wg.Done()
            }()
        }
        wg.Wait()
    }
    func BenchmarkTest1(b *testing.B) {
        smallTest(1000000, b)
    }

    func BenchmarkTest2(b *testing.B) {
        smallTest(10000000, b)
    }

It looks to me the runtime and allocation for both scenario should be similar, but running them gives me the following results which are vastly different. Wonder why this happens? Where do those extra allocations come from?

BenchmarkTest1-12 1000000000 0.26 ns/op 0 B/op 0 allocs/op

BenchmarkTest2-12 1 2868129398 ns/op 31872 B/op 83 allocs/op

PASS

I also notice If I add a inner loop to writeSpan multiple times, the runtime and allocation kind of relates to the numGoroutines * multiple times. If this is not the way how people benchmark with goroutines, are there any other standard ways to test? Thanks in advance.

Answer 1

Meaningless microbenchmarks produce meaningless results.

---

If this is not the way how people benchmark with goroutines, are there any other standard ways to test?

It's not the way to benchmark anything. Benchmark real problems.

You run a very large number of goroutines, which do nothing, until you saturate the scheduler, the machine, and other resources. That merely proves that if you run anything enough times you can bring a machine to its knees.