Bonjour les Gophers ?

Dans cet article de blog, je vais vous montrer comment utiliser un outil génial intégré au package de test #golang. Comment testeriez-vous les performances d’un morceau de code ou d’une fonction ? Utilisez des tests de référence.

Allons-y.

Pour ce test, j'utiliserai le nombre de Fibonacci classique ou la séquence de Fibonacci, qui est déterminé par :

if (x 



Cette séquence est importante car elle apparaît également dans plusieurs parties des mathématiques et de la nature, comme indiqué ci-dessous :



Il existe plusieurs façons d'implémenter ce code, et j'en choisirai deux pour nos tests de référence : les méthodes récursives et itératives de calcul. L'objectif principal des fonctions est de fournir une position et de renvoyer le nombre de Fibonacci à cette position.


  
  
  Méthode récursive




// main.go

func fibRecursive(n int) int {
    if n 




  
  
  Méthode itérative




// main.go

func fibIterative(position uint) uint {
    slc := make([]uint, position)
    slc[0] = 1
    slc[1] = 1

    if position 



Ces méthodes ne sont pas optimisées, mais les résultats des tests sont significativement différents même pour un petit nombre. Vous le verrez dans les tests. Pour suivre le code, vous pouvez cliquer ici.

Maintenant, pour les tests benchmark, écrivons quelques tests dans le fichier _main_test.go. À l'aide de la documentation de Golang sur benchmark, vous pouvez créer les fonctions à tester comme suit :



// main_test.go

// The key is to start every function you want to benchmark with the keyword Benchmark and use b *testing.B instead of t *testing.T as input 
func BenchmarkFibIterative(b *testing.B) {
    // Use this for-loop to ensure the code will behave correctly. 
    // Now, you can put the function or piece of code you want to test
    for i := 0; i 




Question, avant de continuer : lequel est le plus rapide ?


Faisons le test pour un petit nombre (10) et pour un nombre légèrement plus grand (80). Pour exécuter les tests benchmark, exécutez simplement la commande :

aller tester -bench=NomdelaFonction

Si vous souhaitez en savoir plus sur cette commande, cliquez ici.

Premier test : position=10



//(fibIterative)
Results:
cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibIterative-8         24491042                42.50 ns/op
PASS
ok      playground      1.651s




Analysons à l'aide de cette image :



Selon l'image, nous avons 8 cœurs pour les tests, sans limite de temps (il fonctionnera jusqu'à la fin). Il a fallu 1,651s pour terminer la tâche.



==== Extra ====
We got 24,491,042 iterations (computations), and each iteration (op) took 42.50 ns.

Doing some math, we can calculate how much time one op took:

42.50 ns/op with 1 ns = 1/1,000,000,000 s
op ≈ 2.35270590588e-12 s
==== Extra ====




C'est un bon résultat. Vérifions la fonction récursive pour la position 10 :



// Results
BenchmarkFibRecursive-8          6035011               187.8 ns/op
PASS
ok      playground      1.882s




Nous pouvons voir qu'il a fallu 1,882 s pour terminer la tâche.

La fonction itérative a gagné de quelques décisecondes. Essayons un autre test avec :

Position 50



// Results for the Iterative Function

cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibIterative-8         27896118                45.37 ns/op
PASS
ok      playground      2.876s

// Results for the Recursive Function

cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibRecursive-8          6365198               186.3 ns/op
PASS
ok      playground      1.918s




Ouah! Maintenant, la fonction récursive est plus rapide ?

Terminons avec un nombre légèrement plus grand.

Position 80



// Results for the Iterative Function

cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibIterative-8          5102344               229.5 ns/op
PASS
ok      playground      1.933s

// Results for the Recursive Function
// My poor PC couldn’t handle it, so I had to reduce the position to 50 just to get some results printed.

cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
BenchmarkFibRecursive-8                1        44319299474 ns/op
PASS
ok      playground      44.951s




La différence est énorme. Pour la position 80, l'approche itérative a duré environ 2 secondes. Pour la position 50, la fonction récursive a pris environ 45 secondes. Cela démontre l'importance de comparer votre code lorsque votre projet Golang commence à ralentir.


  
  
  Conclusion


Si votre code de production s'exécute lentement ou est plus lent de manière imprévisible, vous pouvez utiliser cette technique, combinée avec pprof ou d'autres outils du package de test intégré, pour identifier et tester les performances de votre code. mal et comment l'optimiser.


Remarque : tous les codes beaux à regarder ne sont pas tous plus performants.



  
  
  Exercice supplémentaire


Pouvez-vous trouver un meilleur moyen d'améliorer la fonction récursive ? (Conseil : utilisez la programmation dynamique). Cet article explique pourquoi pour certains petits nombres, la stratégie récursive est meilleure.