L'escape analysis Escape analysis

Le compilateur décide, seul, si une valeur vit sur la pile (gratuite) ou s'échappe vers le tas (allouée, ramassée plus tard). Retourner &x l'envoie au tas ; une interface peut l'y pousser aussi. -gcflags=-m te montre la décision. The compiler alone decides whether a value lives on the stack (free) or escapes to the heap (allocated, collected later). Returning &x sends it to the heap; an interface can push it there too. -gcflags=-m shows you the decision.

Audience
Dev qui veut comprendre d'où viennent les allocations et comment lire les décisions du compilateur Dev who wants to understand where allocations come from and how to read compiler decisions
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●●●
Date
Juin 2028 Jun 2028

Escape analysisPileTas

SommaireContents ·
№ 01CadrageFraming3 min

La pile est gratuite. Le tas coûte. Le compilateur décide seul — -gcflags=-m te montre ses choix.The stack is free. The heap costs. The compiler decides alone — -gcflags=-m shows you its choices.

Les volumes précédents ont couvert la concurrence, les erreurs, la mémoire partagée. Ce dernier volume descend sous le langage : comment Go gère la mémoire physiquement, où les valeurs vivent, et ce que le runtime fait pendant qu'on travaille. Chaque valeur en Go vit quelque part — sur la pile ou sur le tas. La pile est locale à une goroutine, allouée en bloc au démarrage, libérée automatiquement quand la fonction retourne : son coût est nul. Le tas est partagé entre toutes les goroutines, alloué dynamiquement, et devra être ramassé par le GC : son coût est réel. L'escape analysis est l'analyse statique que le compilateur effectue pour décider, à la compilation, où chaque valeur vivra à l'exécution. La règle de base est simple : une valeur dont la durée de vie ne dépasse pas la frame de la fonction qui la crée peut rester sur la pile. Dès qu'elle doit survivre à cet appel — parce qu'on retourne son adresse, parce qu'on la stocke dans une struct allouée sur le tas, parce qu'une goroutine y accède — elle s'échappe vers le tas. Le compilateur résout cette question seul, sans annotation du programmeur. -gcflags="-m" rend ses décisions visibles : chaque ligne "moved to heap" ou "x escapes to heap" est une allocation que le GC devra éventuellement ramasser.Previous volumes covered concurrency, errors, shared memory. This last volume goes below the language: how Go manages memory physically, where values live, and what the runtime does while you work. Every value in Go lives somewhere — on the stack or the heap. The stack is local to a goroutine, allocated in bulk at startup, freed automatically when the function returns: its cost is zero. The heap is shared across all goroutines, dynamically allocated, and must be collected by the GC: its cost is real. Escape analysis is the static analysis the compiler performs to decide, at compile time, where each value will live at runtime. The basic rule is simple: a value whose lifetime doesn't exceed the frame of the function that creates it can stay on the stack. As soon as it must outlive that call — because you return its address, because you store it in a heap-allocated struct, because a goroutine accesses it — it escapes to the heap. The compiler resolves this question alone, without programmer annotation. -gcflags="-m" makes its decisions visible: each "moved to heap" or "x escapes to heap" line is an allocation the GC will eventually need to collect.

La décision du compilateur : pile ou tas ?The compiler's decision: stack or heap?
// go build -gcflags="-m" ./...
// Le compilateur annote chaque décision d'allocation.

func newPoint(x, y float64) *Point {
    p := Point{x, y}   // p vit ICI — sur la pile de newPoint ?
    return &p           // on retourne son adresse → le compilateur DOIT l'allouer sur le tas
}
// sortie : ./main.go:4:2: moved to heap: p

func sum(a, b int) int {
    return a + b        // résultat retourné par valeur — reste sur la pile
}
// pas d'annotation : rien n'a fui
Pile vs tas — le résuméStack vs heap — the summary
Pile
locale · gratuite · libérée à la sortie de la frame
Tas
partagé · alloué · ramassé par le GC

Le compilateur choisit la pile quand il peut prouver que la durée de vie ne dépasse pas la frame. Dès qu'il ne peut pas prouver, il envoie sur le tas — sûr, mais coûteux.The compiler chooses the stack when it can prove the lifetime doesn't exceed the frame. As soon as it can't prove, it sends to the heap — safe, but costly.

