Profilage du code Go : trouver les goulots d'étranglement en pratique

Introduction : pourquoi le profilage Go est indispensable pour un développeur

Go est réputé pour ses performances, mais même le code le plus rapide peut ralentir à cause d'algorithmes inefficaces, de fuites mémoire ou d'une mauvaise gestion des goroutines. Le profilage est le seul moyen de savoir exactement où votre application consomme des ressources. Dans cet article, nous allons explorer les méthodes pratiques de profilage du code Go à l'aide des outils intégrés : pprof, trace et benchstat. Vous apprendrez à trouver les goulots d'étranglement et à les éliminer.

1. Profilage CPU avec pprof : trouver les points chauds

Le profilage CPU montre quelles fonctions consomment le plus de temps processeur. Le package intégré runtime/pprof permet de collecter facilement des profils.

1.1. Ajouter le profilage dans le code

Prenons l'exemple d'un simple serveur HTTP qui effectue des calculs lourds :

package main\n\nimport (\n    "fmt"\n    "log"\n    "net/http"\n    _ "net/http/pprof"\n    "os"\n    "runtime/pprof"\n)\n\nfunc heavyTask() {\n    sum := 0\n    for i := 0; i < 1_000_000; i++ {\n        sum += i * i\n    }\n    _ = sum\n}\n\nfunc handler(w http.ResponseWriter, r *http.Request) {\n    heavyTask()\n    fmt.Fprintf(w, "Done")\n}\n\nfunc main() {\n    f, _ := os.Create("cpu.prof")\n    pprof.StartCPUProfile(f)\n    defer pprof.StopCPUProfile()\n\n    http.HandleFunc("/", handler)\n    log.Fatal(http.ListenAndServe(":8080", nil))\n}\n

Après avoir lancé le serveur et effectué quelques requêtes, vous obtiendrez un fichier cpu.prof. Analysez-le avec la commande :

go tool pprof -http=:8081 cpu.prof

Un graphe interactif s'ouvrira dans le navigateur. Faites attention aux nœuds rouges — ils indiquent les fonctions les plus "chaudes". Dans notre cas, il s'agit de heavyTask.

1.2. Interprétation des résultats

Dans l'interface web de pprof, vous verrez :

\n
• Graph — un graphe d'appels avec des nœuds dont la taille est proportionnelle au temps d'exécution.
\n
• Flame Graph — un graphique "flamme", où les longues barres représentent les sections les plus lentes.
\n
• Top — un tableau des fonctions triées par temps CPU.
\n

Si vous constatez que heavyTask occupe 90 % du temps, cela signifie qu'il faut l'optimiser (par exemple, remplacer la boucle par une formule de somme des carrés).

2. Profilage mémoire : trouver les fuites et les allocations

Les fuites mémoire en Go sont rares, mais les allocations excessives peuvent fortement ralentir l'application. Utilisons runtime/pprof pour le profil heap.

2.1. Collecte du profil heap

Ajoutons dans le code la collecte du profil mémoire sur le signal SIGUSR1 :

import (\n    "os"\n    "os/signal"\n    "runtime/pprof"\n    "syscall"\n)\n\nfunc main() {\n    // ... votre code ...\n    sigs := make(chan os.Signal, 1)\n    signal.Notify(sigs, syscall.SIGUSR1)\n    go func() {\n        <-sigs\n        f, _ := os.Create("mem.prof")\n        pprof.WriteHeapProfile(f)\n        f.Close()\n        os.Exit(0)\n    }()\n    // ...\n}\n

Après avoir envoyé le signal kill -SIGUSR1 <PID>, vous obtiendrez le fichier mem.prof. Analysez-le :

go tool pprof -http=:8082 mem.prof

2.2. Problèmes mémoire typiques

\n
• Grand nombre de petites allocations — par exemple, la création de chaînes avec + au lieu de strings.Builder.
\n
• Maintien de références vers de grands objets — il faut mettre les pointeurs à zéro après utilisation.
\n
• Goroutines qui ne se terminent pas — chaque goroutine consomme au moins 4 Ko de pile.
\n

Exemple de code non optimal :

func badConcat(n int) string {\n    s := ""\n    for i := 0; i < n; i++ {\n        s += "x"  // chaque itération crée une nouvelle chaîne\n    }\n    return s\n}\n

Optimiz