Memory Profiling

In this lesson, explore memory profiling through one small Go program, and connect its output to the language rules behind it.

Memory profiles describe allocation sites and retained heap objects. The runtime/pprof tool and go test -memprofile help identify where memory is used.

Different views answer different questions: allocation totals show churn, while in-use objects show memory retained at the observation point.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

Commands: go test -run ^$ -bench . -memprofile mem.out, then go tool pprof -alloc_space mem.out or the default heap view. See the runtime/pprof package.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import "fmt"

func build(n int) []int {
	values := make([]int, 0, n)
	for i := 0; i < n; i++ {
		values = append(values, i)
	}
	return values
}
func main() { values := build(4); fmt.Println("Items:", values) }

Output

Items: [0 1 2 3]

The function preallocates capacity for four values and appends them. Its predictable result makes it a good starting point for comparing allocation patterns.

• The size of one test slice does not predict production memory pressure.
• An allocation profile differs from a heap-in-use profile.

Benchmark build(1000) with and without preallocation and compare -benchmem and pprof.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Memory Profiling in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.