Golang采用GreenTeaGC与标准GC性能对比测试报告

root@VM-16-14-ubuntu:/data/webp# neofetch
            .-/+oossssoo+/-.               root@VM-16-14-ubuntu 
        `:+ssssssssssssssssss+:`           -------------------- 
      -+ssssssssssssssssssyyssss+-         OS: Ubuntu 24.04.3 LTS x86_64 
    .ossssssssssssssssssdMMMNysssso.       Host: CVM 3.0 
   /ssssssssssshdmmNNmmyNMMMMhssssss/      Kernel: 6.8.0-88-generic 
  +ssssssssshmydMMMMMMMNddddyssssssss+     Uptime: 1 day, 35 mins 
 /sssssssshNMMMyhhyyyyhmNMMMNhssssssss/    Packages: 913 (dpkg), 4 (snap) 
.ssssssssdMMMNhsssssssssshNMMMdssssssss.   Shell: bash 5.2.21 
+sssshhhyNMMNyssssssssssssyNMMMysssssss+   Resolution: 1024x768 
ossyNMMMNyMMhsssssssssssssshmmmhssssssso   Terminal: /dev/pts/0 
ossyNMMMNyMMhsssssssssssssshmmmhssssssso   CPU: AMD EPYC 7K62 (2) @ 2.595GHz 
+sssshhhyNMMNyssssssssssssyNMMMysssssss+   GPU: 00:02.0 Cirrus Logic GD 5446 
.ssssssssdMMMNhsssssssssshNMMMdssssssss.   Memory: 1886MiB / 3659MiB 
 /sssssssshNMMMyhhyyyyhdNMMMNhssssssss/
  +sssssssssdmydMMMMMMMMddddyssssssss+                             
   /ssssssssssshdmNNNNmyNMMMMhssssss/                              
    .ossssssssssssssssssdMMMNysssso.
      -+sssssssssssssssssyyyssss+-
        `:+ssssssssssssssssss+:`
            .-/+oossssoo+/-.

// 执行一次采样
func (m *GCMonitor) sample() {
    m.sampleCount++
    now := time.Now()
    sinceStart := now.Sub(m.startTime)

    // 读取当前GC统计
    var currentGCStats debug.GCStats
    debug.ReadGCStats(&currentGCStats)

    // 读取内存统计
    var memStats runtime.MemStats
    runtime.ReadMemStats(&memStats)

    // 计算增量
    gcDelta := calculateGCDelta(&m.lastGCStats, &currentGCStats)
    timeDelta := now.Sub(m.lastSample).Seconds()

    // 计算 CPU 指标
    cpuMetrics := m.calculateCPUMetrics(timeDelta)

    // 构建指标快照
    snapshot := MetricSnapshot{
        Timestamp:    now,
        SinceStart:   formatDuration(sinceStart),
        SampleNumber: m.sampleCount,
        GCStats:      m.extractGCMetrics(&currentGCStats, &gcDelta, timeDelta),
        MemStats:     m.extractMemoryMetrics(&memStats),
        NumGoroutine: runtime.NumGoroutine(),
        NumCPU:       runtime.NumCPU(),
        CPUMetrics:   cpuMetrics,
    }

    // 写入日志和JSON
    m.writeToLog(&snapshot)
    if m.config.EnableJSON {
        m.writeToJSON(&snapshot)
    }

    // 更新上次数据
    m.lastGCStats = currentGCStats
    m.lastSample = now
}

// 提取GC指标
func (m *GCMonitor) extractGCMetrics(stats *debug.GCStats, delta *GCDelta, timeDelta float64) GCMetrics {
    metrics := GCMetrics{
        NumGC:      uint32(stats.NumGC),
        NumGCDelta: delta.NumGC,
        PauseTotal: float64(stats.PauseTotal) / 1e6, // 转换为毫秒
        PauseDelta: delta.PauseTotal / 1e6,
    }

    // 计算平均暂停时间
    if stats.NumGC > 0 {
        metrics.PauseAvg = metrics.PauseTotal / float64(stats.NumGC)
    }

    if delta.NumGC > 0 {
        metrics.PauseDeltaAvg = metrics.PauseDelta / float64(delta.NumGC)
    }

    // 最近一次暂停
    if len(stats.Pause) > 0 {
        metrics.LastPause = float64(stats.Pause[0]) / 1e6
    }

    // GC频率
    if timeDelta > 0 {
        metrics.GCRate = float64(delta.NumGC) / timeDelta
    }

    return metrics
}

// 计算GC增量
func calculateGCDelta(last, current *debug.GCStats) GCDelta {
    delta := GCDelta{
        NumGC:      0,
        PauseTotal: 0,
    }

    if current.NumGC > last.NumGC {
        delta.NumGC = uint32(current.NumGC - last.NumGC)
        delta.PauseTotal = float64(current.PauseTotal - last.PauseTotal)
    }

    return delta
}

