PidokuInfra
03Memory

Memory

IntermediateModule 035 topics~4h 45m

Topics, in order

01 Stack and HeapA Go program keeps values in two kinds of place. Each goroutine has a stack: a contiguous block where a function's local variables live for exactly as long as the function runs. Allocating … Intermediate 45 min 02 Escape AnalysisEscape analysis is the compiler pass that decides, for every variable, whether it can live on the stack. The question it asks is: could anything still refer to this value after the function … Intermediate 55 min 03 The AllocatorWhen a value escapes, the runtime's allocator finds it memory. It is built for one goal: make the common case — a small object — lock-free and a few nanoseconds. Advanced 1h 04 The Garbage CollectorGo's garbage collector finds heap objects that nothing can reach any more and frees them. It is a concurrent mark-and-sweep collector: it traces everything reachable from the roots … Advanced 1h 10m 05 Writing Allocation-Aware CodeMost Go performance work is allocation work. The method is always the same: measure which allocations are on the hot path, then remove them with a small set of techniques — preallocate, … Advanced 55 min

About this module

Go manages memory for you. This module explains exactly how, because the difference between a service that spends 2% of its CPU on memory management and one that spends 30% is almost always a handful of decisions you can see once you know where to look.

#LessonThe question it answers
01Stack and HeapWhere do values live, and what does each place cost?
02Escape AnalysisHow does the compiler decide, and how do I read its decision?
03The AllocatorWhat happens, step by step, when the heap is asked for memory?
04The Garbage CollectorHow is unused memory found and freed while the program keeps running?
05Writing Allocation-Aware CodeHow do I cut allocations where it matters?

When you finish you can predict whether a line of code allocates, explain what GOGC and GOMEMLIMIT do, read a GC trace, and remove the allocations from a hot path.

flowchart LR
  V["A value is created"] --> EA{"Escape analysis:<br/>can it outlive the function?"}
  EA -->|"no"| ST["Goroutine stack<br/>free: just move a pointer"]
  EA -->|"yes"| AL["Allocator<br/>size class, span, per-thread cache"]
  AL --> HP[("Heap")]
  HP --> GC["Garbage collector<br/>mark what is reachable, sweep the rest"]
  GC -->|"freed spans"| AL
  class V neutral
  class EA queue
  class ST compute
  class AL,HP,GC memory
esc

↑↓ navigate↵ openesc close