🥇 Pruebas, Benchmark.

El paquete testing incluye un poderoso framework de benchmark. El número de veces que se invoca una función es controlado automáticamente por el framework y al final se reporta en la salida.

Supongamos que deseamos almacenar preparar un string que se va construyendo a través de un loop. En un ejemplo anterior vimos que los buffers son mas eficientes que utilizar el operador += de concatenación, o que almacenar un arreglo de strings y luego explotarlo. Pero como podemos verificar tal performance. Para ello preparamos 3 funciones que realizan la misma función, de cada una de las formas posibles.

Primero el paquete longstring dentro del archivo longstring.go.

package longstring

import (
    "bytes"
    "strings"
)

func MedianteConcatenacion(longitud int) string {
    var s string
    for i := 0; i < longitud; i++ {
        s += "texto"
    }
    return s
}

func MedianteArreglo(longitud int) string {
    s := []string{}
    for i := 0; i < longitud; i++ {
        s = append(s, "texto")
    }
    return strings.Join(s, "")
}

func MedianteBuffer(longitud int) string {
    var buffer bytes.Buffer
    for i := 0; i < longitud; i++ {
        buffer.WriteString("texto")
    }
    return buffer.String()
}

En este podemos ver que tenemos 3 funciones que hacen la misma operacion de ir construyendo este string de salida. El número de ciclos realizados por el loop dependen del párametro longitud.

Ahora creamos las pruebas de benchmark, estas a diferencia de las pruebas de test tienen el prefijo Benchmark y reciben un parametro *testing.B. El argumento contine un valor N que representa el numero de veces que el loop se va a repetir, este valor es ajustado de forma automática por Golang. En cada uno de los casos invocamos cada uno de los distintos métodos.

package longstring

import "testing"

func BenchmarkMedianteConcatenacion(b *testing.B) {
    for i := 0; i < b.N; i++ {
        MedianteConcatenacion(100)
    }
}

func BenchmarkMedianteArreglo(b *testing.B) {
    for i := 0; i < b.N; i++ {
        MedianteArreglo(100)
    }
}

func BenchmarkMedianteBuffer(b *testing.B) {
    for i := 0; i < b.N; i++ {
        MedianteBuffer(100)
    }
}

En la salida obtenemos los resultados del benchmark.

go test -bench=.
goos: darwin
goarch: amd64
pkg: .../benchmark
BenchmarkMedianteConcatenacion-8      200000          7916 ns/op
BenchmarkMedianteArreglo-8            500000          2464 ns/op
BenchmarkMedianteBuffer-8            1000000          1429 ns/op
PASS
ok      .../benchmark    4.378s

En el caso anterior podemos darnos cuenta que basado en el benchmark, el método mas idoneo es BenchmarkMedianteBuffer.

Pruebas, Tablas de pruebas. Pruebas, Cobertura del código
comments powered by Disqus