// 提取内存指标
func (m *GCMonitor) extractMemoryMetrics(stats *runtime.MemStats) MemoryMetrics {
    return MemoryMetrics{
        HeapAlloc:    stats.HeapAlloc / 1024 / 1024,    // 当前堆分配
        HeapSys:      stats.HeapSys / 1024 / 1024,      // 堆系统内存
        HeapInuse:    stats.HeapInuse / 1024 / 1024,    // 堆正在使用
        HeapIdle:     stats.HeapIdle / 1024 / 1024,     // 堆空闲
        HeapReleased: stats.HeapReleased / 1024 / 1024, // 已归还系统
        TotalAlloc:   stats.TotalAlloc / 1024 / 1024,   // 总分配量
        Sys:          stats.Sys / 1024 / 1024,          // 系统内存
        NextGC:       stats.NextGC / 1024 / 1024,       // 下次GC阈值
        NumObjects:   stats.Mallocs - stats.Frees,      // 当前对象数
        StackInuse:   stats.StackInuse / 1024 / 1024,   // 栈使用
        StackSys:     stats.StackSys / 1024 / 1024,     // 栈系统内存
    }
}

func (m *CPUMonitor) getCPUTime() (userTime, sysTime float64) {
    var rusage syscall.Rusage
    if err := syscall.Getrusage(syscall.RUSAGE_SELF, &rusage); err != nil {
        return 0, 0
    }
    
    userSec := float64(rusage.Utime.Sec) + float64(rusage.Utime.Usec)/1e6
    sysSec := float64(rusage.Stime.Sec) + float64(rusage.Stime.Usec)/1e6
    
    return userSec, sysSec
}

func (m *CPUMonitor) GetUsage() (totalPercent, userPercent, sysPercent float64) {
    currentUser, currentSys := m.getCPUTime()
    currentTotal := currentUser + currentSys
    now := time.Now()
    
    if !m.lastUpdate.IsZero() {
        elapsed := now.Sub(m.lastUpdate).Seconds()
        if elapsed > 0 {
            // CPU时间增量
            userDelta := currentUser - m.lastUserTime
            sysDelta := currentSys - m.lastSysTime
            totalDelta := userDelta + sysDelta
            
            // CPU使用率 = CPU时间增量 / 实际时间 * 100
            totalPercent = (totalDelta / elapsed) * 100
            userPercent = (userDelta / elapsed) * 100
            sysPercent = (sysDelta / elapsed) * 100
        }
    }
    
    m.lastUserTime = currentUser
    m.lastSysTime = currentSys
    m.lastTotalTime = currentTotal
    m.lastUpdate = now
    
    return
}

func (m *GCMonitor) writeToLog(snapshot *MetricSnapshot) {
    line := fmt.Sprintf(
        "[%s] [%10s] #%-4d | GC: %5d (+%-2d) Pause: %8.2fms (+%6.2fms / avg %5.2fms) Rate: %.2f/s | Mem: Heap %5dMB | CPU: %.1f%% | Goroutine: %5d\n",
        snapshot.Timestamp.Format("15:04:05"),
        snapshot.SinceStart,
        snapshot.SampleNumber,
        snapshot.GCStats.NumGC,
        snapshot.GCStats.NumGCDelta,
        snapshot.GCStats.PauseTotal,
        snapshot.GCStats.PauseDelta,
        snapshot.GCStats.PauseDeltaAvg,
        snapshot.GCStats.GCRate,
        snapshot.MemStats.HeapAlloc,
        snapshot.CPUMetrics.TotalUsage,
        snapshot.NumGoroutine,
    )
    
    m.logFile.WriteString(line)
    m.logFile.Sync()
}

// 指标快照
type MetricSnapshot struct {
    Timestamp    time.Time     // 采样时间
    SinceStart   string        // 距启动时间
    SampleNumber int           // 采样序号
    GCStats      GCMetrics     // GC统计
    MemStats     MemoryMetrics // 内存统计
    NumGoroutine int           // Goroutine数量
    NumCPU       int           // CPU核心数
    CPUMetrics   CPUMetrics    // CPU指标
}

// GC指标
type GCMetrics struct {
    NumGC         uint32  // 总GC次数
    NumGCDelta    uint32  // 本周期GC次数
    PauseTotal    float64 // 总暂停时间(ms)
    PauseDelta    float64 // 本周期暂停时间(ms)
    PauseAvg      float64 // 平均暂停时间(ms)
    PauseDeltaAvg float64 // 本周期平均暂停(ms)
    LastPause     float64 // 最近一次暂停(ms)
    GCRate        float64 // GC频率(次/秒)
}

// 内存指标
type MemoryMetrics struct {
    HeapAlloc    uint64 // 堆分配(MB)
    HeapSys      uint64 // 堆系统内存(MB)
    HeapInuse    uint64 // 堆正在使用(MB)
    HeapIdle     uint64 // 堆空闲(MB)
    HeapReleased uint64 // 已归还系统(MB)
    TotalAlloc   uint64 // 总分配(MB)
    Sys          uint64 // 系统内存(MB)
    NextGC       uint64 // 下次GC阈值(MB)
    NumObjects   uint64 // 对象数量
    StackInuse   uint64 // 栈使用(MB)
    StackSys     uint64 // 栈系统内存(MB)
}

// CPU指标
type CPUMetrics struct {
    TotalUsage float64 // 总CPU使用率(%)
}