Go Performance : paramètres de fonction par rapport aux variables globales : existe-t-il une réelle différence de vitesse ?

Implications sur les performances des paramètres de fonction par rapport aux variables globales

Dans le domaine de la programmation Go, la question se pose souvent : les paramètres de fonction doivent-ils être prioritaires sur des variables globales pour des performances optimales ?

Considérez la fonction checkFiles qui prend une tranche de modèles exclus comme un argument :

func checkFiles(path string, excludedPatterns []string) {
    // ...
}

Étant donné queexclusPatterns reste constant tout au long de l'exécution de la fonction, certains peuvent suggérer d'en faire une variable globale pour optimiser les performances en éliminant les passages répétés de paramètres.

Cependant, cette optimisation est inutile dans Go en raison de sa gestion efficace des paramètres de tranche. Les tranches sont des structures légères qui contiennent des métadonnées (longueur et capacité) et pointent vers une structure de données sous-jacente. Lorsqu'une tranche est passée en tant que paramètre de fonction, seules les métadonnées sont copiées, et non l'intégralité du tableau de sauvegarde. C'est ce qu'on appelle la sémantique de « copie sur écriture ». Par conséquent, accéder aux modèles exclus via un paramètre de fonction est tout aussi efficace que d'y accéder en tant que variable globale.

De plus, transmettre des paramètres par valeur peut souvent conduire à des optimisations de la part du compilateur, comme la mise en cache. Les variables globales, en revanche, nécessitent une gestion plus complexe, ce qui peut potentiellement entraver l'optimisation.

Les benchmarks illustrent qu'il n'y a pas de différence de performances significative entre le passage d'une tranche en tant que paramètre de fonction et l'accès à une tranche globale :

package main

import (
    "testing"
)

var gslice = make([]string, 1000)

func global(s string) {
    for i := 0; i < 100; i++ {
        _ = s
        _ = gslice // Access global-slice
    }
}

func param(s string, ss []string) {
    for i := 0; i < 100; i++ {
        _ = s
        _ = ss // Access parameter-slice
    }
}

func BenchmarkParameter(b *testing.B) {
    for i := 0; i < b.N; i++ {
        param("hi", gslice)
    }
}

func BenchmarkGlobal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        global("hi")
    }
}

func main() {
    testing.Main(m.Run, m.init, m.cleanup, m.installFlags)
}

Les résultats de référence indiquent que les deux approches fonctionnent à des vitesses presque identiques :

BenchmarkParameter-8   20000000                80.2 ns/op
BenchmarkGlobal-8     20000000                79.9 ns/op

En conclusion, pour le cas d'utilisation en question, passer ExclusPatterns en tant que paramètre de fonction est recommandé car il simplifie le code, améliore la lisibilité et offre des performances comparables aux variables globales dans Go.

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!