最小化go map的内存分配

Question

I am currently digging into optimising some highly used code in go. My Question boils down to the following code snippet (copied with memory allocations from pprof list command). As you can see all the allocations are done in the line where map is being filled (line 959).

ROUTINE ======================== cart.BenchmarkMapWithOutCapacityFixVal in /.../cart_test.go
   3328966    3328966 (flat, cum) 15.50% of Total
         .          .    954:
         .          .    955:func BenchmarkMapWithOutCapacityFixVal(b *testing.B) {
         .          .    956:   for i := 0; i < b.N; i++ {
         .          .    957:       m := make(map[int]float32)
         .          .    958:       for k := 0; k < 10; k++ {
   3328966    3328966    959:           m[k] = 0.434295723423
         .          .    960:       }
         .          .    961:   }
         .          .    962:}

Here what I am trying to do: I am trying to allocate the memory before the (inner) loop so there are no unnecessary allocations happening:

ROUTINE ======================== cart.BenchmarkMapWithCapacityFixVal in /.../cart_test.go
   3214263    3214263 (flat, cum) 14.97% of Total
         .          .    963:
         .          .    964:func BenchmarkMapWithCapacityFixVal(b *testing.B) {
         .          .    965:   for i := 0; i < b.N; i++ {
   3048075    3048075    966:       m := make(map[int]float32, 10)
         .          .    967:       for k := 0; k < 10; k++ {
    166188     166188    968:           m[k] = 0.434295723423
         .          .    969:       }
         .          .    970:   }
         .          .    971:}

Why are there still allocations happening in line 968 (second sample) and how can I correctly allocate the map before the inner loop?

Answer 1

A map is not an array. You can't preallocate space in it because you can't know where in the map the elements will be inserted. In make(map..., X) X is just a capacity hint, it doesn't bound the map and definitely doesn't guarantee that the keys will hash perfectly into it. As such it will do a best effort of minimizing the number of future allocations, but there's no way to eliminate all of them.

In this particular example you should just use an array rather than a map if you want perfect control over allocations. With a proper array you'd have just one allocation.