Golang slice append vs assign performance

Question

To make slice append operation faster we need to allocate enough capacity. There's two ways to append slice, Here is the code:

func BenchmarkSliceAppend(b *testing.B) {     a := make([]int, 0, b.N)     for i := 0; i < b.N; i++ {         a = append(a, i)     } }  func BenchmarkSliceSet(b *testing.B) {     a := make([]int, b.N)     for i := 0; i < b.N; i++ {         a[i] = i     } } 

And the result is:

BenchmarkSliceAppend-4 200000000 7.87 ns/op 8 B/op 0 allocs/op

BenchmarkSliceSet-4 300000000 5.76 ns/op 8 B/op

Why is a[i] = i faster than a = append(a, i)?

Answer 1

a[i] = i simply assigns the value i to a[i]. This is not appending, it's just a simple assignment.

Now the append:

a = append(a, i) 

In theory the following happens:

1. This calls the builtin append() function. For that, it first has to copy the a slice (slice header, backing array is not part of the header), and it has to create a temporary slice for the variadic parameter which will contain the value i.

2. Then it has to reslice a if it has enough capacity (it has in your case) like a = a[:len(a)+1] - which involves assigning the new slice to a inside the append().
   _{(If a would not have big enough capacity to do the append "in-place", a new array would have to be allocated, content from slice copied, and then the assign / append be executed - but it is not the case here.)}

3. Then assigns i to a[len(a)-1].

4. Then returns the new slice from append(), and this new slice is assigned to the local variable a.

A lot of things happen here compared to a simple assignment. Even if many of these steps are optimized and / or inlined, as a minimum addition to assigning i to an element of the slice, the local variable a of slice type (which is a slice header) has to be updated in each cycle of the loop.

Recommended reading: The Go Blog: Arrays, slices (and strings): The mechanics of 'append'

Answer 2

It seems like some improvements of Go compiler or runtime have been introduced since this question has been posted, so now (Go 1.10.1) there is no significant difference between append and direct assignment by index.

Also, I had to change your benchmarks slightly because of OOM panics.

package main  import "testing"  var result []int  const size = 32  const iterations = 100 * 1000 * 1000  func doAssign() {     data := make([]int, size)     for i := 0; i < size; i++ {         data[i] = i     }     result = data }  func doAppend() {     data := make([]int, 0, size)     for i := 0; i < size; i++ {         data = append(data, i)     }     result = data }  func BenchmarkAssign(b *testing.B) {     b.N = iterations     for i := 0; i < b.N; i++ {         doAssign()     } }  func BenchmarkAppend(b *testing.B) {     b.N = iterations     for i := 0; i < b.N; i++ {         doAppend()     } } 

Results:

➜  bench_slice_assign go test -bench=Bench . goos: linux goarch: amd64 BenchmarkAssign-4       100000000           80.9 ns/op BenchmarkAppend-4       100000000           81.9 ns/op PASS ok      _/home/isaev/troubles/bench_slice_assign    16.288s