GoLang au-delà des bases : analyse d'évasion

Comprenons comment Golang gère les variables et ce qu'est cette analyse d'évasion. Golang dispose de 2 types de types de données d'allocation de mémoire utilisés dans l'environnement d'exécution Go appelés pile et tas.

La pile est plus rapide pour effectuer des opérations (entrée et sortie). Les variables à l'intérieur d'une fonction auxquelles on accède à l'intérieur de celle-ci vont dans cette pile. Par exemple :

package main

import "fmt"

func stackExample() int {
    a := 10        // Variable `a` is allocated on the stack
    b := 20        // Variable `b` is allocated on the stack
    result := a + b // `result` is also allocated on the stack
    return result   // All stack variables are popped off when the function exits
}

func main() {
    result := stackExample() // Function call happens, variables are pushed to the stack
    fmt.Println(result)      // Print the result
}

Voici comment fonctionne la pile dans GoLang. Vient ensuite un tas. C'est une mémoire dynamique, c'est-à-dire que sa taille peut être ajustée en fonction des besoins. Voici un exemple simple d'allocation de tas.

package main

import "fmt"

func heapExample() *int {
    num := 42           // Variable `num` is created inside the function
    return &num         // Returning the address of `num`, which escapes the function
}

func main() {
    ptr := heapExample() // The value pointed to by `ptr` is allocated on the heap
    fmt.Println(*ptr)    // Accessing the heap-allocated variable through the pointer
}

Ici, puisque la fonction renvoie un pointeur vers num, le runtime Go détecte que num sera accessible en dehors de la portée de la fonction. En conséquence, il alloue num sur le tas au lieu de la pile.

Un Heap est utilisé pour stocker des variables qui dépassent la portée d'une fonction ou d'une goroutine. Parfois, lorsque la valeur d'une variable est très énorme, elle est stockée dans un tas.

Après avoir compris ces deux éléments, il est temps de passer à l'analyse de l'évasion. Il n'y a aucun moyen de savoir quelles variables seront allouées au tas simplement en lisant le code Go. Nous pouvons comprendre cela avec une « analyse d’évasion ». Par échappement, nous entendons si la variable échappe à la portée d'une fonction déterminant si elle sera stockée sur un tas ou une pile.

Exécutez la commande build du code go comme ceci

go build -gcflags '-m -l'

-m - Drapeau pour afficher l'analyse d'évasion.
-l - Désactivez l'inline pour que les traces de pile restent précises.

Prenez ce code :

package main

func escapeExample() *int {
    x := 42
    return &x // x escapes because its address is returned
}

func noEscapeExample() int {
    y := 100
    return y // y does not escape
}

func main() {
    _ = escapeExample()
    _ = noEscapeExample()
}

Les résultats ressemblent à ceci :

./main.go:4:10: &x escapes to heap
./main.go:12:13: main escapes to heap

Alors, pourquoi faisons-nous tout cela ? Cette analyse peut s'avérer utile lorsque vous déboguez des problèmes de performances. Les variables sont mieux stockées dans une pile plutôt que dans un tas. Vous pouvez trouver où les variables s'échappent vers le tas et refactoriser le code pour une meilleure efficacité.

J'espère que vous avez appris quelque chose de nouveau aujourd'hui.
Je suis actuellement en train de créer LiveAPI, un outil de génération de documents API, essayez-le.

Merci d'avoir lu.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!