Pourquoi ma fonction Cgo est-elle tellement plus lente que ma fonction Go équivalente ?

Pourquoi les performances de Cgo sont incroyablement lentes : examen d'un scénario de test

Dans une tentative de comparer les temps d'exécution des fonctions Cgo et Go pures à plusieurs reprises, un testeur a rencontré des résultats inattendus . La fonction Cgo a pris beaucoup plus de temps que la fonction Golang, entraînant une confusion et une exploration du code de test.

Le code de test en question

Le code de test fourni ci-dessous compare les temps d'exécution pour Cgo et des fonctions Go pures, chacune exécutée 100 millions de fois :

import (
    "fmt"
    "time"
)

/*
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void show() {

}

*/
// #cgo LDFLAGS: -lstdc++
import "C"

//import "fmt"

func show() {

}

func main() {
    now := time.Now()
    for i := 0; i < 100000000; i = i + 1 {
        C.show()
    }
    end_time := time.Now()

    var dur_time time.Duration = end_time.Sub(now)
    var elapsed_min float64 = dur_time.Minutes()
    var elapsed_sec float64 = dur_time.Seconds()
    var elapsed_nano int64 = dur_time.Nanoseconds()
    fmt.Printf("cgo show function elasped %f minutes or \nelapsed %f seconds or \nelapsed %d nanoseconds\n",
        elapsed_min, elapsed_sec, elapsed_nano)

    now = time.Now()
    for i := 0; i < 100000000; i = i + 1 {
        show()
    }
    end_time = time.Now()

    dur_time = end_time.Sub(now)
    elapsed_min = dur_time.Minutes()
    elapsed_sec = dur_time.Seconds()
    elapsed_nano = dur_time.Nanoseconds()
    fmt.Printf("go show function elasped %f minutes or \nelapsed %f seconds or \nelapsed %d nanoseconds\n",
        elapsed_min, elapsed_sec, elapsed_nano)

    var input string
    fmt.Scanln(&amp;input)
}

Résultats inattendus et recherche de réponses

Les résultats obtenus à partir du code de test ont montré que l'appel de la fonction C était nettement plus lent que la fonction Go. Cela a conduit à la question de savoir s'il y avait une faille dans le code de test lui-même.

Plonger dans les défis de performance de Cgo

Bien que le code de test fourni soit valide, les limitations de performances inhérentes à Cgo contribuent à le temps d'exécution plus lent observé pour la fonction Cgo.

L'appel de code C/C via Cgo entraîne une surcharge relativement élevée, et minimiser ces appels CGo est généralement recommandé. Dans ce scénario particulier, déplacer la boucle vers C au lieu d'appeler à plusieurs reprises une fonction CGo depuis Go pourrait potentiellement améliorer les performances.

De plus, CGo utilise une configuration de thread distincte pour exécuter le code C, en faisant certaines hypothèses sur le code. comportement. Certaines de ces hypothèses peuvent entraîner des impacts sur les performances :

• Les goroutines dans Go utilisent des piles relativement petites et gèrent la croissance de la pile de manière dynamique.
• La gestion des threads de CGo peut interférer avec l'implémentation du stockage local des threads de libpthread.
• Le gestionnaire de signal UNIX de Go peut perturber le C ou le C traditionnel code.
• La réutilisation des threads du système d'exploitation pour plusieurs Goroutines peut avoir des conséquences négatives si le code C bloque les appels système ou monopolise le thread.

Conclusion

Le rôle de CGo devrait être principalement considéré comme une passerelle vers l'interface avec les bibliothèques existantes, potentiellement avec de petites fonctions supplémentaires de wrapper C pour réduire le nombre d'appels effectués depuis Go. Les attentes d'optimisations de performances de type C via CGo ne sont généralement pas satisfaites, car il y a déjà moins d'écart de performances entre le code C et Go équivalent.

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!