使用Go语言实现benchmark解析器

更新时间：2025年04月11日 08:50:30 作者：唐青枫

这篇文章主要为大家详细介绍了如何使用Go语言实现benchmark解析器并实现及Web UI 数据可视化,文中的示例代码讲解详细,需要的小伙伴可以参考一下

简介

用 Go 编写的 benchmark 输出解析器，功能如下

读取 go test -bench=. -benchmem 的输出文件（如 benchmark.txt）
解析出每行数据
写入成 CSV 文件（如 benchmark.csv）
Web UI 可视化数据

仅Go解析器

package main

import (
	"bufio"
	"encoding/csv"
	"fmt"
	"os"
	"regexp"
)

type BenchmarkResult struct {
	Name        string
	Runs        string
	NsPerOp     string
	BytesPerOp  string
	AllocsPerOp string
}

func main() {
	inputFile := "benchmark.txt"
	outputFile := "benchmark.csv"

	file, err := os.Open(inputFile)
	if err != nil {
		fmt.Println("读取文件失败:", err)
		return
	}
	defer file.Close()

	// 匹配 benchmark 输出行
	re := regexp.MustCompile(`^Benchmark(\w+)-\d+\s+(\d+)\s+(\d+)\s+ns/op\s+(\d+)\s+B/op\s+(\d+)\s+allocs/op`)

	var results []BenchmarkResult

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		matches := re.FindStringSubmatch(line)
		if len(matches) == 6 {
			results = append(results, BenchmarkResult{
				Name:        matches[1],
				Runs:        matches[2],
				NsPerOp:     matches[3],
				BytesPerOp:  matches[4],
				AllocsPerOp: matches[5],
			})
		}
	}

	if err := scanner.Err(); err != nil {
		fmt.Println("读取行失败:", err)
		return
	}

	// 写入 CSV
	outFile, err := os.Create(outputFile)
	if err != nil {
		fmt.Println("创建 CSV 文件失败:", err)
		return
	}
	defer outFile.Close()

	writer := csv.NewWriter(outFile)
	defer writer.Flush()

	headers := []string{"name", "runs", "ns_per_op", "bytes_per_op", "allocs_per_op"}
	if err := writer.Write(headers); err != nil {
		fmt.Println("写入 CSV 头失败:", err)
		return
	}

	for _, r := range results {
		row := []string{r.Name, r.Runs, r.NsPerOp, r.BytesPerOp, r.AllocsPerOp}
		if err := writer.Write(row); err != nil {
			fmt.Println("写入行失败:", err)
			return
		}
	}

	fmt.Println("✅ 成功导出 CSV:", outputFile)
}

使用方法

保存为 main.go

编译运行：

go run main.go

或编译为可执行文件：

go build -o benchparser
./benchparser

确保 benchmark.txt 在同目录，输出会生成 benchmark.csv。

使用 Web UI 可视化数据

功能需求

支持输入：
- 从 benchmark.txt 文件读取
- 从标准输入读取（如管道输入）
解析 go test -bench=. -benchmem 输出
提供一个 Web UI：
- 显示 ns/op、B/op、allocs/op 的柱状图
- 支持切换不同维度视图

项目结构设计（Go + HTML + JS）

benchmark-visualizer/
├── main.go ← 启动解析器 + Web Server
├── static/
│ ├── index.html ← Web 页面
│ ├── chart.js ← Chart.js 库
│ └── main.js ← 渲染图表的 JS 脚本

Go 服务器（main.go）

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"regexp"
)

type BenchmarkResult struct {
	Name        string `json:"name"`
	Runs        int    `json:"runs"`
	NsPerOp     float64`json:"ns_per_op"`
	BytesPerOp  int    `json:"bytes_per_op"`
	AllocsPerOp int    `json:"allocs_per_op"`
}

var results []BenchmarkResult

func parseBenchmark(input *os.File) ([]BenchmarkResult, error) {
	re := regexp.MustCompile(`^(Benchmark\S*)\s+(\d+)\s+([\d\.]+)\s+ns/op\s+(\d+)\s+B/op\s+(\d+)\s+allocs/op`)
	scanner := bufio.NewScanner(input)
	var parsed []BenchmarkResult

	for scanner.Scan() {
		line := scanner.Text()
        matches := re.FindStringSubmatch(line)
        if len(matches) == 6 {
            var r BenchmarkResult
            r.Name = matches[1]
            fmt.Sscanf(matches[2], "%d", &r.Runs)
            fmt.Sscanf(matches[3], "%f", &r.NsPerOp)
            fmt.Sscanf(matches[4], "%d", &r.BytesPerOp)
            fmt.Sscanf(matches[5], "%d", &r.AllocsPerOp)
            parsed = append(parsed, r)
        }
	}

	return parsed, scanner.Err()
}

func dataHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(results)
}

