Benchmarks und Leistungsvergleich in der Go-Sprache

In Go können Sie ganz einfach Benchmark-Tests schreiben, um die Codeleistung zu messen, indem Sie die BenchmarkXXX-Funktionen im Testpaket verwenden. Diese Funktionen folgen der Standardsyntax und erhalten als Argument einen Zeiger vom Typ *testing.B, der die Ausführung des Benchmarks steuert. Beim Ausführen des Benchmarks (go test -bench=BenchmarkName) kann eine Ergebnistabelle ausgegeben werden, die verschiedene Informationen wie die Anzahl der für jede Operation aufgewendeten Nanosekunden, die Anzahl der pro Sekunde durchgeführten Operationen, die Anzahl der im Test ausgeführten Iterationen usw. anzeigt Anzahl der Durchläufe pro Sekunde, Speichermenge usw. Durch den Vergleich der Ergebnisse verschiedener Benchmarks können Sie ineffiziente Codebereiche identifizieren und so die Gesamtleistung Ihrer Anwendung verbessern.

Benchmarks und Leistungsvergleich in der Go-Sprache

Einführung

Benchmarks sind ein wichtiges Werkzeug zur Messung der Codeleistung. Es kann dabei helfen, ineffiziente Codebereiche zu identifizieren und so die Gesamtleistung Ihrer Anwendung zu verbessern. Die Go-Sprache bietet ein integriertes testing-Paket, das das Schreiben von Benchmark-Tests in Go sehr einfach macht. testing 包，使得在 Go 中编写基准测试变得非常容易。

语法

基准测试函数的语法如下：

func BenchmarkName(b *testing.B)

其中：

• b 是一个 *testing.B 类型的指针，它包含了一些用于基准测试的附加功能。

实战案例

让我们编写一个基准测试来比较两种不同的排序算法的性能：

package main

import (
    "testing"
    "bytes"
    "sort"
)

// 插入排序
func insertionSort(nums []int) {
    for i := 1; i < len(nums); i++ {
        key := nums[i]
        j := i - 1

        for j >= 0 && nums[j] > key {
            nums[j+1] = nums[j]
            j--
        }

        nums[j+1] = key
    }
}

// 快速排序
func quickSort(nums []int) {
    if len(nums) <= 1 {
        return
    }

    pivot := nums[len(nums)/2]
    var left, right []int

    for _, num := range nums {
        if num < pivot {
            left = append(left, num)
        } else if num > pivot {
            right = append(right, num)
        }
    }

    quickSort(left)
    quickSort(right)

    copy(nums, append(left, append([]int{pivot}, right...)...))
}

// 基准测试
func BenchmarkInsertionSort(b *testing.B) {
    var buf bytes.Buffer

    for i := 0; i < b.N; i++ {
        nums := []int{5, 2, 8, 3, 1, 9, 4, 7, 6}
        insertionSort(nums)
        buf.WriteString(bytes.Join(nums, " "))
    }
}

func BenchmarkQuickSort(b *testing.B) {
    var buf bytes.Buffer

    for i := 0; i < b.N; i++ {
        nums := []int{5, 2, 8, 3, 1, 9, 4, 7, 6}
        quickSort(nums)
        buf.WriteString(bytes.Join(nums, " "))
    }
}

func BenchmarkGoSort(b *testing.B) {
    var buf bytes.Buffer

    for i := 0; i < b.N; i++ {
        nums := []int{5, 2, 8, 3, 1, 9, 4, 7, 6}
        sort.Ints(nums)
        buf.WriteString(bytes.Join(nums, " "))
    }
}

运行基准测试

要运行基准测试，请运行以下命令：

go test -bench=BenchmarkName

其中 BenchmarkName 是您要运行的基准测试函数的名称。

结果解读

基准测试结果将以表格的形式输出，其中包含各种信息，例如：

• ns/op：每个操作所花费的纳秒数。
• op/s：每秒执行的操作数。
• B：测试中运行的迭代次数。
• MB/s：每秒传递的内存量。

比较排序算法

运行上面的基准测试后，您会看到以下结果（结果可能会因您的硬件和系统配置而异）：

BenchmarkInsertionSort     20332432               62.5 ns/op         16 B/op               5.75 MB/s
BenchmarkQuickSort         11440808              104 ns/op          24 B/op              1.64 MB/s
BenchmarkGoSort            21864500               57.7 ns/op          32 B/op               4.77 MB/s

从这些结果中，我们可以看到 插入排序 是最慢的，其次是 快速排序，最快的则是 sort.Ints

🎜Syntax🎜🎜🎜Die Syntax der Benchmark-Funktion lautet wie folgt: 🎜rrreee🎜wobei: 🎜

• b ein Zeiger vom Typ *testing.B , das einige zusätzliche Funktionen für das Benchmarking enthält.

🎜🎜Praktischer Fall🎜🎜🎜Lassen Sie uns einen Benchmark schreiben, um die Leistung zweier verschiedener Sortieralgorithmen zu vergleichen: 🎜rrreee🎜🎜Benchmark ausführen🎜🎜🎜Um den Benchmark auszuführen, führen Sie den folgenden Befehl aus: 🎜 rrreee🎜wobei BenchmarkName der Name der Benchmark-Funktion ist, die Sie ausführen möchten. 🎜🎜🎜Interpretation der Ergebnisse🎜🎜🎜Die Benchmark-Ergebnisse werden in Form einer Tabelle ausgegeben, die verschiedene Informationen enthält, wie zum Beispiel: 🎜

• ns/op: Die Anzahl der Nanosekunden, die für jeden Vorgang aufgewendet wurden.
• op/s: Anzahl der pro Sekunde ausgeführten Operationen.
• B: Anzahl der im Test ausgeführten Iterationen.
• MB/s: Die pro Sekunde übertragene Speichermenge.

🎜🎜Vergleich von Sortieralgorithmen🎜🎜🎜Nachdem Sie den obigen Benchmark ausgeführt haben, werden Sie die folgenden Ergebnisse sehen (die Ergebnisse können je nach Hardware- und Systemkonfiguration variieren): 🎜rrreee🎜Anhand dieser Ergebnisse können wir Sehen Sie, dass Insertion Sort am langsamsten ist, gefolgt von Quick Sort und am schnellsten ist sort.Ints. 🎜

Das obige ist der detaillierte Inhalt vonBenchmarks und Leistungsvergleich in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!