Gérer Goroutine, GC, déboguer et collecter des métriques avec le package d’exécution | de Stefanie Lai | novembre 2022

Quand et comment utiliser le package d’exécution Go

Le feu vert Durée package et son sous-package déboguer sont très pratiques pour gérer les métriques, le débogage, la goroutine et le GC, ce qui peut également faciliter notre compréhension de l’implémentation de Go lui-même.

Cet article vise à répondre aux cinq « Comment faire » suivants avec quelques cas d’utilisation et des exemples de codes.

• Comment utiliser les variables d’environnement exposées par les packages d’exécution et d’exécution/de débogage
• Comment utiliser les métriques Go exposées par les packages d’exécution et d’exécution/de débogage
• Comment gérer les goroutines avec les packages d’exécution et d’exécution/de débogage
• Comment faire fonctionner GC avec des packages d’exécution et d’exécution/de débogage
• Comment déboguer avec les packages d’exécution et d’exécution/de débogage

Le package d’exécution fournit de nombreuses variables d’environnement intégrées que nous pouvons appeler lors du développement.

Les variables d’environnement les plus courantes sont GOARCH,GOOS,GOPATH,GOROOT, qui sont pour différentes implémentations basées sur différents systèmes d’exploitation sous-jacents, respectivement. La sortie suivante est la même que celle que nous obtenons en exécutant go env en CLI.

fmt.Printf(“OS: %s, GOARCH: %s”, runtime.GOOS, runtime.GOARCH)

De plus, il existe des variables d’environnement liées au GC, au débogage et à la trace.

• GOGCdéfinit le pourcentage cible initial de récupération de place et détermine s’il convient de déclencher GC en fonction de la proportion d’objets de récupération restants. La debug.SetGCPercentla fonction modifie ce pourcentage lors de l’exécution et désactive complètement la récupération de place lorsqueGOGC=100. GOGC=off par défaut.
• GODEBUG contrôle les variables de débogage dans le runtime, consistant en un ensemble de name=valdes chaînes séparées par des virgules et des configurations de prise en charge telles que allocfreetrace=1, clobberfree=1etc. Veuillez vous référer à ce liste pour plus d’informations.
• GORACE est utilisé pour configurer le détecteur de course en ajoutant -race signaler quand build.
• GOMAXPROCS limite le nombre de threads du système d’exploitation qui exécutent simultanément du code Go au niveau de l’utilisateur, mais pas le nombre de threads bloqués dans un appel système.
• GOTRACEBACK contrôle la quantité de sortie lorsqu’un programme Go échoue en raison d’une exception non gérée ou d’une condition d’exécution inattendue. Par défaut, la trace de la pile de la goroutine actuelle sera imprimée lorsqu’une erreur se produit, en ignorant la fonction d’exécution interne et en sortant avec exit 2.
  Alors que les traces de pile pour toutes les goroutines sont imprimées lorsqu’une erreur se produit s’il n’y a pas de goroutine actuelle, ou si l’échec est interne à l’exécution, les valeurs de support, y compris none(0), all(1), system(2), single, crashparmi lesquels all et system sont les plus couramment utilisés. all consiste à ajouter des informations de trace de pile pour toutes les goroutines créées par l’utilisateur. Et system est similaire mais ajoute des informations de trace de pile pour les fonctions d’exécution et affiche les goroutines créées à l’intérieur de l’exécution.

Goroutine est l’une des principales fonctionnalités de Go. Généralement, on utilise go func() pour créer des goroutines mais se soucient moins de la planification et de l’exécution ultérieures tant que le résultat final est correct.

Cependant, en tant que développeurs Go de haut niveau, nous devons connaître la planification des goroutines, comme le modèle GMP, la taille de la pile que chaque goroutine peut utiliser, le nombre maximum de goroutines pouvant être exécutées en parallèle, etc. Celles-ci peuvent, pour dans une certaine mesure, être affecté par les méthodes des packages d’exécution.

​runtime.GOMAXPROCS(n)

runtime.GOMAXPROCS(n) définit le nombre maximum de goroutines exécutées en parallèle dans un processus (P), qui est identique à NumCPU() et 256 au maximum. Mais la modification de cette valeur déclenchera STW (Stop the World), nous devons donc éviter de l’appeler fréquemment. Cette méthode est principalement utilisée pour s’assurer GOMAXPROCS() est inférieur aux pools de travailleurs lorsque le nombre de travailleurs (ou waitGroups) dans le pool de nœuds de calcul est configurable.

runtime.LockOSThread()
defer runtime.UnlockOSThread()// Call unix functions(non-Go)
fds, err := unix.Socketpair(unix.AF_UNIX, unix.SOCK_DGRAM, 0)
if err != nil {
return false, -1, err
}
r, w := os.NewFile(uintptr(fds[0]), "sync host"), os.NewFile(uintptr(fds[1]), "sync child")

func flushProfiling() error {
switch profileName {
case "none":
return nil
case "cpu":
pprof.StopCPUProfile()
case "heap":
runtime.GC()
fallthrough
...
}

runtime.SetFinalizer(p, func(p *File) { syscall.Close(p.d) })
var buf [10]byte
n, err := syscall.Read(p.d, buf[:])
// Ensure p is not finalized until Read returns.
runtime.KeepAlive(p)​

func GetFileBasicInfo(f *os.File) (*FileBasicInfo, error) {
bi := &FileBasicInfo{}
if err := windows.GetFileInformationByHandleEx(windows.Handle(f.Fd()), windows.FileBasicInfo, (*byte)(unsafe.Pointer(bi)), uint32(unsafe.Sizeof(*bi))); err != nil {
return nil, &os.PathError{Op: "GetFileInformationByHandleEx", Path: f.Name(), Err: err}
}
runtime.KeepAlive(f)
return bi, nil
}​​​