Le GC et la pression d'allocation The GC and allocation pressure

Le ramasse-miettes de Go est concurrent et discret — la bonne réponse est rarement de le tuner, presque toujours d'allouer moins. sync.Pool, mesures avant optimisation, pprof. On regarde le coût au lieu de l'imaginer. Go's garbage collector is concurrent and quiet — the right answer is rarely to tune it, almost always to allocate less. sync.Pool, measure before optimizing, pprof. We look at the cost instead of guessing it.

Audience
Dev dont le service a une latence p99 instable ou dont pprof montre beaucoup d'allocations inattendues Dev whose service has unstable p99 latency or whose pprof shows many unexpected allocations
ChapitresChapters
5
LectureReading
≈ 17 min
NiveauLevel
●●●●
Date
Juil 2028 Jul 2028

GCAllocationpprof

SommaireContents ·
№ 01CadrageFraming3 min

Le GC de Go est concurrent et discret. La bonne réponse n'est presque jamais de le tuner — c'est d'allouer moins.Go's GC is concurrent and quiet. The right answer is almost never to tune it — it's to allocate less.

Le numéro précédent a montré où les valeurs s'allouent. Ce numéro montre ce qui se passe ensuite : le garbage collector ramasse les valeurs sur le tas qui ne sont plus atteignables. Le GC de Go est un collecteur tricolor mark-and-sweep concurrent : il tourne en parallèle avec le programme, en marquant les objets atteignables (blanc → gris → noir) puis en libérant les blancs. Les pauses stop-the-world (STW) sont courtes — quelques dizaines de microsecondes en Go moderne — précisément parce que la majorité du travail se fait de manière concurrente. Le paramètre GOGC contrôle quand un cycle GC se déclenche : GOGC=100 (la valeur par défaut) signifie que le GC se déclenche quand le tas a doublé depuis le dernier cycle. Augmenter GOGC réduit la fréquence des cycles au prix d'une utilisation mémoire plus haute. Baisser GOGC augmente la fréquence des cycles et réduit l'empreinte mémoire. Mais tuner GOGC sans réduire les allocations est un jeu à somme nulle : on déplace la pression, on ne la supprime pas. La vraie leçon est contre-intuitive : le GC de Go est si efficace que la quasi-totalité des problèmes de performance liés au GC se résout en allouant moins, pas en modifiant le GC. Et allouer moins commence par mesurer où les allocations se produisent.The previous issue showed where values get allocated. This issue shows what happens next: the garbage collector collects heap values that are no longer reachable. Go's GC is a concurrent tricolor mark-and-sweep collector: it runs in parallel with the program, marking reachable objects (white → gray → black) then freeing the whites. Stop-the-world (STW) pauses are short — a few tens of microseconds in modern Go — precisely because most work happens concurrently. The GOGC parameter controls when a GC cycle triggers: GOGC=100 (the default) means the GC triggers when the heap has doubled since the last cycle. Increasing GOGC reduces cycle frequency at the cost of higher memory usage. Decreasing GOGC increases cycle frequency and reduces memory footprint. But tuning GOGC without reducing allocations is a zero-sum game: you shift the pressure, you don't eliminate it. The real lesson is counterintuitive: Go's GC is so efficient that virtually all GC-related performance problems are solved by allocating less, not by modifying the GC. And allocating less starts with measuring where allocations happen.

Lire la trace GC avec GODEBUG=gctrace=1Reading the GC trace with GODEBUG=gctrace=1
// Voir l'activité du GC en temps réel
GODEBUG=gctrace=1 go run ./server.go

// Exemple de sortie :
// gc 1 @0.012s 1%: 0.014+1.2+0.027 ms clock, 0.11+0.44/1.1/0 ms cpu, 4->4->2 MB, 5 MB goal, 8 P
//       ^      ^   ^                           ^                         ^          ^
//   numéro  depuis  STW mark setup + concurrent mark + STW finish      heap avant/après/live
//   du GC   le démarrage                                               goal = seuil prochain GC