Le réflexe du numéroThe issue's reflex

« Est-ce que cette valeur doit survivre à la fonction qui la crée ? » Si oui, elle ira sur le tas. Ce n'est pas un problème en soi — c'est le comportement attendu pour les valeurs longue durée. Le problème arrive quand une valeur qui n'avait pas besoin de survivre s'échappe quand même — via une interface, via un closure capturant un pointeur, via une goroutine. C'est là que -gcflags="-m" révèle des surprises."Does this value need to outlive the function that creates it?" If yes, it will go to the heap. That's not a problem in itself — it's the expected behavior for long-lived values. The problem comes when a value that didn't need to outlive its function escapes anyway — through an interface, through a closure capturing a pointer, through a goroutine. That's where -gcflags="-m" reveals surprises.

La pile d'une goroutine est dynamiqueA goroutine's stack is dynamic

Contrairement à la plupart des langages, une goroutine Go commence avec une petite pile (2 Ko en Go 1.4+) qui grandit dynamiquement par copie si elle déborde. Pas de pile de taille fixe qui déborde au premier appel profond — la pile s'étend jusqu'à la limite configurée (1 Go par défaut sur 64 bits) ; une récursion infinie finit quand même en « fatal error: stack overflow ». Ce mécanisme de croissance explique pourquoi on peut lancer des millions de goroutines : chacune consomme très peu de mémoire au départ. Mais il a un coût : la copie de pile est une opération non triviale. Les valeurs sur le tas, elles, ne bougent jamais — c'est pourquoi on ne peut pas garder de pointeur brut C vers une valeur Go sur la pile.Unlike most languages, a Go goroutine starts with a small stack (2KB in Go 1.4+) that grows dynamically by copying if it overflows. No fixed-size stack that overflows on the first deep call — the stack extends up to a configured limit (1GB by default on 64-bit); infinite recursion still ends in 'fatal error: stack overflow'. This growth mechanism explains why you can launch millions of goroutines: each consumes very little memory initially. But it has a cost: stack copying is a non-trivial operation. Heap values never move — that's why you can't keep a raw C pointer to a Go value on the stack.

№ 02La surpriseThe surprise4 min

Passer une valeur à une interface l'envoie sur le tas — même une valeur entière. Le boxing est une allocation invisible.Passing a value to an interface sends it to the heap — even an integer value. Boxing is an invisible allocation.

La surprise la plus courante en escape analysis est le boxing d'interface. Quand on passe une valeur concrète à un paramètre de type interface — any, io.Writer, fmt.Stringer, n'importe quelle interface — le compilateur doit créer une valeur d'interface, qui est une paire (type, pointeur vers la donnée). Pour que ce pointeur soit valide au-delà de la frame courante, la donnée doit être allouée sur le tas — c'est le cas dès que l'interface elle-même peut s'échapper, comme quand on la passe à fmt.Println ; si la fonction appelée ne la laisse pas fuir, le compilateur peut garder la donnée sur la pile. Concrètement : passer un int à fmt.Println — qui accepte ...any — alloue cet entier sur le tas. Passer une petite struct à une méthode qui prend une interface alloue la struct sur le tas. Ce n'est pas une fuite : la valeur est correctement gérée et sera ramassée par le GC. Mais c'est une allocation par appel, et sous une boucle serrée ou une fonction hot-path appelée des millions de fois, ces allocations accumulent une pression sur le GC qui se traduit en pauses et en temps CPU gaspillé. La surprise est particulièrement traître parce que le code semble propre et idiomatique — passer à une interface est le style Go recommandé pour les abstractions. La leçon n'est pas d'éviter les interfaces, mais de savoir que les hot paths peuvent mériter des variantes concrètes, et que -gcflags="-m" est l'outil pour identifier où le boxing se produit vraiment.The most common surprise in escape analysis is interface boxing. When you pass a concrete value to an interface-typed parameter — any, io.Writer, fmt.Stringer, any interface — the compiler must create an interface value, which is a pair (type, pointer to data). For that pointer to be valid beyond the current frame, the data must be allocated on the heap — which happens as soon as the interface itself can escape, as when you pass it to fmt.Println; if the callee doesn't let it leak, the compiler can keep the data on the stack. Concretely: passing an int to fmt.Println — which accepts ...any — allocates that integer on the heap. Passing a small struct to a method taking an interface allocates the struct on the heap. This isn't a leak: the value is correctly managed and will be collected by the GC. But it's one allocation per call, and under a tight loop or a hot-path function called millions of times, these allocations accumulate pressure on the GC that translates to pauses and wasted CPU time. The surprise is particularly treacherous because the code looks clean and idiomatic — passing to an interface is the recommended Go style for abstractions. The lesson is not to avoid interfaces, but to know that hot paths may deserve concrete variants, and that -gcflags="-m" is the tool to identify where boxing actually happens.

