Go语言Map Range操作的性能分析与基准测试最佳实践

$ go run map.go 425984 1 425985
    273578 wps ::   18488800 rps
    227909 wps ::    1790311 rps

package main

import (
    "bytes"
    "fmt"
    "math/rand"
    "runtime"
    "strconv"
    "testing"
    "time"
)

// randomString 辅助函数，用于生成随机字符串
func randomString(n int) string {
    var b bytes.Buffer
    for i := 0; i < n; i++ {
        b.WriteByte(byte(0x61 + rand.Intn(26)))
    }
    return b.String()
}

// prepareKeys 预生成指定数量的随机键
func prepareKeys(count int64) []string {
    keys := make([]string, count)
    for i := int64(0); i < count; i++ {
        keys[i] = randomString(16)
    }
    return keys
}

// BenchmarkMapWrite 测试Map写入性能
func BenchmarkMapWrite(b *testing.B) {
    // 预生成所有键，确保这部分时间不计入基准测试
    keys := prepareKeys(int64(b.N)) // b.N 是基准测试框架确定的迭代次数

    b.ResetTimer() // 重置计时器，排除准备工作时间
    for i := 0; i < b.N; i++ {
        m := make(map[string]int64)
        m[keys[i]]++ // 测量单个写入操作
    }
}

// BenchmarkMapRange 测试Map遍历性能
func BenchmarkMapRange(b *testing.B) {
    // 准备一个足够大的Map用于遍历测试
    const mapSize = 100000 // 假设我们要测试10万个元素的Map
    keys := prepareKeys(mapSize)
    m := make(map[string]int64, mapSize)
    for _, k := range keys {
        m[k]++
    }

    b.ResetTimer() // 重置计时器，排除Map初始化和填充时间
    for i := 0; i < b.N; i++ {
        // 每次迭代都遍历整个Map
        totalInMap := int64(0)
        for _, v := range m {
            if v != 0 { // 避免编译器优化掉整个循环
                totalInMap++
            }
        }
        _ = totalInMap // 避免未使用变量警告
    }
}

// BenchmarkMapRangeWithGC 演示如何通过控制GC来观察性能
func BenchmarkMapRangeWithGC(b *testing.B) {
    const mapSize = 100000
    keys := prepareKeys(mapSize)
    m := make(map[string]int64, mapSize)
    for _, k := range keys {
        m[k]++
    }

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        // 在每次迭代前强制进行垃圾回收，以最小化GC对当前迭代的影响
        runtime.GC() 

        totalInMap := int64(0)
        for _, v := range m {
            if v != 0 {
                totalInMap++
            }
        }
        _ = totalInMap
    }
}

// 为了兼容原始的runNTimes函数，这里提供一个非测试版本，但建议使用testing包
func perSecond(end time.Time, start time.Time, n int64) float64 {
    return float64(n) / end.Sub(start).Seconds()
}

func runNTimes(n int64) {
    m := make(map[string]int64)
    keys := prepareKeys(n) // 预生成键

    startAdd := time.Now()
    for _, k := range keys { // 使用预生成的键
        m[k]++
    }
    endAdd := time.Now()

    totalInMap := int64(0)
    startRead := time.Now()
    for _, v := range m {
        if v != 0 {
            totalInMap++
        } 
    }
    endRead := time.Now()

    fmt.Printf("%10.0f wps :: %10.0f rps (Map size: %d)\n",
        perSecond(endAdd, startAdd, n),
        perSecond(endRead, startInMap, totalInMap),
        n,
    )
}

func main() {
    // 示例：如何调用非测试版本的runNTimes
    // 假设通过命令行参数传递 start, step, end
    if len(os.Args) > 3 {
        start, _ := strconv.ParseInt(os.Args[1], 10, 64)
        step, _ := strconv.ParseInt(os.Args[2], 10, 64)
        end, _ := strconv.ParseInt(os.Args[3], 10, 64)
        for n := start; n <= end; n += step {
            runNTimes(n)
        }
    } else {
        fmt.Println("Usage: go run your_program.go <start_size> <step_size> <end_size>")
        fmt.Println("For proper benchmarking, use 'go test -bench=.'")
    }
}

go test -bench=. -benchmem