Go Array vs Slice Benchmark

Array

Arrays in Go are fixed-length sequences of elements of a single type.

Comparison

• Array run is 98.37% faster than Dynamic Slice run.
• Array run is 95.39% faster than Preallocated Slice run.

func BenchmarkArray_run(b *testing.B) {
	var arr [1000]int // Define an array of fixed size

	b.ResetTimer()

	for i := 0; i < 1_000; i++ {
		for j := range arr {
			arr[j] = i
		}

		arr = [1000]int{} // Reset the array
	}
}

Array run

By Run Count

By CPU Core Count

Dynamic Slice

Slices in Go are variable-length sequences of elements of a single type. They are built on top of arrays. Each time you append an element to a slice, the Go runtime checks if the underlying array is large enough to hold the new element. If it is not large enough, the runtime allocates a new array and copies the elements from the old array to the new one. This makes dynamic slices very flexible, but also slower.

Comparison

• Dynamic Slice run is 6043.18% slower than Array run.
• Dynamic Slice run is 183.13% slower than Preallocated Slice run.

func BenchmarkDynamicSlice_run(b *testing.B) {
	var slice []int // Define a dynamic slice

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		for j := 0; j < 1000; j++ {
			slice = append(slice, i)
		}

		slice = []int{} // Reset the slice
	}
}

Dynamic Slice run

By Run Count

By CPU Core Count

Preallocated Slice

Pre-allocated slices are slices, that have a fixed length and capacity. They are built on top of arrays. Each time you append an element to a pre-allocated slice, the Go runtime checks if the underlying array is large enough to hold the new element. If it is not large enough, the runtime allocates a new array and copies the elements from the old array to the new one. This makes pre-allocated slices very flexible, but also slower. The advantage of pre-allocated slices is, that you can pre-allocate the underlying array, so that the runtime does not need to allocate a new array each time you append an element. This makes pre-allocated slices faster than dynamic slices, but they are still slower than arrays.

Comparison

• Preallocated Slice run is 2069.71% slower than Array run.
• Preallocated Slice run is 64.68% faster than Dynamic Slice run.

func BenchmarkPreallocatedSlice_run(b *testing.B) {
	slice := make([]int, 1000) // Define a slice with the same size as the array

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		for j := range slice {
			slice[j] = i
		}

		slice = make([]int, 1000) // Reset the slice
	}
}

Preallocated Slice run

By Run Count

By CPU Core Count