Passer un int à any : une allocation silencieuse par appelPassing an int to any: a silent allocation per call
// On croit éviter les allocations en passant par valeur…
func logValue(v any) {
    fmt.Println(v)
}

func main() {
    n := 42
    logValue(n)   // → n escapes to heap : le boxing d'interface alloue
}

// -gcflags="-m" :
// ./main.go:9:10: n escapes to heap
// ./main.go:2:15: leaking param: v   (fmt.Println fait fuir l'interface → n part sur le tas)

n est un int de 8 octets sur la pile. Passé à any, il devient un objet sur le tas. Ce n'est pas un bug — c'est ce que le runtime doit faire pour que l'interface soit valide. Mais dans une boucle appelée un million de fois, c'est un million d'allocations de 8 octets chacune, qui créent autant de travail pour le GC. -gcflags="-m" le rend visible avant que le profiler ne le confirme.n is an 8-byte int on the stack. Passed to any, it becomes an object on the heap. This is not a bug — it's what the runtime must do for the interface to be valid. But in a loop called a million times, that's a million 8-byte allocations, creating as much work for the GC. -gcflags="-m" makes it visible before the profiler confirms it.

Les quatre causes d'escape les plus communesThe four most common escape causes
Retourner &xReturning &x
survit à la frame
Passer à une interfacePassing to an interface
boxing
Goroutine capture une varGoroutine captures a var
durée de vie inconnue
Taille inconnue à la compileSize unknown at compile time
slice/map dynamique
Passer à une interface est idiomatic Go. Dans les hot paths, -gcflags="-m" révèle si ce geste coûte une allocation par appel.Passing to an interface is idiomatic Go. In hot paths, -gcflags="-m" reveals whether this gesture costs one allocation per call.
№ 03La mécaniqueThe mechanics5 min

Une closure qui capture une variable par référence envoie cette variable sur le tas. -gcflags="-m -m" donne toute la chaîne causale.A closure capturing a variable by reference sends that variable to the heap. -gcflags="-m -m" gives the full causal chain.

L'escape analysis suit les flux de données. Une variable s'échappe dès que le compilateur ne peut pas garantir que son adresse disparaîtra avant la fin de la frame qui l'a créée. Les closures sont le cas le plus courant après les interfaces : quand une fonction retourne une closure qui accède à une variable locale, cette variable doit survivre à la fonction — elle s'échappe vers le tas. Le compilateur ne peut pas savoir combien de fois la closure sera appelée, ni quand elle le sera — il doit donc allouer la variable sur le tas dès la création de la closure. Ce comportement est correct et attendu pour les closures longue durée. Le problème surgit dans les boucles qui créent des closures à chaque itération pour les passer à des goroutines : chaque itération peut allouer les variables capturées sur le tas, et sous haute fréquence, la pression s'accumule. Pour investiguer, -gcflags="-m -m" (double m) donne non seulement la décision mais la chaîne causale complète — l'origine de la valeur, le flux par lequel elle s'échappe, et la ligne précise. C'est une lecture dense, mais c'est le seul outil qui dit pourquoi une valeur s'échappe, pas seulement qu'elle s'échappe.Escape analysis follows data flows. A variable escapes as soon as the compiler can't guarantee its address will disappear before the creating frame ends. Closures are the most common case after interfaces: when a function returns a closure that accesses a local variable, that variable must outlive the function — it escapes to the heap. The compiler can't know how many times or when the closure will be called — so it must allocate the variable on the heap when the closure is created. This behavior is correct and expected for long-lived closures. The problem arises in loops that create closures per iteration to pass to goroutines: each iteration may allocate captured variables on the heap, and at high frequency, pressure accumulates. To investigate, -gcflags="-m -m" (double m) gives not only the decision but the complete causal chain — the value's origin, the flow through which it escapes, and the exact line. It's dense reading, but it's the only tool that says why a value escapes, not just that it does.

