Go语言性能基准测试：正确使用testing.B避免误导性结果

package child_sort

import (
    "math/rand"
    "testing"
    "time"
)

// 排序算法实现 (BubbleSort, SelectionSort, InsertionSort) 略
// ...

func generate(size int, min, max int) []int {
    rand.Seed(time.Now().UTC().UnixNano()) // 注意：在基准测试中频繁播种随机数可能影响性能
    var xs = make([]int, size, size)
    for i := range xs {
        xs[i] = min + rand.Intn(max-min)
    }
    return xs
}

func BenchmarkBubble(b *testing.B) {
    xs := generate(10000, -100, 100)
    SortBubble(xs) // 问题所在：只调用了一次
}

func BenchmarkSelection(b *testing.B) {
    xs := generate(10000, -100, 100)
    SortSelection(xs) // 问题所在：只调用了一次
}

func BenchmarkInsertion(b *testing.B) {
    xs := generate(10000, -100, 100)
    SortInsertion(xs) // 问题所在：只调用了一次
}

BenchmarkBubble        1    2258469081 ns/op      241664 B/op          1 allocs/op
BenchmarkSelection  1000000000           0.60 ns/op        0 B/op          0 allocs/op
BenchmarkInsertion         1    1180026827 ns/op      241664 B/op          1 allocs/op

package child_sort

import (
    "math/rand"
    "testing"
    "time"
)

// 排序算法实现 (BubbleSort, SelectionSort, InsertionSort)
func SortBubble(xs []int) {
    for i := range xs {
        swapped := false
        for j := 1; j < len(xs)-i; j++ {
            if xs[j-1] > xs[j] {
                xs[j-1], xs[j] = xs[j], xs[j-1]
                swapped = true
            }
        }
        if !swapped {
            break
        }
    }
}

func SortSelection(xs []int) {
    for i := range xs {
        min_i := i
        for j := i + 1; j < len(xs); j++ {
            if xs[j] < xs[min_i] {
                min_i = j
            }
        }
        if min_i != i {
            xs[i], xs[min_i] = xs[min_i], xs[i]
        }
    }
}

func SortInsertion(xs []int) {
    for i := 1; i < len(xs); i++ {
        for j := i; j > 0; j-- {
            if xs[j] < xs[j-1] {
                xs[j], xs[j-1] = xs[j-1], xs[j]
            }
        }
    }
}

// 辅助函数：生成随机整数切片
func generate(size int, min, max int) []int {
    // 更好的做法是在测试开始时只播种一次，或者在Benchmark函数外部播种
    // rand.Seed(time.Now().UTC().UnixNano())
    // 考虑到多次调用generate可能导致重复播种，这里可以简化或将播种逻辑移出
    // 为确保每次测试数据略有不同，可以考虑使用固定的种子或在包级别初始化一次
    r := rand.New(rand.NewSource(time.Now().UnixNano())) // 使用局部随机数生成器
    xs := make([]int, size)
    for i := range xs {
        xs[i] = r.Intn(max-min) + min
    }
    return xs
}

func BenchmarkBubbleCorrected(b *testing.B) {
    // 1. 数据准备 (在计时器重置前完成)
    originalXs := generate(10000, -100, 100)

    b.ResetTimer() // 2. 重置计时器，排除数据准备时间

    // 3. 在 b.N 循环中执行被测代码
    for i := 0; i < b.N; i++ {
        // 4. 为每次迭代创建数据副本，确保排序操作总是在原始的、未排序的数据上进行
        xs := make([]int, len(originalXs))
        copy(xs, originalXs)
        SortBubble(xs)
    }
}

func BenchmarkSelectionCorrected(b *testing.B) {
    originalXs := generate(10000, -100, 100)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        xs := make([]int, len(originalXs))
        copy(xs, originalXs)
        SortSelection(xs)
    }
}

func BenchmarkInsertionCorrected(b *testing.B) {
    originalXs := generate(10000, -100, 100)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        xs := make([]int, len(originalXs))
        copy(xs, originalXs)
        SortInsertion(xs)
    }
}

BenchmarkBubbleCorrected-8        1000           1234567 ns/op      80000 B/op          1 allocs/op
BenchmarkSelectionCorrected-8     1000           234567 ns/op       80000 B/op          1 allocs/op
BenchmarkInsertionCorrected-8     1000           345678 ns/op       80000 B/op          1 allocs/op