// GOGC=100 (défaut) : GC quand le tas double depuis le dernier GC
// GOGC=200 : GC moins fréquent, plus de mémoire utilisée
// GOGC=off : GC désactivé (test/benchmark uniquement)
Le cycle GC en trois phasesThe GC cycle in three phases
STW setup
< 1ms · rare
→
Mark concurrent
parallèle au programme
→
STW finish
< 1ms · rare

Le GC moderne de Go est concurrent à 99%. Les pauses STW sont de l'ordre de la microseconde, pas de la milliseconde. La latence vient des allocations, pas du collecteur lui-même.Modern Go's GC is 99% concurrent. STW pauses are in the microsecond range, not millisecond. Latency comes from allocations, not from the collector itself.

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

« Mon programme est lent à cause du GC — je dois tuner GOGC. » Presque toujours faux. Le bon diagnostic est : combien d'allocations par requête ? quelle est leur taille ? d'où viennent-elles ? go tool pprof -alloc_objects et -alloc_space répondent à ces questions. Une fois la source identifiée, on réduit les allocations — sync.Pool, pré-allocation, réutilisation de buffers — et le GC suit naturellement."My program is slow because of the GC — I need to tune GOGC." Almost always wrong. The right diagnosis is: how many allocations per request? what size? where do they come from? go tool pprof -alloc_objects and -alloc_space answer those questions. Once the source is identified, reduce the allocations — sync.Pool, pre-allocation, buffer reuse — and the GC follows naturally.

GOGC vs GOMEMLIMITGOGC vs GOMEMLIMIT

