Benchmark mit Golang

Hallo Gophers?

In diesem Blogbeitrag zeige ich Ihnen, wie Sie ein fantastisches Tool verwenden, das im #golang-Testpaket integriert ist. Wie würden Sie die Leistung eines Codeteils oder einer Funktion testen? Verwenden Sie Benchmark--Tests.

Lass uns gehen.

Für diesen Test verwende ich die klassische Fibonacci-Zahl oder Fibonacci-Folge, die bestimmt wird durch:

if (x < 2) 
   F(0) = 1
   F(2) = 2
else 
   F(x) = F(x-1) + F(x-2)

In practice, the sequence is:
1, 1, 2, 3, 5, 8, 13, etc.

Diese Reihenfolge ist wichtig, da sie auch in mehreren Teilen der Mathematik und der Natur vorkommt, wie unten gezeigt:

Es gibt mehrere Möglichkeiten, diesen Code zu implementieren, und ich werde zwei für unsere Benchmark-Tests auswählen: die rekursiven und iterativen Methoden zur Berechnung. Das Hauptziel der Funktionen besteht darin, eine Position bereitzustellen und die Fibonacci-Zahl an dieser Position zurückzugeben.

Rekursive Methode

// main.go

func fibRecursive(n int) int {
    if n <= 2 {
        return 1
    }
    return fibRecursive(n-1) + fibRecursive(n-2)
}

Iterative Methode

// main.go

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

    if position <= 2 {
        return 1
    }

    var result, i uint
    for i = 2; i < position; i++ {
        result = slc[i-1] + slc[i-2]
        slc[i] = result
    }

    return result
}

Diese Methoden sind nicht optimiert, aber die Ergebnisse der Tests unterscheiden sich selbst bei einer kleinen Anzahl erheblich. Das werden Sie in den Tests sehen. Um dem Code zu folgen, klicken Sie hier.

Jetzt schreiben wir für die Benchmark--Tests einige Tests in die Datei _main_test.go. Mithilfe der Golang-Dokumentation zum Benchmark können Sie die zu testenden Funktionen wie folgt erstellen:

// 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 < b.N; i++ { 
        fibIterative(uint(100))
    }
}

// Same as above
func BenchmarkFibRecursive(b *testing.B) {
    for i := 0; i < b.N; i++ {
        fibRecursive(100)
    }
}

Frage, bevor Sie fortfahren: Welches ist schneller?

Lassen Sie uns den Test für eine kleine Zahl (10) und für eine etwas größere Zahl (80) durchführen. Um die Benchmark-Tests auszuführen, führen Sie einfach den Befehl aus:

Gehen Sie test -bench=NameoftheFunction

Wenn Sie mehr über diesen Befehl erfahren möchten, schauen Sie hier nach.

Erster 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

Lass uns mit Hilfe dieses Bildes analysieren:

Dem Bild zufolge haben wir 8 Kerne für die Tests, keine zeitliche Begrenzung (es läuft bis zum Abschluss). Es dauerte 1,651 Sekunden, um die Aufgabe abzuschließen.

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

Das ist ein gutes Ergebnis. Schauen wir uns die rekursive Funktion für Position 10 an:

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

Wir können sehen, dass es 1,882 Sekunden gedauert hat, um die Aufgabe abzuschließen.

Die iterative Funktion gewann mit ein paar Dezisekunden Vorsprung. Versuchen wir noch einen Test mit:

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

Wow! Jetzt ist die rekursive Funktion schneller?

Beenden wir mit einer etwas größeren Zahl.

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

Der Unterschied ist riesig. Für Position 80 dauerte der iterative Ansatz etwa 2 Sekunden. Für Position 50 dauerte die rekursive Funktion etwa 45 Sekunden. Dies zeigt, wie wichtig es ist, Ihren Code zu vergleichen, wenn Ihr Golang-Projekt langsamer wird.

Abschluss

Wenn Ihr Produktionscode langsam läuft oder unvorhersehbar langsamer ist, können Sie diese Technik in Kombination mit pprof oder anderen Tools aus dem integrierten Testpaket verwenden, um die Leistung Ihres Codes zu identifizieren und zu testen schlecht und wie man es optimiert.

Randbemerkung: Nicht jeder Code, der schön für das Auge ist, ist leistungsfähiger.

Zusätzliche Übung

Können Sie einen besseren Weg finden, die rekursive Funktion zu verbessern? (Tipp: Verwenden Sie dynamische Programmierung). In diesem Artikel wird erklärt, warum für einige kleine Zahlen die rekursive Strategie besser ist.

Das obige ist der detaillierte Inhalt vonBenchmark mit Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!