¿Hola tuzas?

En esta publicación de blog, le mostraré cómo usar una increíble herramienta integrada en el paquete de pruebas #golang. ¿Cómo probarías el rendimiento de un fragmento de código o una función? Utilice pruebas comparativas.

Vamos.

Para esta prueba, usaré el clásico Número de Fibonacci o Secuencia de Fibonacci, que está determinada por:

if (x 



Esta secuencia es importante porque aparece también en varias partes de las matemáticas y de la naturaleza, como se muestra a continuación:



Hay varias formas de implementar este código, y elegiré dos para nuestras pruebas comparativas: los métodos recursivo e iterativo para calcularlo. El objetivo principal de las funciones es proporcionar una posición y devolver el número de Fibonacci en esa posición.


  
  
  Método recursivo




// main.go

func fibRecursive(n int) int {
    if n 




  
  
  Método iterativo




// main.go

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

    if position 



Estos métodos no están optimizados, pero los resultados de las pruebas son significativamente diferentes incluso para un número pequeño. Verás esto en las pruebas. Para seguir el código, puede hacer clic aquí.

Ahora, para las pruebas benchmark, escribamos algunas pruebas en el archivo _main_test.go. Usando la documentación de Golang en benchmark, puede crear las funciones que se probarán de la siguiente manera:


// 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 




Pregunta, antes de continuar: ¿cuál es más rápido?


Ejecutemos la prueba para un número pequeño (10) y para un número ligeramente mayor (80). Para ejecutar las pruebas benchmark, simplemente ejecute el comando:

go test -bench=NombredelaFunción

Si quieres saber más sobre este comando, consulta aquí.

Primera prueba: posición=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




Analicemos con la ayuda de esta imagen:



Según la imagen, tenemos 8 núcleos para las pruebas, sin límite de tiempo (se ejecutará hasta su finalización). Se necesitaron 1.651 s para completar la tarea.


==== 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 ====




Ese es un buen resultado. Comprobemos la función recursiva para la posición 10:


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




Podemos ver que se necesitaron 1.882s para completar la tarea.

La función iterativa ganó por unos pocos decisegundos. Probemos una prueba más con:

Posición 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




¡Guau! ¿Ahora la función recursiva es más rápida?

Terminemos con un número ligeramente mayor.

Posición 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 diferencia es enorme. Para la posición 80, el enfoque iterativo tomó aproximadamente 2 segundos. Para la posición 50, la función recursiva tardó alrededor de 45 segundos. Esto demuestra la importancia de realizar una evaluación comparativa de su código cuando su proyecto Golang comienza a ralentizarse.


  
  
  Conclusión


Si su código de producción se ejecuta lentamente o es impredeciblemente más lento, puede usar esta técnica, combinada con pprof u otras herramientas del paquete de prueba integrado, para identificar y probar dónde se está desempeñando su código. mal y cómo optimizarlo.


Nota al margen: no todo el código que es hermoso a la vista tiene mejor rendimiento.



  
  
  Ejercicio adicional


 ¿Puedes encontrar una mejor manera de mejorar la función recursiva? (Consejo: utilice programación dinámica). Este artículo explica por qué para algunos números pequeños, la estrategia recursiva es mejor.