Le profilage est une technique couramment utilisée dans le cycle de développement des logiciels pour analyser les performances d’un programme, généralement à des fins de comparaison entre les programmes ou pour identifier les goulets d’étranglement et les domaines d’amélioration d’un programme. Le profilage consiste à mesurer et à analyser diverses mesures telles que l’utilisation de la mémoire, l’utilisation du processeur, le temps d’exécution et d’autres statistiques au niveau du système.
Le profilage vise à identifier les parties d’un programme qui consomment le plus de ressources afin de les optimiser pour obtenir de meilleures performances. Le profilage peut également aider au débogage, à l’optimisation de la gestion de la mémoire et au réglage de la concurrence.
Profiler en Go
Il existe de nombreux outils de profilage en Go. Parmi les outils les plus populaires, on trouve l’outil de profilage intégré à Go, pprof, et des paquets tiers populaires tels que Go Tool Trace et Go-Torch.
L’outil pprof fait partie du paquet temps d’exécution paquet. Le paquet pprof fournit des fonctionnalités permettant d’écrire des données de profilage en cours d’exécution dans des formats que l’application pprof L’outil de visualisation peut interpréter.
Voici comment vous pouvez importer le pprof dans vos programmes Go :
import "pprof"
Go fournit plusieurs commandes et drapeaux pour travailler avec le code source. Exécutez les commandes suivantes outil pour accéder aux résultats du profilage dans différents formats.
go tool pprof
La commande affiche les détails d’utilisation de l’élément pprof commande.
Profilage du processeur en Go
Le profilage du processeur mesure le temps passé par un programme à exécuter des fonctions. Le profilage du processeur est utile pour identifier les parties du code qui consomment le plus de temps processeur.
Le pprof fournit des fonctions permettant de collecter des profils de CPU, de démarrer et d’arrêter le profilage de CPU, ainsi qu’une fonction permettant d’écrire des données de profil dans des fichiers.
Voici comment démarrer et arrêter un profil de CPU et écrire les données dans un fichier de profilage :
import (
"os"
"runtime/pprof"
)
func main() {
f, err := os.Create("cpu_profile.prof")
if err != nil {
panic(err)
}
defer f.Close()
err = pprof.StartCPUProfile(f)
if err != nil {
panic(err)
}
defer pprof.StopCPUProfile()
// code to be profiled
}
Le principal crée un fichier et ferme le flux de fichiers avec une fonction différer et la déclaration de Fermer de l’instance de fichier. La fonction StartCPUProfile démarre un profil CPU et écrit les données dans le fichier, et la fonction StopCPUProfile ferme le flux de profil avec un report déclaration. Après avoir démarré et arrêté le profil de l’unité centrale, vous pouvez écrire le code que vous souhaitez analyser.
Voici le résultat de l’exécution de l’instruction pprof avec le fichier de profil du programme :
Exécution du fichier de profil de l’unité centrale pprof avec un fichier lance un shell interactif qui vous permet d’explorer les données de profilage. Vous pouvez utiliser des commandes comme top et liste pour afficher les fonctions dont l’exécution prend le plus de temps.
Le profilage de la mémoire en Go
Le profilage de la mémoire est une technique utilisée pour identifier les fuites de mémoire et l’utilisation coûteuse de la mémoire dans le code en mesurant l’utilisation de la mémoire des fonctions dans le code.
Vous pouvez lancer un profil de mémoire avec la commande WriteHeapProfile fonction. La fonction WriteHeapProfile prend une instance de fichier et écrit les données du profil dans le fichier.
import (
"os"
"runtime/pprof"
)
func main() {
f, err := os.Create("mem_profile.prof")
if err != nil {
panic(err)
}
defer f.Close()
err = pprof.WriteHeapProfile(f)
if err != nil {
panic(err)
}
// code to be profiled
}
La fonction principal crée un fichier de profilage, et la fonction WriteHeapProfile prend en argument l’instance de fichier et renvoie un type d’erreur d’écriture après avoir écrit dans le fichier. Vous pouvez gérer l’erreur en fonction de vos besoins.
Le profilage des blocs avec Go
Le profilage des blocs mesure le temps d’attente d’un programme pour les primitives de synchronisation, telles que les mutex et les canaux. Le profilage des blocs est utile pour identifier les parties du code qui peuvent être à l’origine de blocages.
Le profilage par blocs est utile pour identifier les parties du code qui peuvent causer des blocages. Recherche renvoie le profil dont le nom est une chaîne de caractères spécifiée, et la fonction WriteTo de la fonction Recherche écrit un instantané du profil au format pprof dans le fichier.
Voici comment vous pouvez implémenter le profilage par bloc pour vos programmes Go :
import (
"os"
"runtime/pprof"
)
func main() {
f, err := os.Create("block_profile.prof")
if err != nil {
panic(err)
}
defer f.Close()
err = pprof.Lookup("block").WriteTo(f, 0)
if err != nil {
panic(err)
}
// code to be profiled
}
Le programme crée un fichier pour stocker les données de profilage des blocs, recherche les blocs avec l’attribut Lookup et écrit les données du profil du bloc dans le fichier.
Profils de traces avec Go
Le profilage de traces est une technique permettant de mesurer l’exécution d’un programme, y compris l’ordonnancement des goroutines et les appels système. Cette technique est utile pour identifier les goulots d’étranglement et comprendre les interactions entre les différentes parties d’un programme.
Le trace fournit des fonctions pour le profilage des traces. Ce paquetage fait également partie du paquetage temps d’exécution paquet.
import (
"os"
"runtime/trace"
)
func main() {
f, err := os.Create("trace.out")
if err != nil {
panic(err)
}
defer f.Close()
err = trace.Start(f)
if err != nil {
panic(err)
}
defer trace.Stop()
// code to be profiled
}
Le programme crée un fichier de trace pour stocker les données de trace, démarre le traceur avec la commande Démarrer qui prend en compte l’instance de fichier et renvoie un type d’erreur, et reporte le traceur avec la fonction Arrêter fonction.
Go fournit des outils pour formater le code source
Go fournit également des outils de formatage du code source. En plus des outils de profilage, vous pouvez utiliser les outils de formatage pour maintenir les normes du code. Les outils de formatage gofmt est un outil de formatage intégré que vous pouvez utiliser pour formater votre code source Go en fonction des règles spécifiées pour vos paquets.