Sub-benchmark

b.Run ile alt benchmark çalıştırmayı öğrenirsin.

Sub-benchmark

b.Run ile farklı girdi boyutlarını tek benchmark altında ölçebilirsin; büyüme davranışı (doğrusal mı, karesel mi) böyle görünür:

func BenchmarkAra(b *testing.B) {
    for _, n := range []int{10, 1000, 100000} {
        veri := sirali(n)
        b.Run(fmt.Sprintf("n=%d", n), func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                sinkBool = ikiliAra(veri, n/2)
            }
        })
    }
}

Çıktı: BenchmarkAra/n=10, BenchmarkAra/n=1000... -bench=Ara/n=1000 ile tek alt ölçüm çalıştırılır.

Veriyi dışarıda hazırla

Alt benchmark'ın girdisini b.Run çağrısından önce hazırlamak, hazırlık süresinin ölçüme girmesini önler; her alt benchmark kendi zamanlayıcısıyla başlar. b.Run'a verilen kapanış, döngü değişkenini (Go 1.22'den beri her turda yeni olan n) güvenle yakalar.

Uygulama Boyutlara göre ölçüm

topla(n int) int 1'den n'ye kadar döngüyle toplasın. []int{10, 1000} boyutları için testing.Benchmark ile ölç ve büyük boyutun işlem başına süresinin (NsPerOp()) küçükten fazla olduğunu yazdır.

Örnek çözümü göster

package main

import (
    "fmt"
    "testing"
)

var sink int

func topla(n int) int {
    t := 0
    for i := 1; i <= n; i++ {
        t += i
    }
    return t
}

func main() {
    var sure []int64
    for _, n := range []int{10, 1000} {
        r := testing.Benchmark(func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                sink = topla(n)
            }
        })
        sure = append(sure, r.NsPerOp())
    }
    fmt.Println(sure[1] > sure[0])
}

Kendini test et

n 100 kat büyüdüğünde ns/op da yaklaşık 100 kat büyüyorsa algoritma nasıldır?
- Doğrusal (O(n))
- Logaritmik (O(log n))
- Sabit (O(1))
- Karesel (O(n²))
Cevabı göster

Doğrusal (O(n)) — Süre girdiyle aynı oranda büyüyorsa doğrusaldır; karesel olsaydı 10.000 kat, logaritmik olsaydı çok az büyürdü.

Alt benchmark

b.____(fmt.Sprintf("n=%d", n), func(b *testing.B) {
    // ...
})

Cevabı göster

b.Run(fmt.Sprintf("n=%d", n), func(b *testing.B) {
    // ...
})

Karmaşıklık ve büyüme (n×100)

O(1)

Değişmez
O(log n)

~3 kat
O(n)

~100 kat
O(n²)

~10.000 kat

Sıradaki ders: Benchmark karşılaştırma

Deneyiminizi Geliştiriyoruz

Çerez Tercihleri

Kesinlikle Gerekli Çerezler

Analitik Çerezler