Golang - Slice Performance append has better performance than assign

I am trying to understand performance of slice appends vs assigns in Golang, and I would have thought generally an assign would be better, but in this bit of code, it looks like append is better. I am trying to figure out why - but am struggling with it.

This is a Merge Sorted Array in Leetcode and version 1 below gives me Runtime of 3 ms

func merge(nums1 []int, m int, nums2 []int, n int)  {
    
    tmpSlice := make([]int, m+n)
    tmpIndex := 0
    index1 := 0
    index2 := 0
    
    for index1 < m {
        value1 := nums1[index1]
        for index2 < n {
            value2 := nums2[index2]
            if value1 <= value2 {
                break
            } else {
                tmpSlice[tmpIndex] = value2    \\ <-- Assign
                index2++
                tmpIndex++          
            }
        }
        tmpSlice[tmpIndex] = value1    \\ <-- Assign
        index1++
        tmpIndex++ 
    }
    

    copy(nums1, tmpSlice[:tmpIndex])
    copy(nums1[tmpIndex:], nums2[index2:])

}

Version 2 below gives me a Runtime of 0 ms

func merge(nums1 []int, m int, nums2 []int, n int)  {
   
    tmpSlice := make([]int, 0, m+n)
    tmpIndex := 0
    index1 := 0
    index2 := 0
    
    for index1 < m {
        value1 := nums1[index1]
        for index2 < n {
            value2 := nums2[index2]
            if value1 <= value2 {
                break
            } else {
                tmpSlice = append(tmpSlice, value2)    \\ <-- Append
                index2++
                tmpIndex++          
            }
        }
        tmpSlice = append (tmpSlice, value1)    \\ <-- Append
        index1++
        tmpIndex++ 
    }
    

    copy(nums1, tmpSlice[:tmpIndex])
    copy(nums1[tmpIndex:], nums2[index2:])

}

The only difference in the two versions is the append vs assign, and the append is faster. Append is checking for memory allocation and then doing an assign, right? Shouldn't Append be slower?

I put both in a benchmarks, performance between the two is almost equal, append is slower, but by an almost negligible amount.

package main_test

import "testing"

func BenchmarkMerge1(b *testing.B) {
	for i := 0; i < b.N; i++ {
		num1 := []int{1, 2, 3}
		num2 := []int{4, 5, 6}
		merge1(num1, len(num1), num2, len(num2))
	}
}

func merge1(nums1 []int, m int, nums2 []int, n int) {

	tmpSlice := make([]int, m+n)
	tmpIndex := 0
	index1 := 0
	index2 := 0

	for index1 < m {
		value1 := nums1[index1]
		for index2 < n {
			value2 := nums2[index2]
			if value1 <= value2 {
				break
			} else {
				tmpSlice[tmpIndex] = value2 // <-- Assign
				index2++
				tmpIndex++
			}
		}
		tmpSlice[tmpIndex] = value1 // <-- Assign
		index1++
		tmpIndex++
	}

	copy(nums1, tmpSlice[:tmpIndex])
	copy(nums1[tmpIndex:], nums2[index2:])
}

func BenchmarkMerge2(b *testing.B) {
	for i := 0; i < b.N; i++ {
		num1 := []int{1, 2, 3}
		num2 := []int{4, 5, 6}
		merge2(num1, len(num1), num2, len(num2))
	}
}

func merge2(nums1 []int, m int, nums2 []int, n int) {
	tmpSlice := make([]int, 0, m+n)
	tmpIndex := 0
	index1 := 0
	index2 := 0

	for index1 < m {
		value1 := nums1[index1]
		for index2 < n {
			value2 := nums2[index2]
			if value1 <= value2 {
				break
			} else {
				tmpSlice = append(tmpSlice, value2) // <-- Append
				index2++
				tmpIndex++
			}
		}
		tmpSlice = append(tmpSlice, value1) // <-- Append
		index1++
		tmpIndex++
	}

	copy(nums1, tmpSlice[:tmpIndex])
	copy(nums1[tmpIndex:], nums2[index2:])
}

Running tool: /usr/local/go/bin/go test -benchmem -run=^$ -bench ^(BenchmarkMerge1|BenchmarkMerge2)$ example.com/m
goos: linux
goarch: amd64
pkg: example.com/m
cpu: Intel(R) Core(TM) i7-10870H CPU @ 2.20GHz
BenchmarkMerge1-16    	34586568	        36.40 ns/op	      48 B/op	       1 allocs/op
BenchmarkMerge2-16    	32561293	        36.77 ns/op	      48 B/op	       1 allocs/op
PASS
ok  	example.com/m	2.533s

This is to be expected since append basically does an assignment as long as the slice has capacity. append also increment the len field in the slice header(thx @rustyx for that hint), which explains the difference.

You will see a larger difference when not setting an initial capacity on the slice and using append since it will "grow" the underlying array which takes time.

If we change tmpSlice := make([]int, 0, m+n) to tmpSlice := make([]int, 0) in merge2 we get this result:

Running tool: /usr/local/go/bin/go test -benchmem -run=^$ -bench ^(BenchmarkMerge1|BenchmarkMerge2)$ example.com/m

goos: linux
goarch: amd64
pkg: example.com/m
cpu: Intel(R) Core(TM) i7-10870H CPU @ 2.20GHz
BenchmarkMerge1-16    	37319397	        32.34 ns/op	      48 B/op	       1 allocs/op
BenchmarkMerge2-16    	14543529	        87.75 ns/op	      56 B/op	       3 allocs/op
PASS
ok  	example.com/m	2.604s

TL;DR, append is slower than assigning(since the len field in the slice is incremented), by an almost negligible amount, as long as the slice has capacity