Comment composez-vous le code GO à l'aide du package de test?

Comment composez-vous le code GO à l'aide du package de test?

L'analyse comparative dans GO est facilitée par le package testing , ce qui fournit un moyen simple mais puissant de mesurer les performances de votre code. Pour écrire une référence, vous utilisez le préfixe de la fonction Benchmark suivi d'un nom qui décrit ce que les tests de référence. Voici un exemple de base de la façon d'écrire une référence:

 <code class="go">package main import "testing" func BenchmarkMyFunction(b *testing.B) { for i := 0; i </code>

Dans cet exemple, bN est un nombre défini par le package de test qui indique le nombre de fois que la fonction doit être exécutée. Le package de tests ajustera bN pour obtenir des mesures précises.

Pour exécuter l'indice de référence, vous utilisez la commande go test avec l'indicateur -bench . Par exemple:

 <code class="bash">go test -bench=BenchmarkMyFunction</code>

Cette commande exécutera l'indice de référence et sortira les résultats, montrant le temps pris par opération.

Quelles sont les meilleures pratiques pour rédiger des repères efficaces en Go?

La rédaction de repères efficaces dans GO implique plusieurs meilleures pratiques pour garantir des résultats précis et significatifs:

1. Isoler le code en cours de référence : assurez-vous que la référence ne mesure que le code qui vous intéresse. Évitez d'inclure le code de configuration ou de démontage dans la boucle de référence.

2. Utilisez b.ResetTimer() : Si vous avez besoin d'effectuer des opérations de configuration avant le référence réelle, utilisez b.ResetTimer() pour réinitialiser la minuterie après la configuration et avant le code de référence réel.

    <code class="go">func BenchmarkMyFunction(b *testing.B) { // Setup code b.ResetTimer() for i := 0; i </code>

3. Évitez les allocations de mémoire à l'intérieur de la boucle : les allocations de mémoire peuvent fausser les résultats de référence. Essayez d'allouer la mémoire en dehors de la boucle de référence si possible.

4. Utilisez b.StopTimer() et b.StartTimer() : Si vous avez besoin d'effectuer des opérations qui ne doivent pas être incluses dans la référence, vous pouvez vous arrêter et démarrer la minuterie autour de ces opérations.

    <code class="go">func BenchmarkMyFunction(b *testing.B) { for i := 0; i </code>

5. Exécutez des repères plusieurs fois : utilisez l'indicateur -count pour exécuter plusieurs fois les repères pour tenir compte de la variabilité.

    <code class="bash">go test -bench=BenchmarkMyFunction -count=5</code>

6. Utilisez b.ReportAllocs() : Pour mesurer les allocations de mémoire, utilisez b.ReportAllocs() au début de votre fonction de référence.

    <code class="go">func BenchmarkMyFunction(b *testing.B) { b.ReportAllocs() for i := 0; i </code>

Comment pouvez-vous analyser et interpréter les résultats de référence dans GO?

L'analyse et l'interprétation des résultats de référence dans GO impliquent la compréhension de la sortie fournie par la commande go test . Voici comment interpréter la sortie typique:

 <code class="bash">BenchmarkMyFunction-8 1000000 123 ns/op</code>

• BenchMarkMyFunction-8 : le nom de la référence et la valeur GomaxProcs (8 dans ce cas).
• 1000000 : le nombre d'itérations ( bN ) Le référence a fonctionné.
• 123 NS / OP : le temps moyen par opération dans les nanosecondes.

Pour analyser les résultats plus profondément:

1. Comparez différentes implémentations : exécutez des repères pour différentes implémentations de la même fonction pour comparer leurs performances.

2. Utiliser -benchmem Indicateur : Cet drapeau fournit des statistiques d'allocation de mémoire.

    <code class="bash">go test -bench=BenchmarkMyFunction -benchmem</code>

   La sortie peut ressembler à ceci:

    <code class="bash">BenchmarkMyFunction-8 1000000 123 ns/op 16 B/op 1 allocs/op</code>

   • 16 b / op : le nombre moyen d'octets alloués par opération.
   • 1 ALLOCS / OP : Le nombre moyen d'allocations par opération.
3. Analyser les tendances au fil du temps : utilisez le contrôle de la version pour suivre les changements dans les résultats de référence au fil du temps, en aidant à identifier les régressions de performances.
4. Utiliser des outils de comparaison de référence : des outils comme benchstat peuvent aider à comparer les résultats de référence entre différentes analyses ou versions de votre code.

Quels outils peuvent être utilisés aux côtés du package de test de Go pour améliorer l'analyse comparative?

Plusieurs outils peuvent améliorer les capacités d'analyse comparative fournies par le package de tests de Go:

1. Benchstat : un outil de l'équipe Go qui aide à comparer les résultats de référence entre différentes analyses. Il peut être installé en utilisant:

    <code class="bash">go get golang.org/x/perf/cmd/benchstat</code>

   Vous pouvez l'utiliser pour comparer deux ensembles de résultats de référence:

    <code class="bash">benchstat old.txt new.txt</code>

2. PPROF : l'outil de profilage intégré de Go qui peut être utilisé pour analyser l'utilisation du processeur et de la mémoire. Vous pouvez activer le profilage du processeur dans votre référence avec:

    <code class="go">func BenchmarkMyFunction(b *testing.B) { b.Run("CPU", func(b *testing.B) { b.SetParallelism(1) b.ReportAllocs() b.ResetTimer() for i := 0; i </code>

   Ensuite, exécutez la référence avec le profilage activé:

    <code class="bash">go test -bench=BenchmarkMyFunction -cpuprofile cpu.out</code>

   Vous pouvez ensuite analyser le profil avec:

    <code class="bash">go tool pprof cpu.out</code>

3. Plot de référence : un outil pour visualiser les résultats de référence au fil du temps. Il peut être installé avec:

    <code class="bash">go get github.com/ajstarks/svgo/benchplot</code>

   Vous pouvez l'utiliser pour générer des parcelles à partir des résultats de référence:

    <code class="bash">benchplot -t "My Benchmark" -o mybenchmark.png old.txt new.txt</code>

4. GO-TORCH : Un outil pour visualiser les traces d'exécution GO. Il peut être installé avec:

    <code class="bash">go get github.com/uber/go-torch</code>

   Vous pouvez générer une trace avec:

    <code class="bash">go test -bench=BenchmarkMyFunction -trace trace.out</code>

   Puis visualisez-le avec:

    <code class="bash">go-torch trace.out</code>

Ces outils, lorsqu'ils sont utilisés aux côtés du package de tests de Go, peuvent fournir une vue complète des performances de votre code et vous aider à l'optimiser efficacement.

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!