Benchmarks et comparaison des performances en langage Go

Dans Go, vous pouvez facilement écrire des tests de référence pour mesurer les performances du code en utilisant les fonctions BenchmarkXXX du package de tests. Ces fonctions suivent une syntaxe standard et reçoivent en argument un pointeur de type *testing.B, qui contrôle le déroulement du benchmark. L'exécution du benchmark (go test -bench=BenchmarkName) peut générer un tableau de résultats, affichant diverses informations telles que le nombre de nanosecondes passées sur chaque opération, le nombre d'opérations effectuées par seconde, le nombre d'itérations exécutées dans le test et le nombre de passes par seconde quantité de mémoire, etc. En comparant les résultats de différents benchmarks, vous pouvez identifier les zones de code inefficaces et ainsi améliorer les performances globales de votre application.

Benchmarks et comparaison des performances en langage Go

Introduction

Les benchmarks sont un outil important pour mesurer les performances du code. Cela peut aider à identifier les zones de code inefficaces, améliorant ainsi les performances globales de votre application. Le langage Go fournit un package testing intégré qui facilite grandement l'écriture de tests de référence dans Go. 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

🎜Syntaxe🎜🎜🎜La syntaxe de la fonction benchmark est la suivante : 🎜rrreee🎜où : 🎜

• b est un pointeur de type *testing.B , qui contient des fonctionnalités supplémentaires pour l’analyse comparative.

🎜🎜Cas pratique🎜🎜🎜Écrivons un benchmark pour comparer les performances de deux algorithmes de tri différents : 🎜rrreee🎜🎜Exécutez le benchmark🎜🎜🎜Pour exécuter le benchmark, exécutez la commande suivante : 🎜 rrreee🎜où BenchmarkName est le nom de la fonction de référence que vous souhaitez exécuter. 🎜🎜🎜Interprétation des résultats🎜🎜🎜Les résultats du benchmark seront affichés sous la forme d'un tableau, qui contient diverses informations, telles que : 🎜

• ns/op : Le nombre de nanosecondes passées sur chaque opération.
• op/s : nombre d'opérations effectuées par seconde.
• B : Nombre d'itérations exécutées dans le test.
• Mo/s : quantité de mémoire transférée par seconde.

🎜🎜Comparaison des algorithmes de tri🎜🎜🎜Après avoir exécuté le benchmark ci-dessus, vous verrez les résultats suivants (les résultats peuvent varier en fonction de votre matériel et de la configuration de votre système) : 🎜rrreee🎜À partir de ces résultats, nous pouvons voyez que Tri par insertion est le plus lent, suivi de Tri rapide, et le plus rapide est sort.Ints. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!