Closure qui capture par référence : la variable capturée s'échappeClosure capturing by reference: the captured variable escapes
func makeAdder(x int) func(int) int {
    // x n'est jamais réaffecté : la closure en garde une COPIE
    return func(y int) int {
        return x + y   // x est accédé ici, après la fin de makeAdder
    }
}
// -gcflags="-m" :
// ./main.go:3:9: func literal escapes to heap   ← la closure, et sa copie de x

func counter() func() int {
    n := 0      // -gcflags="-m" : moved to heap: n
    return func() int {
        n++     // n est modifié : capturé par référence, partagé, il vit sur le tas
        return n
    }
}

x dans makeAdder est capturé par la closure retournée. Puisque la closure peut être appelée après que makeAdder soit terminé, x doit vivre plus longtemps que la frame. Comme il n'est jamais réaffecté, le compilateur le copie dans la closure — et c'est la closure qui s'échappe. n, dans counter, est modifié : capturé par référence, il part lui-même sur le tas (moved to heap: n). Ce n'est pas une erreur : c'est le comportement attendu d'une factory de functions. Le signal d'alerte arrive quand une boucle chaude crée des closures à chaque itération — chaque n ou x capturé devient une allocation, invisible dans le code mais visible dans le profiler heap.x in makeAdder is captured by the returned closure. Since the closure can be called after makeAdder finishes, x must live longer than the frame. Since it's never reassigned, the compiler copies it into the closure — and it's the closure that escapes. n, in counter, is modified: captured by reference, it goes to the heap itself (moved to heap: n). This is not an error: it's the expected behavior of a function factory. The warning signal comes when a hot loop creates closures per iteration — each captured n or x becomes an allocation, invisible in the code but visible in the heap profiler.

-gcflags="-m" dit quoi. -gcflags="-m -m" dit pourquoi — et c'est la question qui mène à la correction.-gcflags="-m" says what. -gcflags="-m -m" says why — and that's the question that leads to the fix.
№ 04Le piègeThe trap4 min

Optimiser l'escape analysis sans mesurer revient souvent à déplacer les allocations, pas à les supprimer. Le profiler d'abord, -gcflags=-m ensuite.Optimizing escape analysis without measuring often just moves allocations, not removes them. The profiler first, -gcflags=-m second.

L'escape analysis est un sujet qui fascine, et cette fascination pousse à des optimisations prématurées. On lit qu'une interface alloue, on remplace toutes les interfaces par des types concrets. On lit que les closures s'échappent, on les réécrit. Mais on rate le point essentiel : ce qui alloue le plus dans un programme n'est presque jamais là où on le pense. Dans un serveur HTTP typique, les allocations dominantes sont dans le parsing HTTP, la sérialisation JSON, les queries SQL, les buffers réseau — pas dans les quelques interfaces du code métier. Optimiser les mauvais endroits n'améliore pas les performances mesurées ; cela peut même les dégrader si l'optimisation rend le code plus complexe et que le compilateur ne peut plus l'inliner. La bonne séquence est immuable : mesurer d'abord avec pprof (go test -bench=. -memprofile=mem.out, puis go tool pprof mem.out), identifier les fonctions qui dominent les allocations, appliquer -gcflags="-m" ciblé sur ces fonctions, et seulement alors modifier. Un autre piège fréquent : la variable de boucle Go partagée entre toutes les closures d'une boucle for range. Avant Go 1.22, item dans une boucle était une seule variable réutilisée ; une goroutine qui la capturait par référence capturait la même variable pour toutes les itérations. La correction — passer la valeur en argument de la closure — élimine aussi l'escape de la variable de boucle.Escape analysis is a fascinating topic, and that fascination pushes toward premature optimizations. You read that an interface allocates, you replace all interfaces with concrete types. You read that closures escape, you rewrite them. But you miss the essential point: what allocates most in a program is almost never where you think. In a typical HTTP server, the dominant allocations are in HTTP parsing, JSON serialization, SQL queries, network buffers — not in a few interfaces in business logic. Optimizing the wrong places doesn't improve measured performance; it can even degrade it if the optimization makes code more complex and the compiler can no longer inline it. The correct sequence is immutable: measure first with pprof (go test -bench=. -memprofile=mem.out, then go tool pprof mem.out), identify the functions dominating allocations, apply targeted -gcflags="-m" to those functions, and only then modify. Another common trap: the loop variable shared across all closures in a for range loop. Before Go 1.22, item in a loop was a single reused variable; a goroutine capturing it by reference captured the same variable for all iterations. The fix — passing the value as an argument to the closure — also eliminates the loop variable's escape.