func main() {
	// 判断是否有标准输入
	stat, _ := os.Stdin.Stat()
	var err error

	if (stat.Mode() & os.ModeCharDevice) == 0 {
		// 从标准输入读取
		results, err = parseBenchmark(os.Stdin)
	} else {
		// 默认读取 benchmark.txt 文件
		file, err := os.Open("benchmark.txt")
		if err != nil {
			fmt.Println("打开 benchmark.txt 失败:", err)
			return
		}
		defer file.Close()
		results, err = parseBenchmark(file)
	}

	if err != nil {
		fmt.Println("解析失败:", err)
		return
	}

	fs := http.FileServer(http.Dir("./static"))
	http.Handle("/", fs)
	http.HandleFunc("/data", dataHandler)

	fmt.Println("🚀 服务器已启动：http://localhost:8080")
	http.ListenAndServe(":8080", nil)
}

Web 页面（static/index.html）

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>Go Benchmark 可视化</title>
  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
  <script src="main.js" defer></script>
</head>
<body>
  <h2>Go Benchmark 可视化结果</h2>
  <select id="metric-select">
    <option value="ns_per_op">ns/op</option>
    <option value="bytes_per_op">B/op</option>
    <option value="allocs_per_op">allocs/op</option>
  </select>
  <canvas id="benchmarkChart" width="900" height="500"></canvas>
</body>
</html>

Chart 渲染脚本（static/main.js）

let chart;
const ctx = document.getElementById('benchmarkChart').getContext('2d');

function renderChart(data, metric = "ns_per_op") {
  const labels = data.map(item => item.name);
  const values = data.map(item => item[metric]);

  if (chart) chart.destroy();

  chart = new Chart(ctx, {
    type: 'bar',
    data: {
      labels: labels,
      datasets: [{
        label: metric,
        data: values,
        backgroundColor: 'rgba(54, 162, 235, 0.6)'
      }]
    },
    options: {
      scales: {
        y: {
          beginAtZero: true
        }
      }
    }
  });
}

fetch('/data')
  .then(res => res.json())
  .then(data => {
    renderChart(data);
    document.getElementById('metric-select').addEventListener('change', (e) => {
      renderChart(data, e.target.value);
    });
  });

运行方式

方法 1：从文件读取

go run main.go
# 或
go build -o benchvis && ./benchvis

方法 2：从标准输入读取

go test -bench=. -benchmem | go run main.go

然后访问：http://localhost:8080

效果如图：

benchmark.txt文件示例

goos: darwin
goarch: arm64
pkg: echo
cpu: Apple M1
BenchmarkEchoAll1-8    271656   4631 ns/op   21080 B/op   99 allocs/op
BenchmarkEchoAll2-8    224186   5874 ns/op   31560 B/op   99 allocs/op
BenchmarkEchoAll3-8    1273263   836.1 ns/op   640 B/op   1 allocs/op
BenchmarkEchoAll4-8    1457311   809.8 ns/op   1912 B/op   8 allocs/op
PASS
ok     echo   9.128s

到此这篇关于使用Go语言实现benchmark解析器和Web UI数据可视化的文章就介绍到这了,更多相关Go benchmark解析内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

go
benchmark

使用Golang实现加权负载均衡算法的实现代码
这篇文章主要介绍了使用Golang实现加权负载均衡算法的实现代码,详细说明权重转发算法的实现，通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-09-09
Go Resiliency库中timeout实现原理及源码解析
Go-Resiliency库中的timeout是一种基于协程的超时机制，通过创建协程来执行任务并设置超时时间，若任务执行时间超时则中止协程并返回错误，需要详细了解可以参考下文
2023-05-05
Go关键字defer的使用和底层实现
defer是Go语言的关键字,一般用于资源的释放和异常的捕捉,defer语句后将其后面跟随的语句进行延迟处理,就是说在函数执行完毕后再执行调用,也就是return的ret指令之前,本文给大家介绍了Go关键字defer的使用和底层实现,需要的朋友可以参考下
2023-11-11
Golang 实现简单随机负载均衡
均衡算法又分为随机，轮询，加权轮询，哈希，而随机负载均衡算法就是本文的重点，需要的朋友们下面随着小编来一起学习学习吧
2021-06-06
Golang实现短网址/短链服务的开发笔记分享
这篇文章主要为大家详细介绍了如何使用Golang实现短网址/短链服务，文中的示例代码讲解详细，具有一定的学习价值，感兴趣的小伙伴可以了解一下
2023-05-05
利用dep代替go get获取私有库的方法教程
go get 从指定源上面下载或者更新指定的代码和依赖，并对他们进行编译和安装，但go get功能比较差，所以下面这篇文章主要给大家介绍了关于利用dep代替go get获取私有库的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。
2017-11-11
golang 如何用反射reflect操作结构体
这篇文章主要介绍了golang 用反射reflect操作结构体的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2021-04-04
Win10系统下Golang环境搭建全过程
在编程语言的选取上,越来越多的人选择了Golang,下面这篇文章主要给大家介绍了关于Win10系统下Golang环境搭建的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下
2024-01-01
浅析go逆向符号恢复
这篇文章主要介绍了go逆向符号恢复的相关知识,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
2023-08-08
go实现冒泡排序的示例代码
这篇文章主要介绍了go实现冒泡排序的示例代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2021-01-01