Go 1.19 a introduit GOMEMLIMIT, une limite souple sur la mémoire totale gérée par le runtime. Contrairement à GOGC qui contrôle la fréquence, GOMEMLIMIT dit « essaie de rester sous X octets » — une cible, pas une garantie : si le tas vivant la dépasse, le programme la dépasse aussi. C'est utile dans des environnements containerisés où la mémoire est limitée : à l'approche de la limite, le GC devient plus agressif pour rester en dessous, ce qui repousse l'OOM. La combinaison recommandée : GOGC=off + GOMEMLIMIT=<mémoire disponible> dans un container. Le GC ne se déclenche que quand la limite approche, réduisant la fréquence — mais si le tas vivant approche la limite, le GC tourne en continu : garder une marge (GOMEMLIMIT ≈ 90 % de la mémoire du container).Go 1.19 introduced GOMEMLIMIT, a soft limit on the total memory managed by the runtime. Unlike GOGC which controls frequency, GOMEMLIMIT says 'try to stay under X bytes' — a target, not a guarantee: if the live heap exceeds it, so does the program. It's useful in containerized environments where memory is limited: as the limit approaches, the GC becomes more aggressive to stay under it, which pushes the OOM back. The recommended combination: GOGC=off + GOMEMLIMIT=<available memory> in a container. The GC only triggers when the limit approaches, reducing frequency — but if the live heap nears the limit, the GC runs nonstop: keep headroom (GOMEMLIMIT ≈ 90% of the container's memory).

№ 02La surpriseThe surprise4 min

La pression d'allocation vient rarement du code métier. pprof -alloc_objects montre que c'est souvent la sérialisation et les buffers.Allocation pressure rarely comes from business code. pprof -alloc_objects shows it's usually serialization and buffers.

La surprise du numéro est statistique. Quand on profile un serveur Go sous charge et qu'on regarde les allocations, la source dominante est presque toujours la même : la sérialisation (json.Marshal, protobuf), les buffers réseau, et les structures de données temporaires créées par les bibliothèques standard — pas le code métier qu'on a écrit. C'est la contre-intuition fondamentale de l'optimisation mémoire en Go : on passe du temps à réfléchir aux allocations dans son propre code, mais le profiler pointe vers des fonctions qu'on n'a pas écrites. La conséquence pratique est importante : la cible d'optimisation n'est pas toujours le code qu'on peut modifier directement. Parfois, la solution est de réduire le nombre d'appels à la fonction allouante — sérialiser une fois au lieu de trois, batcher les requêtes — ou de choisir une librairie qui alloue moins (encoders zero-copy, parsers streaming). La pression d'allocation se traduit en cycles GC fréquents, qui se traduisent en pauses courtes mais nombreuses, qui se traduisent en latence de percentile élevé (p99, p999) même quand la médiane est basse. C'est la signature caractéristique d'un programme avec une pression GC élevée : une médiane acceptable mais une queue de distribution longue, avec des spikes réguliers de latence.The issue's surprise is statistical. When you profile a Go server under load and look at allocations, the dominant source is almost always the same: serialization (json.Marshal, protobuf), network buffers, and temporary data structures created by standard libraries — not the business code you wrote. It's the fundamental counter-intuition of memory optimization in Go: you spend time thinking about allocations in your own code, but the profiler points to functions you didn't write. The practical consequence is important: the optimization target isn't always code you can modify directly. Sometimes the solution is to reduce the number of calls to the allocating function — serialize once instead of three times, batch requests — or choose a library that allocates less (zero-copy encoders, streaming parsers). Allocation pressure translates to frequent GC cycles, which translate to short but numerous pauses, which translate to high-percentile latency (p99, p999) even when the median is low. That's the characteristic signature of a program with high GC pressure: an acceptable median but a long tail distribution, with regular latency spikes.

3 allocations par requête × 10 000 req/s = GC toutes les 100ms3 allocations per request × 10,000 req/s = GC every 100ms
// Pattern qui crée une pression d'allocation élevée
func handleRequest(r *Request) *Response {
    // Chaque requête alloue une nouvelle struct, un nouveau buffer, un nouveau slice
    buf := make([]byte, 4096)        // allocation #1
    resp := &Response{}              // allocation #2
    items := make([]Item, 0, 10)     // allocation #3

    n, _ := r.Body.Read(buf)
    items = parseItems(buf[:n])
    resp.Items = items
    return resp
    // buf → abandonné → ramassé au prochain GC (items survit via resp)
}
// À 10 000 req/s → 30 000 allocations/s, GC toutes les ~100ms

Chaque requête alloue puis abandonne. Ce pattern est courant et souvent inévitable — le problème n'est pas l'allocation elle-même mais son volume. Sous 10 000 req/s, le GC peut déclencher plusieurs fois par seconde. Chaque cycle est court, mais leur fréquence crée une pression CPU constante et des spikes de latence p99. La solution n'est pas de supprimer les allocations mais de les réduire ou de les réutiliser — via sync.Pool pour les objets temporaires récurrents.Every request allocates then abandons. This pattern is common and often unavoidable — the problem is not the allocation itself but its volume. Under 10,000 req/s, the GC may trigger several times per second. Each cycle is short, but their frequency creates constant CPU pressure and p99 latency spikes. The solution isn't to eliminate allocations but to reduce or reuse them — via sync.Pool for recurring temporary objects.

La pression GC a une signature : médiane basse, queue longue. pprof montre d'où elle vient — souvent pas d'où on croit.GC pressure has a signature: low median, long tail. pprof shows where it comes from — often not where you think.
№ 03La mécaniqueThe mechanics5 min

sync.Pool réutilise les objets temporaires entre goroutines. Son Get/Put évite l'allocation — à condition de ne pas y stocker d'état persistant.sync.Pool reuses temporary objects across goroutines. Its Get/Put avoids allocation — provided you don't store persistent state in it.

sync.Pool est l'outil Go pour réduire la pression d'allocation sur des objets temporaires récurrents : buffers, encoders, structs de scratchpad. L'idée est simple : au lieu d'allouer un nouvel objet à chaque appel et de le laisser mourir, on le remet dans un pool commun à la fin de l'usage, et la prochaine goroutine qui en a besoin le récupère au lieu d'en allouer un nouveau. Le GC n'a pas à ramasser ce qui est réutilisé. sync.Pool a deux contraintes importantes. La première : il se vide au fil des cycles GC (depuis Go 1.13, un objet survit à un cycle dans un cache « victime », pas à deux). Un objet mis en pool n'est pas garanti d'y rester — si un GC se produit entre le Put et le Get, le pool sera vide et New() sera rappelé. Ce n'est pas un bug : c'est voulu, pour que le pool ne retienne pas de mémoire indéfiniment sous faible charge. La conséquence est qu'on ne peut pas se servir de sync.Pool comme cache avec garantie de persistance. La seconde contrainte est plus subtile : les objets mis en pool ne doivent pas garder de références vers d'autres objets. Un buffer est parfait pour le pool — une slice d'octets sans pointeurs. Une struct avec un champ db *sql.DB est dangereuse : si la connexion tient des ressources, les remettre dans le pool sans les libérer crée des fuites. La règle : sync.Pool pour les objets de travail purs (buffers, builders, scratchpads), jamais pour les objets avec état externe.sync.Pool is Go's tool to reduce allocation pressure on recurring temporary objects: buffers, encoders, scratchpad structs. The idea is simple: instead of allocating a new object on every call and letting it die, you return it to a shared pool at the end of use, and the next goroutine that needs one retrieves it instead of allocating a new one. The GC doesn't have to collect what's being reused. sync.Pool has two important constraints. First: it drains over GC cycles (since Go 1.13, an object survives one cycle in a 'victim' cache, not two). An object put in the pool is not guaranteed to stay — if a GC happens between the Put and the Get, the pool will be empty and New() will be called again. This is not a bug: it's intentional, so the pool doesn't hold memory indefinitely under light load. The consequence is that you can't use sync.Pool as a cache with persistence guarantees. The second constraint is subtler: objects put in the pool must not hold references to other objects. A buffer is perfect for the pool — a byte slice with no pointers. A struct with a db *sql.DB field is dangerous: if the connection holds resources, returning them to the pool without releasing them creates leaks. The rule: sync.Pool for pure work objects (buffers, builders, scratchpads), never for objects with external state.

sync.Pool de buffers : une allocation partagée entre toutes les requêtessync.Pool of buffers: one allocation shared across all requests
var bufPool = sync.Pool{
    New: func() any {
        b := make([]byte, 4096)     // créé si le pool est vide
        return &b                   // un pointeur : Put d'une slice nue allouerait (SA6002)
    },
}

func handleRequest(r *Request) *Response {
    bp := bufPool.Get().(*[]byte)    // emprunter du pool
    defer bufPool.Put(bp)            // remettre dans le pool, pleine longueur

    buf := *bp
    n, _ := r.Body.Read(buf)
    return processBody(buf[:n])      // processBody ne doit pas garder buf
    // buf n'est pas alloué à chaque requête : il est réutilisé entre les requêtes
}

Le pool maintient un ensemble de buffers réutilisables entre les goroutines. Au lieu de 10 000 allocations par seconde, on a quelques dizaines de buffers qui circulent — alloués une fois, réutilisés indéfiniment jusqu'au prochain cycle GC. Le pool stocke un *[]byte plutôt qu'une slice nue — mettre une slice dans un any alloue à chaque Put, ce que staticcheck signale (SA6002) — et le defer bufPool.Put(bp) rend le buffer entier, prêt pour la prochaine requête. (Le remettre avec buf[:0] serait un piège : le prochain Read dans une slice de longueur zéro ne lirait rien.) L'économie est maximale sur les hot paths à haute fréquence.The pool maintains a set of reusable buffers across goroutines. Instead of 10,000 allocations per second, you have a few dozen buffers circulating — allocated once, reused indefinitely until the next GC cycle. The pool stores a *[]byte rather than a bare slice — putting a slice in an any allocates on every Put, which staticcheck flags (SA6002) — and defer bufPool.Put(bp) hands back the whole buffer, ready for the next request. (Returning buf[:0] would be a trap: the next Read into a zero-length slice would read nothing.) The savings are maximal on high-frequency hot paths.

sync.Pool est fait pour les objets de travail purs — buffers, builders. Il vide ses objets à chaque GC : jamais y stocker d'état persistant.sync.Pool is for pure work objects — buffers, builders. It empties its objects on every GC: never store persistent state in it.
№ 04Le piègeThe trap4 min

Ne pas pré-allouer une slice de capacité connue crée une cascade de réallocations. Une seule make avec la bonne capacité suffit.Not pre-allocating a slice of known capacity creates a cascade of reallocations. A single make with the right capacity suffices.

Le piège de fin de numéro est simple mais omniprésent : la slice créée avec var s []T ou make([]T, 0) sans capacité. Quand on y appende des éléments, Go double la capacité à chaque débordement jusqu'à 256 éléments — 1, 2, 4, 8, 16... — puis la fait croître plus doucement. Pour une slice de 1000 éléments, cela représente une douzaine d'allocations et autant de copies complètes du slice. Chaque réallocation crée un nouvel objet sur le tas et abandonne l'ancien — ce sont des objets supplémentaires pour le GC. La correction est triviale dès qu'on connaît la borne supérieure de la capacité : make([]T, 0, n) alloue la capacité exacte d'entrée, et les appends suivants ne réallouent plus tant que la longueur ne dépasse pas n. Si la borne n'est pas exacte, une estimation raisonnable par excès vaut mieux que zéro : une capacité initiale de 2×len(input) coûte plus de mémoire mais évite toutes les réallocations intermédiaires. Le même principe vaut pour les maps : make(map[K]V, n) pré-alloue les buckets pour n entrées et évite les rehash coûteux. C'est une des optimisations les plus rentables en Go parce que son coût est nul en lisibilité et en complexité — c'est juste un argument supplémentaire à make.The end-of-issue trap is simple but pervasive: the slice created with var s []T or make([]T, 0) without capacity. When you append elements to it, Go doubles capacity on every overflow up to 256 elements — 1, 2, 4, 8, 16... — then grows it more gently. For a slice of 1000 elements, that's about a dozen allocations and as many full copies of the slice. Each reallocation creates a new object on the heap and abandons the old one — extra objects for the GC. The fix is trivial when you know the capacity upper bound: make([]T, 0, n) allocates the exact capacity upfront, and subsequent appends no longer reallocate as long as length doesn't exceed n. If the bound isn't exact, a reasonable overestimate beats zero: an initial capacity of 2×len(input) costs more memory but avoids all intermediate reallocations. The same principle holds for maps: make(map[K]V, n) pre-allocates buckets for n entries and avoids costly rehashes. It's one of the most profitable optimizations in Go because its cost in readability and complexity is zero — it's just one extra argument to make.

Sans capacité : une douzaine d'allocations pour 1000 élémentsWithout capacity: about a dozen allocations for 1000 elements
// Pattern courant qui crée des reallocations inutiles
func collectResults(ids []int) []Result {
    var results []Result   // capacity 0 — chaque append peut réallouer

    for _, id := range ids {
        r, err := fetch(id)
        if err != nil { continue }
        results = append(results, r)   // réallocations exponentielles : 1, 2, 4, 8, ...
    }
    return results
}
// Si len(ids) == 1000 → une douzaine d'allocations, ~3 200 éléments alloués, ~1 900 copiés

La slice part de 0, double à chaque débordement puis croît plus doucement au-delà de 256. Pour 1000 éléments : capacités 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 853, 1365 (mesuré en Go 1.26 pour une struct de 24 octets) — 12 allocations, 11 tableaux abandonnés. Chaque objet abandonné est un travail pour le GC. À haute fréquence d'appel, cette cascade devient une source significative de pression d'allocation — visible dans pprof comme allocations dans les fonctions d'append interne de runtime.The slice starts at 0, doubles on every overflow, then grows more gently past 256. For 1000 elements: capacities 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 853, 1365 (measured on Go 1.26 for a 24-byte struct) — 12 allocations, 11 discarded arrays. Each abandoned object is work for the GC. At high call frequency, this cascade becomes a significant source of allocation pressure — visible in pprof as allocations inside runtime's internal append functions.

La liste de contrôle pre-allocThe pre-alloc checklist

Avant chaque création de slice ou map dans un hot path : 1. La capacité finale est-elle connue ou estimable ? Si oui, passer la capacité à make. 2. C'est une map ? make(map[K]V, n) évite les rehash. 3. Ce code est-il appelé des milliers de fois par seconde ? Si oui, benchmarker avec -benchmem avant et après.Before every slice or map creation in a hot path: 1. Is the final capacity known or estimable? If yes, pass capacity to make. 2. Is it a map? make(map[K]V, n) avoids rehashes. 3. Is this code called thousands of times per second? If yes, benchmark with -benchmem before and after.

strings.Builder et bytes.Bufferstrings.Builder and bytes.Buffer

Pour la concaténation de strings, strings.Builder maintient un buffer interne qui grandit par doublement — même problème de réallocation si on ne pré-alloue pas. strings.Builder.Grow(n) réserve n octets d'avance et évite toutes les réallocations si la taille finale est connue. bytes.Buffer a la même méthode Grow. C'est l'équivalent du make avec capacité pour les builders de strings : un Grow en début de boucle remplace dix réallocations.For string concatenation, strings.Builder maintains an internal buffer that grows by doubling — same reallocation problem if you don't pre-allocate. strings.Builder.Grow(n) reserves n bytes in advance and avoids all reallocations if the final size is known. bytes.Buffer has the same Grow method. It's the equivalent of make with capacity for string builders: one Grow at the start of a loop replaces ten reallocations.

La pré-allocation coûte un argument à make. Elle économise N réallocations, N copies, et N objets abandonnés pour le GC.Pre-allocation costs one argument to make. It saves N reallocations, N copies, and N abandoned objects for the GC.
№ 05Bilan & éditoWrap-up & editorial2 min

Le GC de Go est efficace. La bonne réponse est presque toujours d'allouer moins — sync.Pool, pré-allocation, et pprof pour savoir où commencer.Go's GC is efficient. The right answer is almost always to allocate less — sync.Pool, pre-allocation, and pprof to know where to start.

Ce numéro a couvert le garbage collector Go et la pression d'allocation. Le GC est concurrent et tricolor : ses pauses stop-the-world sont de l'ordre de la microseconde en Go moderne. GOGC contrôle la fréquence des cycles (défaut : déclencher quand le tas a doublé) ; GOMEMLIMIT, introduit en Go 1.19, pose un plafond absolu de mémoire. La surprise centrale est statistique : la pression d'allocation dominante vient rarement du code métier — pprof pointe presque toujours vers la sérialisation, les buffers réseau, les librairies standard. La bonne réponse à la pression GC n'est pas de tuner GOGC, mais de réduire les allocations. Trois leviers concrets : sync.Pool pour réutiliser les objets temporaires récurrents (buffers, builders) sans les allouer à chaque appel — à condition de n'y stocker que des objets sans état externe et de ne pas supposer leur persistance entre deux GC. La pré-allocation des slices et maps quand la capacité est connue — make([]T, 0, n) — qui élimine les cascades de réallocation par doublement. Et le profiler heap (go tool pprof -alloc_objects) pour mesurer avant de modifier, parce que l'intuition se trompe souvent de cible. Le dernier numéro de la newsletter descend au niveau du scheduler : comment Go fait tourner des centaines de milliers de goroutines sur quelques threads OS, et pourquoi ce n'est plus un problème depuis Go 1.14.This issue covered the Go garbage collector and allocation pressure. The GC is concurrent and tricolor: its stop-the-world pauses are in the microsecond range in modern Go. GOGC controls cycle frequency (default: trigger when the heap has doubled); GOMEMLIMIT, introduced in Go 1.19, sets an absolute memory ceiling. The central surprise is statistical: dominant allocation pressure rarely comes from business code — pprof almost always points to serialization, network buffers, standard libraries. The right answer to GC pressure is not to tune GOGC, but to allocate less. Three concrete levers: sync.Pool to reuse recurring temporary objects (buffers, builders) without allocating them on every call — provided you only store stateless objects there and don't assume their persistence between GCs. Pre-allocating slices and maps when capacity is known — make([]T, 0, n) — which eliminates doubling reallocation cascades. And the heap profiler (go tool pprof -alloc_objects) to measure before modifying, because intuition often targets the wrong place. The newsletter's last issue goes down to the scheduler level: how Go runs hundreds of thousands of goroutines on a few OS threads, and why that's no longer a problem since Go 1.14.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
GC concurrentConcurrent GCTuner GOGC est le dernier recours — réduire les allocations est presque toujours plus efficace.Tuning GOGC is the last resort — reducing allocations is almost always more effective.Des semaines sur GOGC sans impact sur la latence p99.Weeks on GOGC without impact on p99 latency.
sync.Poolsync.PoolPour les objets de travail purs — buffers, builders. Jamais d'état externe, jamais de persistance supposée.For pure work objects — buffers, builders. No external state, no assumed persistence.Fuites de ressources via des objets avec état mis en pool.Resource leaks via pooled objects with state.
Pré-allocationPre-allocationmake([]T, 0, n) et make(map[K]V, n) quand la capacité est estimable.make([]T, 0, n) and make(map[K]V, n) when capacity is estimable.N réallocations, N copies, N objets abandonnés par appel.N reallocations, N copies, N abandoned objects per call.
pprof d'abordpprof firstgo test -memprofile + go tool pprof -alloc_objects avant toute modification.go test -memprofile + go tool pprof -alloc_objects before any change.Optimiser le code métier quand c'est json.Marshal qui domine.Optimizing business code when json.Marshal dominates.
Le GC de Go est efficace par conception. Ne pas l'aider à ramasser moins — l'aider à avoir moins à ramasser.Go's GC is efficient by design. Don't help it collect less — help it have less to collect.
Mot de l'éditeur · avant-dernier numéro de la newsletterFrom the editor · penultimate issue of the newsletter

Deux numéros sur la mémoire. Il reste un sujet pour clore le volume — et la newsletter : comment le scheduler fait danser des millions de goroutines.Two issues on memory. One subject remains to close the volume — and the newsletter: how the scheduler makes millions of goroutines dance.

Le volume 9 a commencé par où les valeurs vivent — pile ou tas, décidé par l'escape analysis. Ce numéro a montré ce que le GC fait des valeurs sur le tas, et comment réduire son travail. Le dernier numéro de la newsletter porte sur la troisième pièce du runtime : le scheduler. Comment des centaines de milliers de goroutines — chacune avec sa pile, son contexte, son état — peuvent-elles coexister sur une poignée de threads OS ? La réponse est le scheduler M:N de Go : M goroutines sur N threads OS, avec un multiplicateur de P processeurs logiques contrôlé par GOMAXPROCS. Ce numéro couvrira la structure G/M/P, le work stealing entre processeurs, et la préemption asynchrone introduite en Go 1.14 qui a mis fin à la vieille histoire de la goroutine en boucle serrée qui affamait le scheduler. C'est le dernier numéro — celui qui ferme le runtime et la newsletter. Vol. 9 №03 — Le scheduler.Volume 9 started with where values live — stack or heap, decided by escape analysis. This issue showed what the GC does with heap values, and how to reduce its work. The newsletter's last issue covers the third piece of the runtime: the scheduler. How can hundreds of thousands of goroutines — each with its stack, its context, its state — coexist on a handful of OS threads? The answer is Go's M:N scheduler: M goroutines on N OS threads, with a multiplier of P logical processors controlled by GOMAXPROCS. This issue will cover the G/M/P structure, work stealing between processors, and the asynchronous preemption introduced in Go 1.14 that ended the old story of the tight-loop goroutine that starved the scheduler. It's the last issue — the one that closes the runtime and the newsletter. Vol. 9 №03 — The scheduler.