Penanda aras dan perbandingan prestasi dalam bahasa Go

Dalam Go, anda boleh menulis ujian penanda aras dengan mudah untuk mengukur prestasi kod dengan menggunakan fungsi BenchmarkXXX dalam pakej ujian. Fungsi ini mengikut sintaks standard dan menerima penunjuk jenis *testing.B sebagai hujah, yang mengawal perjalanan penanda aras. Menjalankan penanda aras (go test -bench=BenchmarkName) boleh mengeluarkan jadual keputusan, menunjukkan pelbagai maklumat seperti bilangan nanosaat yang dibelanjakan untuk setiap operasi, bilangan operasi yang dilakukan sesaat, bilangan lelaran dijalankan dalam ujian dan bilangan pas setiap saat jumlah memori, dsb. Dengan membandingkan hasil penanda aras yang berbeza, anda boleh mengenal pasti kawasan kod yang tidak cekap dan dengan itu meningkatkan prestasi keseluruhan aplikasi anda.

Tanda Aras dan Perbandingan Prestasi dalam Bahasa Go

Pengenalan

Tanda aras ialah alat penting untuk mengukur prestasi kod. Ia boleh membantu mengenal pasti kawasan kod yang tidak cekap, dengan itu meningkatkan prestasi keseluruhan aplikasi anda. Bahasa Go menyediakan pakej testing terbina dalam yang menjadikan ujian penanda aras penulisan dalam Go sangat mudah. 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🎜🎜🎜Sintaks fungsi penanda aras adalah seperti berikut: 🎜rrreee🎜di mana: 🎜

• b ialah penunjuk jenis *testing.B , yang mengandungi beberapa ciri tambahan untuk penandaarasan.

🎜🎜Kes Praktikal🎜🎜🎜Mari kita tulis penanda aras untuk membandingkan prestasi dua algoritma pengisihan berbeza: 🎜rrreee🎜🎜Jalankan Penanda Aras🎜🎜🎜Untuk menjalankan penanda aras, jalankan Perintah berikut: rrreee🎜di mana BenchmarkName ialah nama fungsi penanda aras yang anda mahu jalankan. 🎜🎜🎜Tafsiran keputusan🎜🎜🎜Hasil penanda aras akan dikeluarkan dalam bentuk jadual, yang mengandungi pelbagai maklumat, seperti: 🎜

• ns/op: Bilangan nanosaat yang dibelanjakan untuk setiap operasi.
• op/s: Bilangan operasi yang dilakukan sesaat.
• B: Bilangan lelaran dijalankan dalam ujian.
• MB/s: Jumlah memori yang dipindahkan sesaat.

🎜🎜Membandingkan Algoritma Pengisihan🎜🎜🎜Selepas menjalankan penanda aras di atas, anda akan melihat hasil berikut (hasil mungkin berbeza-beza berdasarkan konfigurasi perkakasan dan sistem anda): 🎜rrreee🎜Daripada keputusan ini, kita boleh lihat bahawa Isih Sisipan adalah yang paling perlahan, diikuti dengan Isih Pantas dan yang terpantas ialah sort.Ints. 🎜

Atas ialah kandungan terperinci Penanda aras dan perbandingan prestasi dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!