Éviter une allocation visible → en créer des invisiblesAvoiding a visible allocation → creating invisible ones
// "Optimisation" qui aggrave la situation
func processItems(items []Item) {
    // On évite l'interface pour "ne pas allouer"…
    for _, item := range items {
        // …mais on crée une goroutine par item, dont la closure capture item
        go func() {
            handle(item)   // la closure (et sa capture d'item) part sur le tas — allocation !
        }()
    }
}

// Résultat : on a évité le boxing d'interface mais créé N allocations de goroutine
// + N closures sur le tas. Net : pire qu'avant.

On a évité le boxing d'interface, mais on a créé une capture par référence dans une goroutine — qui envoie la variable sur le tas. Net : plus d'allocations qu'avant, pas moins. Sans pprof pour quantifier avant et après, l'optimisation est aveugle. Les micro-benchmarks go test -bench=. -benchmem mesurent le nombre d'allocations par opération — c'est le premier chiffre à regarder avant de toucher quoi que ce soit.You avoided interface boxing, but created a by-reference capture in a goroutine — which sends the variable to the heap. Net: more allocations than before, not fewer. Without pprof to quantify before and after, the optimization is blind. Micro-benchmarks go test -bench=. -benchmem measure allocations per operation — that's the first number to look at before touching anything.

L'escape analysis dit où les allocations se produisent. pprof dit lesquelles comptent — et c'est souvent ailleurs qu'on le pense.Escape analysis says where allocations happen. pprof says which ones matter — and that's often elsewhere than you think.
№ 05Bilan & éditoWrap-up & editorial2 min

Le compilateur décide où une valeur vit. -gcflags=-m rend cette décision lisible. pprof indique si elle compte.The compiler decides where a value lives. -gcflags=-m makes that decision readable. pprof tells you if it matters.

