Go 性能基准测试：理解 testing.B 的正确用法与实践

package child_sort

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

// generate 函数用于生成随机整数切片
func generate(size int, min, max int) []int {
    // 注意：在基准测试中，rand.Seed 应避免在每次调用时都用 time.Now() 重新播种
    // 更好的做法是在包初始化时播种一次，或使用固定种子以保证测试可复现性。
    // 这里为了示例，暂时保留用户原代码结构，但在实际应用中需注意。
    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
}

// 示例排序函数（此处省略具体实现，假设已定义 SortBubble, SortSelection, SortInsertion）
// func SortBubble(xs []int) { /* ... */ }
// func SortSelection(xs []int) { /* ... */ }
// func SortInsertion(xs []int) { /* ... */ }

func BenchmarkBubble(b *testing.B) {
    xs := generate(10000, -100, 100)
    /* b.ResetTimer() */ // 注释掉的行
    SortBubble(xs)
}

func BenchmarkSelection(b *testing.B) {
    xs := generate(10000, -100, 100)
    /* b.ResetTimer() */ // 注释掉的行
    SortSelection(xs)
}

func BenchmarkInsertion(b *testing.B) {
    xs := generate(10000, -100, 100)
    /* b.ResetTimer() */ // 注释掉的行
    SortInsertion(xs)
}

BenchmarkSelection  1000000000           0.60 ns/op        0 B/op          0 allocs/op

package child_sort

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

// generate 函数：优化 rand.Seed 的使用
// 在基准测试中，通常将 rand.Source 的初始化放在基准测试函数外部，
// 或者使用一个固定种子，以确保每次基准测试运行的数据分布一致。
var globalRand *rand.Rand

func init() {
    source := rand.NewSource(time.Now().UTC().UnixNano())
    globalRand = rand.New(source)
}

func generate(size int, min, max int) []int {
    xs := make([]int, size)
    for i := range xs {
        xs[i] = min + globalRand.Intn(max-min)
    }
    return xs
}

// 假设 SortSelection, SortBubble, SortInsertion 函数已定义
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 BenchmarkBubbleCorrect(b *testing.B) {
    // 1. 准备初始的未排序切片（模板数据），只执行一次
    initialXs := generate(10000, -100, 100)

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

    // 3. 循环 b.N 次，执行待测函数
    for i := 0; i < b.N; i++ {
        // 4. 重要：每次迭代都需提供一份新的、未排序的数据副本
        // 因为排序算法会修改原始切片，如果直接使用 initialXs，
        // 后续迭代将对已排序的切片进行操作，导致结果失真。
        dataToSort := make([]int, len(initialXs))
        copy(dataToSort, initialXs)

        SortBubble(dataToSort) // 5. 调用待测函数
    }
}

func BenchmarkSelectionCorrect(b *testing.B) {
    initialXs := generate(10000, -100, 100)

    b.ResetTimer()

    for i := 0; i < b.N; i++ {
        dataToSort := make([]int, len(initialXs))
        copy(dataToSort, initialXs)
        SortSelection(dataToSort)
    }
}

func BenchmarkInsertionCorrect(b *testing.B) {
    initialXs := generate(10000, -100, 100)

    b.ResetTimer()

    for i := 0; i < b.N; i++ {
        dataToSort := make([]int, len(initialXs))
        copy(dataToSort, initialXs)
        SortInsertion(dataToSort)
    }
}

go test --bench . --benchmem