Ce numéro a ouvert le volume 9 par la question la plus fondamentale de la gestion mémoire en Go : où vivent les valeurs ? La réponse est décidée par le compilateur via l'escape analysis, une analyse statique du flux de données qui détermine si la durée de vie d'une valeur dépasse sa frame. La pile est gratuite — libérée automatiquement à la sortie de la fonction, zéro coût pour le GC. Le tas coûte — alloué dynamiquement, le GC doit le ramasser. Deux causes déclenchent l'escape plus souvent qu'on le croirait : retourner l'adresse d'une variable locale (inévitable et correct), et passer une valeur concrète à une interface (boxing, une allocation par appel). Les closures capturant des variables par référence envoient ces variables sur le tas dès qu'elles peuvent survivre à leur créateur. Le piège de fin de numéro : optimiser sans mesurer est aveugle. -gcflags="-m" montre où les allocations se produisent ; pprof montre lesquelles dominent le coût réel. Les deux ensemble définissent le bon ordre d'intervention. Le numéro suivant monte d'un cran : que se passe-t-il une fois que les valeurs sont sur le tas et que le GC doit les ramasser ?This issue opened volume 9 with the most fundamental question of memory management in Go: where do values live? The answer is decided by the compiler via escape analysis, a static data-flow analysis that determines whether a value's lifetime exceeds its frame. The stack is free — automatically released on function exit, zero cost to the GC. The heap costs — dynamically allocated, the GC must collect it. Two causes trigger escape more often than expected: returning a local variable's address (unavoidable and correct), and passing a concrete value to an interface (boxing, one allocation per call). Closures capturing variables by reference send those variables to the heap whenever they can outlive their creator. The end-of-issue trap: optimizing without measuring is blind. -gcflags="-m" shows where allocations happen; pprof shows which ones dominate the real cost. Both together define the right intervention order. The next issue moves up a level: what happens once values are on the heap and the GC must collect them?

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Pile vs tasStack vs heapLa pile est gratuite ; le tas crée du travail pour le GC.The stack is free; the heap creates work for the GC.Ignorer que chaque allocation sur le tas a un coût différé.Ignoring that every heap allocation has a deferred cost.
Boxing d'interfaceInterface boxingPasser à une interface alloue — dans les hot paths, préférer le type concret.Passing to an interface allocates — in hot paths, prefer the concrete type.Des allocations invisibles par appel dans les boucles chaudes.Invisible per-call allocations in hot loops.
-gcflags=-m-gcflags=-mLire les annotations d'escape avant d'optimiser — jamais à l'intuition.Read escape annotations before optimizing — never by intuition.Optimiser les mauvais endroits, rater les vrais hotspots.Optimizing the wrong places, missing the real hotspots.
Mesurer d'abordMeasure firstpprof heap avant toute modification — les allocations dominantes sont rarement où on l'imagine.pprof heap before any change — dominant allocations are rarely where you imagine.Des semaines d'optimisation sur 1% du problème.Weeks of optimization on 1% of the problem.
L'escape analysis est une fenêtre sur les décisions du compilateur. La lire ne remplace pas pprof — elle éclaire ce que pprof a trouvé.Escape analysis is a window into compiler decisions. Reading it doesn't replace pprof — it illuminates what pprof found.
Mot de l'éditeur · ouverture du volume 9From the editor · opening volume 9

Le volume 9 descend sous le langage. Ce n'est pas de la plomberie — c'est la carte qui rend les décisions de conception lisibles.Volume 9 goes below the language. This is not plumbing — it's the map that makes design decisions legible.

Huit volumes ont couvert le langage Go : les goroutines et leur coordination, les canaux et leur sémantique, les interfaces et leur piège nil, les erreurs et la panique, les slices et maps, les structs et les receveurs, defer et recover, et enfin context.Context comme câble d'annulation. Ce neuvième volume change de niveau : non plus les constructions du langage, mais la machine qui les exécute. L'escape analysis est la première pièce : comprendre où les valeurs vivent permet de comprendre pourquoi certaines fonctions semblent gratuites et d'autres pas. Le numéro suivant remonte depuis les allocations vers ce qui les ramasse : le garbage collector de Go, sa conception tricolore concurrente, et comment la pression d'allocation se traduit en cycles GC. L'outil sera sync.Pool — le mécanisme de réutilisation d'objets — et le profiler heap pour mesurer ce qu'on veut corriger. Et le troisième et dernier numéro portera sur le scheduler : comment des centaines de milliers de goroutines tiennent sur une poignée de threads OS, ce que GOMAXPROCS contrôle réellement, et la préemption asynchrone introduite en Go 1.14 qui a mis fin à l'ancien problème de la goroutine affamatrice. Trois numéros qui forment une carte du runtime — pas un manuel d'optimisation, mais une compréhension de la machine qu'on conduit.Eight volumes covered the Go language: goroutines and their coordination, channels and their semantics, interfaces and their nil trap, errors and panic, slices and maps, structs and receivers, defer and recover, and finally context.Context as a cancellation cable. This ninth volume changes level: not the language constructs, but the machine that runs them. Escape analysis is the first piece: understanding where values live lets you understand why some functions seem free and others not. The next issue climbs from allocations toward what collects them: Go's garbage collector, its concurrent tricolor design, and how allocation pressure translates into GC cycles. The tool will be sync.Pool — the object reuse mechanism — and the heap profiler to measure what you want to fix. And the third and final issue will cover the scheduler: how hundreds of thousands of goroutines ride on a handful of OS threads, what GOMAXPROCS actually controls, and the asynchronous preemption introduced in Go 1.14 that ended the old goroutine-starvation problem. Three issues forming a runtime map — not an optimization manual, but an understanding of the machine you're driving.