Go语言性能优化建议与pprof性能调优详解——结合博客项目实战

文章目录

  • 性能优化建议
    • Benchmark的使用
    • slice优化
      • 预分配内存
      • 大内存未释放
    • map优化
    • 字符串处理优化
    • 结构体优化
    • atomic包
    • 小结
  • pprof性能调优
    • 采集性能数据
    • 服务型应用
    • go tool pprof命令
    • 项目调优分析
      • 修改`main.go`
      • 安装go-wrk
      • 命令行交互界面
      • 图形化
      • 火焰图

性能优化建议

简介:

  • 性能优化的前提是满足正确可靠、简洁清晰等质量因素
  • 性能优化是综合评估,有时候时间效率和空间效率可能对立
  • 针对Go语言特性,介绍Go相关的性能优化建议

Benchmark的使用

性能表现需要实际数据衡量,Go语言提供了支持基准性能测试的benchmark工具。

示例:

//fib.go
package mainfunc Fib(n int) int {if n < 2 {return n}return Fib(n-1) + Fib(n-2)
}
//fib_test.go
package mainimport ("testing"
)func BenchmarkFib10(b *testing.B) {for i := 0; i < b.N; i++ {Fib(10)}
}
  • benchmark 和普通的单元测试用例一样,都位于 _test.go 文件中。
  • 函数名以 Benchmark 开头,参数是 b *testing.B。和普通的单元测试用例很像,单元测试函数名以 Test 开头,参数是 t *testing.T

运行示例:

  • 运行当前 package 内的用例:go test .
  • 运行子 package 内的用例: go test ./<package name>
  • 如果想递归测试当前目录下的所有的 package:go test ./...

go test 命令默认不运行 benchmark 用例的,如果我们想运行 benchmark 用例,需要加上 -bench 参数。例如:

$ go test -bench .
goos: windows
goarch: amd64
pkg: GoProject1
cpu: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz
BenchmarkFib10-16        5496252               212.5 ns/op
PASS
ok      GoProject1      1.454s
  1. goos: windows:这行显示运行基准测试的操作系统,此处为 Windows。
  2. goarch: amd64:这行显示运行基准测试的机器架构,此处为 64 位 AMD 架构。
  3. pkg: GoProject1:这行显示包含基准测试代码的包名,此处为 “GoProject1”。
  4. cpu: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz:这行显示运行基准测试的机器 CPU 信息,包括 CPU 型号和时钟频率。
  5. PASS:这行表示所有的测试,包括基准测试,都已成功通过。
  6. ok GoProject1 1.454s:这行显示所有测试,包括基准测试,的整体执行时间。在这种情况下,整个测试套件执行时间大约为 1.454 秒。

BenchmarkFib10-16 是测试函数名,-16表示GOMAXPROCS的值为16,GOMAXPROCS 1.5版本后,默认值为CPU核数 。5496252 表示一共执行5496252 次,即b.N的值。212.5 ns/op表示每次执行花费212.5ns

slice优化

预分配内存

接下来看两个函数:

func NoPreAlloc(size int) {data := make([]int, 0)for k := 0; k < size; k++ {data = append(data, k)}
}func PreAlloc(size int) {data := make([]int, 0, size)for k := 0; k < size; k++ {data = append(data, k)}
}

分别为它们编写基准测试:

func BenchmarkNoPreAlloc(b *testing.B) {for i := 0; i < b.N; i++ {NoPreAlloc(1000000)}
}func BenchmarkPreAlloc(b *testing.B) {for i := 0; i < b.N; i++ {PreAlloc(1000000)}
}

运行结果如下:

$ go test -bench .
goos: windows
goarch: amd64
pkg: GoProject1
cpu: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz
BenchmarkNoPreAlloc-16               193           5968006 ns/op
BenchmarkPreAlloc-16                1498            825965 ns/op
PASS
ok      GoProject1      3.164s

可以看到预分配内存后,性能更好。因此应尽可能在使用make()初始化切片时提供容量信息。

大内存未释放

当我们在已有切片基础上创建新的切片时,新切片并不会创建一个新的底层数组。相反,它会共享同一个底层数组。这种情况下,如果我们从一个大切片中截取出一个小切片,并且在代码中保留对大切片的引用,那么原底层数组将会一直存在于内存中,得不到释放,即使大切片的内容对我们来说已经不再需要了。

举例说明: 假设有一个名为bigSlice的大切片,其底层数组非常大。然后我们基于bigSlice创建一个新的小切片smallSlice,并且在代码中保留对bigSlice的引用。这样一来,即使我们只使用smallSlice,底层数组也不会被释放,导致占用大量的内存。

优化建议:使用copy替代re-slice 为了避免上述陷阱,我们可以使用copy操作来创建一个新的切片,而不是在已有切片基础上使用re-slice。copy操作会将源切片的内容复制到一个新的底层数组中,这样就不会和原始切片共享底层数组,避免了底层数组无法释放的问题。

示例代码:

goCopy codebigSlice := make([]int, 1000000) // 假设bigSlice是一个非常大的切片
// 使用re-slice,smallSlice和bigSlice共享同一个底层数组
smallSlice := bigSlice[:100] // 使用copy,创建一个新的切片,底层数组得到释放
smallSlice = make([]int, 100)
copy(smallSlice, bigSlice[:100])

通过使用copy操作,我们可以避免因为底层数组无法释放而导致的内存浪费问题。

map优化

示例代码:

func NoPreAlloc(size int) {data := make(map[int]int)for k := 0; k < size; k++ {data[k] = 1}
}func PreAlloc(size int) {data := make(map[int]int, size)for k := 0; k < size; k++ {data[k] = 1}
}
func BenchmarkNoPreAlloc(b *testing.B) {for n := 0; n < b.N; n++ {NoPreAlloc(1000000)}
}func BenchmarkPreAlloc(b *testing.B) {for n := 0; n < b.N; n++ {PreAlloc(1000000)}
}

运行测试:

$ go test -bench .
goos: windows
goarch: amd64
pkg: GoProject1
cpu: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz
BenchmarkNoPreAlloc-16                12          90044942 ns/op
BenchmarkPreAlloc-16                  26          50461700 ns/op
PASS
ok      GoProject1      2.637s

可以发现map预分配内存后效果更好。

分析:

  • 不断向map中添加元素的操作会触发map的扩容
  • 提前分配好空间可以减少内存拷贝和Rehash的消耗。
  • 建议根据实际需求提前预估好需要的空间

字符串处理优化

使用strings.Builder、预分配内存。

示例代码:

func Plus(n int, str string) string {s := ""for i := 0; i < n; i++ {s += str}return s
}func StrBuilder(n int, str string) string {var builder strings.Builderfor i := 0; i < n; i++ {builder.WriteString(str)}return builder.String()
}func ByteBuffer(n int, str string) string {buf := new(bytes.Buffer)for i := 0; i < n; i++ {buf.WriteString(str)}return buf.String()
}func PreStrBuilder(n int, str string) string {var builder strings.Builderbuilder.Grow(n * len(str))for i := 0; i < n; i++ {builder.WriteString(str)}return builder.String()
}
func PreStrByteBuffer(n int, str string) string {buf := new(bytes.Buffer)buf.Grow(n * len(str))for i := 0; i < n; i++ {buf.WriteString(str)}return buf.String()
}
func BenchmarkPlus(b *testing.B) {for i := 0; i < b.N; i++ {Plus(100000, "wxy")}
}func BenchmarkStrBuilder(b *testing.B) {for i := 0; i < b.N; i++ {StrBuilder(100000, "wxy")}
}func BenchmarkByteBuffer(b *testing.B) {for i := 0; i < b.N; i++ {ByteBuffer(100000, "wxy")}
}func BenchmarkPreStrBuilder(b *testing.B) {for i := 0; i < b.N; i++ {PreStrBuilder(100000, "wxy")}
}func BenchmarkPreByteBuffer(b *testing.B) {for i := 0; i < b.N; i++ {PreStrByteBuffer(100000, "wxy")}
}

运行结果:

$ go test -bench .
goos: windows
goarch: amd64
pkg: GoProject1
cpu: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz
BenchmarkPlus-16                       1        1126084200 ns/op
BenchmarkStrBuilder-16              3982            284773 ns/op
BenchmarkByteBuffer-16              2947            485091 ns/op
BenchmarkPreStrBuilder-16           4771            278961 ns/op
BenchmarkPreByteBuffer-16           3310            364676 ns/op
PASS
ok      GoProject1      6.457s
  • 使用拼接性能最差,strings.Builderbytes.Buffer相近,strings.Builder更快
  • 字符串在Go语言中是不可变类型,占用内存大小是固定的
  • 使用每次都会重新分配内存
  • strings.Builderbytes.Buffer底层都是[]byte数组。内存扩容策略,不需要每次拼接重新分配内存
  • 预分配内存后,strings.Builderbytes.Buffer性能都有所提升

结构体优化

示例代码:

func EmptyStructMap(n int) {m := make(map[int]struct{})for i := 0; i < n; i++ {m[i] = struct{}{}}
}
func BoolMap(n int) {m := make(map[int]bool)for i := 0; i < n; i++ {m[i] = false}
}
func BenchmarkEmptyStructMap(b *testing.B) {for i := 0; i < b.N; i++ {EmptyStructMap(100000000)}
}func BenchmarkBoolMap(b *testing.B) {for i := 0; i < b.N; i++ {BoolMap(100000000)}
}

执行结果:

$ go test -bench .
goos: windows
goarch: amd64
pkg: GoProject1
cpu: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz
BenchmarkEmptyStructMap-16             1        13943515100 ns/op
BenchmarkBoolMap-16                    1        14002905100 ns/op
PASS
ok      GoProject1      28.215s

可以发现使用空结构体性能较好。

使用空结构体节省内存:

  • 空结构体struct{}实例不占据任何的内存空间
  • 可作为各种场景下的占位符使用
  • 节省资源
  • 空结构体本身具备很强的语义,即这里不需要任何值,仅作为占位符

atomic包

示例代码:

type atomicCounter struct {i int32
}func AtomicAddOne(c *atomicCounter) {atomic.AddInt32(&c.i, 1)
}type mutexCounter struct {i int32m sync.Mutex
}func MutexAddOne(c *mutexCounter) {c.m.Lock()c.i++c.m.Unlock()
}
func BenchmarkAtomicAddOne(b *testing.B) {var c atomicCounterb.ResetTimer()for i := 0; i < b.N; i++ {AtomicAddOne(&c)}
}func BenchmarkMutexAddOne(b *testing.B) {var c mutexCounterb.ResetTimer()for i := 0; i < b.N; i++ {MutexAddOne(&c)}
}

运行结果:

$ go test -bench .
goos: windows
goarch: amd64
pkg: GoProject1
cpu: 11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz
BenchmarkAtomicAddOne-16        255736488                4.565 ns/op
BenchmarkMutexAddOne-16         99685160                13.66 ns/op
PASS
ok      GoProject1      3.101s

使用atomic包:

  • 锁的实现是通过操作系统来实现,属于系统调用
  • atomic操作是通过硬件实现,效率比锁高
  • sync.Mutex应该用来保护一段逻辑,不仅仅用于保护一个变量
  • 对于非数值操作,可以使用atomic.Value,能承载一个interface{}

小结

  • 避免常见的性能陷阱可以保证大部分程序的性能
  • 普通应用代码,不要一味地追求程序的性能
  • 越高级的性能优化手段越容易出现问题
  • 在满足正确可靠、简洁清晰的质量要求的前提下提高程序性能

pprof性能调优

在计算机性能调试领域里,profiling 是指对应用程序的画像,画像就是应用程序使用 CPU 和内存的情况。 Go语言是一个对性能特别看重的语言,因此语言中自带了 profiling 的库。

Go语言项目中的性能优化主要有以下几个方面:

  • CPU profile:报告程序的 CPU 使用情况,按照一定频率去采集应用程序在 CPU 和寄存器上面的数据
  • Memory Profile(Heap Profile):报告程序的内存使用情况
  • Block Profiling:报告 goroutines 不在运行状态的情况,可以用来分析和查找死锁等性能瓶颈
  • Goroutine Profiling:报告 goroutines 的使用情况,有哪些 goroutine,它们的调用关系是怎样的

采集性能数据

Go语言内置了获取程序的运行数据的工具,包括以下两个标准库:

  • runtime/pprof:采集工具型应用运行数据进行分析
  • net/http/pprof:采集服务型应用运行时数据进行分析

pprof开启后,每隔一段时间(10ms)就会收集下当前的堆栈信息,获取各个函数占用的CPU以及内存资源;最后通过对这些采样数据进行分析,形成一个性能分析报告。

注意,我们只应该在性能测试的时候才在代码中引入pprof。

本篇文章只对服务型应用进行性能分析。

服务型应用

如果你的应用程序是一直运行的,比如 web 应用,那么可以使用net/http/pprof库,它能够在提供 HTTP 服务进行分析。

如果使用了默认的http.DefaultServeMux(通常是代码直接使用 http.ListenAndServe(“0.0.0.0:8000”, nil)),只需要在你的web server端代码中按如下方式导入net/http/pprof

import _ "net/http/pprof"

如果你使用自定义的 Mux,则需要手动注册一些路由规则:

r.HandleFunc("/debug/pprof/", pprof.Index)
r.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
r.HandleFunc("/debug/pprof/profile", pprof.Profile)
r.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
r.HandleFunc("/debug/pprof/trace", pprof.Trace)

如果你使用的是gin框架,那么推荐使用github.com/gin-contrib/pprof,在代码中通过以下命令注册pprof相关路由。

pprof.Register(router)

不管哪种方式,你的 HTTP 服务都会多出http://host:port/debug/pprof ,访问它会得到类似下面的内容:

这个路径下还有几个子页面:

  • /debug/pprof/profile:访问这个链接会自动进行 CPU profiling,持续 30s,并生成一个文件供下载
  • /debug/pprof/heap: Memory Profiling 的路径,访问这个链接会得到一个内存 Profiling 结果的文件
  • /debug/pprof/block:block Profiling 的路径
  • /debug/pprof/goroutines:运行的 goroutines 列表,以及调用关系

下面是详细的解释:

Allocs: 过去所有内存分配的抽样

Block: 导致同步原语阻塞的堆栈跟踪

Cmdline: 当前程序的命令行调用

Goroutine: 所有当前 goroutine 的堆栈跟踪。使用 debug = 2作为查询参数,以与未恢复的惊慌相同的格式导出。

Heap: 活动对象的内存分配的抽样。在获取堆示例之前,可以指定 gc GET 参数来运行 GC。

Mutex: 对争用的互斥对象的持有者进行跟踪堆栈

profile: CPU 配置文件。可以在秒 GET 参数中指定持续时间。获得概要文件之后,使用 go 工具 pprof 命令调查概要文件。

Threadcreate: 导致创建新操作系统线程的堆栈跟踪

Trace: 当前程序执行的跟踪。可以在秒 GET 参数中指定持续时间。获得跟踪文件后,使用 go tool trace 命令调查跟踪。

go tool pprof命令

不管是工具型应用还是服务型应用,我们使用相应的pprof库获取数据之后,下一步的都要对这些数据进行分析,我们可以使用go tool pprof命令行工具。

go tool pprof最简单的使用方式为:

go tool pprof [binary] [source]

其中:

  • binary 是应用的二进制文件,用来解析各种符号;
  • source 表示 profile 数据的来源,可以是本地的文件,也可以是 http 地址。

注意事项: 获取的 Profiling 数据是动态的,要想获得有效的数据,请保证应用处于较大的负载(比如正在生成中运行的服务,或者通过其他工具模拟访问压力)。否则如果应用处于空闲状态,得到的结果可能没有任何意义。

项目调优分析

本案例使用了blob项目——类似博客的管理系统,用beego实现,源码我已经放到了github仓库里:https://github.com/uestc-wxy/blob,里面也有详细的使用说明。

修改main.go

为了能对这个项目进行调优分析,需要在main.go文件里添加几行代码:

import ("net/http"_ "net/http/pprof"
)
go func() {http.ListenAndServe("localhost:8080", nil)}()

下面是修改后的main.go(只需要修改这一个文件):

package mainimport (_ "blob/models"_ "blob/routers""blob/utils""fmt""github.com/beego/beego/v2/client/orm""github.com/beego/beego/v2/server/web"_ "github.com/go-sql-driver/mysql""net/http"_ "net/http/pprof"
)func init() {username, _ := web.AppConfig.String("username")password, _ := web.AppConfig.String("password")host, _ := web.AppConfig.String("host")port, _ := web.AppConfig.String("port")database, _ := web.AppConfig.String("database")datasource := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&loc=Local", username, password, host, port, database)err := orm.RegisterDataBase("default", "mysql", datasource)if err != nil {fmt.Printf("%v\n", err)}err = orm.RunSyncdb("default", false, true)if err != nil {fmt.Printf("%v\n", err)}}func main() {web.InsertFilter("/cms/index/*", web.BeforeRouter, utils.CmsLoginFilter)orm.RunCommand()go func() {http.ListenAndServe("localhost:8080", nil)}()web.Run()
}

安装go-wrk

为了使数据直观便于分析,需要使用压测工具。

推荐使用:https://github.com/wg/wrk 或 https://github.com/adjust/go-wrk,由于我是Windows系统,于是选择了后者,因为前者对Windows并不是很友好,虽然它的star数还要多些。

GOPATH/src路径终端依次运行下列命令,注意是GOPATH/src

git clone https://github.com/adjust/go-wrk.git
cd go-wrk
go mod init
go mod tidy
go build

这时你会发现go-wrk项目里会多出go-wrk.exe文件,为了方便使用我选择把它放在(也就是复制粘贴过去)GOPATH/bin目录下,当然你得把GOPATH/bin放在环境变量里面,至于为什么将go-wrk.exe放在$GOPATH/bin 里面,这似乎是一种规范。我的其他文章也有提到过。

通过上述操作就可以在任何地方使用go-wrk命令了。

命令行交互界面

首先需要保证我们的项目需要在本地跑起来。在项目根目录终端运行:

go build
./blob

当然也可以使用bee run命令,毕竟这是beego项目特有的运行方式。

然后在该路径下再开一个终端,用来跑压测,执行命令:

go-wrk -n 50000 http://localhost:8080/

执行上面的代码会进入交互界面如下:

(base) PS F:\GolandProjects\beegoProject\blob> go-wrk -n 50000 http://localhost:8080/
==========================BENCHMARK==========================
URL:                            http://localhost:8080/Used Connections:               100
Used Threads:                   1
Total number of calls:          50000===========================TIMINGS===========================
Total time passed:              22.95s
Avg time per request:           45.76ms
Requests per second:            2179.05
Median time per request:        45.14ms
99th percentile time:           53.77ms
Slowest time for request:       119.00ms=============================DATA=============================
Total response body sizes:              251100000
Avg response body per request:          5022.00 Byte
Transfer rate per second:               10943208.24 Byte/s (10.94 MByte/s)
==========================RESPONSES==========================
20X Responses:          50000   (100.00%)
30X Responses:          0       (0.00%)
40X Responses:          0       (0.00%)
50X Responses:          0       (0.00%)
Errors:                 0       (0.00%)

接着再开一个终端,以使用pprof来分析。

执行命令:

go tool pprof http://127.0.0.1:8080/debug/pprof/profile

执行上面的代码会进入交互界面如下:

(base) PS F:\GolandProjects\beegoProject\blob> go tool pprof http://127.0.0.1:8080/debug/pprof/profile
Fetching profile over HTTP from http://127.0.0.1:8080/debug/pprof/profile
Saved profile in C:\Users\19393\pprof\pprof.blob.exe.samples.cpu.004.pb.gz
File: blob.exe
Build ID: F:\GolandProjects\beegoProject\blob\blob.exe2023-08-01 16:06:16.7719208 +0800 CST   
Type: cpu
Time: Aug 1, 2023 at 4:10pm (CST)
Duration: 30s, Total samples = 44.41s (148.02%)
Entering interactive mode (type "help" for commands, "o" for options)
(pprof)

我们可以在交互界面输入top5来查看程序中占用CPU前5位的函数:

(pprof) top5
Showing nodes accounting for 27510ms, 61.95% of 44410ms total
Dropped 859 nodes (cum <= 222.05ms)
Showing top 5 nodes out of 246flat  flat%   sum%        cum   cum%21960ms 49.45% 49.45%    22080ms 49.72%  runtime.cgocall2010ms  4.53% 53.97%     5980ms 13.47%  runtime.scanobject1410ms  3.17% 57.15%     1740ms  3.92%  runtime.greyobject1340ms  3.02% 60.17%     1730ms  3.90%  runtime.findObject790ms  1.78% 61.95%      790ms  1.78%  runtime.stdcall2

其中:

  • flat:当前函数占用CPU的耗时
  • flat::当前函数占用CPU的耗时百分比
  • sun%:函数占用CPU的耗时累计百分比
  • cum:当前函数加上调用当前函数的函数占用CPU的总耗时
  • cum%:当前函数加上调用当前函数的函数占用CPU的总耗时百分比
  • 最后一列:函数名称

我们发现上面并没有我们自己写的函数,所以本项目的性能还是不错的。在大多数的情况下,我们可以通过分析这五列得出一个应用程序的运行情况,并对程序进行优化。

我们还可以使用list 函数名命令查看具体的函数分析,例如执行list cgocall查看我们编写的函数的详细分析。

(pprof) list cgocall
Total: 44.41s
ROUTINE ======================== runtime.cgocall in F:\Users\19393\sdk\go1.20.4\src\runtime\cgocall.go21.96s     22.08s (flat, cum) 49.72% of Total.          .    123:func cgocall(fn, arg unsafe.Pointer) int32 {.          .    124:   if !iscgo && GOOS != "solaris" && GOOS != "illumos" && GOOS != "windows" {.          .    125:           throw("cgocall unavailable").          .    126:   }.          .    127:.          .    128:   if fn == nil {.          .    129:           throw("cgocall nil").          .    130:   }.          .    131:.          .    132:   if raceenabled {.          .    133:           racereleasemerge(unsafe.Pointer(&racecgosync))        .          .    134:   }.          .    135:.          .    136:   mp := getg().m.          .    137:   mp.ncgocall++.          .    138:   mp.ncgo++.          .    139:.          .    140:   // Reset traceback..          .    141:   mp.cgoCallers[0] = 0.          .    142:.          .    143:   // Announce we are entering a system call.          .    144:   // so that the scheduler knows to create another.          .    145:   // M to run goroutines while we are in the.          .    146:   // foreign code..          .    147:   //.          .    148:   // The call to asmcgocall is guaranteed not to.          .    149:   // grow the stack and does not allocate memory,.          .    150:   // so it is safe to call while "in a system call", outside    .          .    151:   // the $GOMAXPROCS accounting..          .    152:   //.          .    153:   // fn may call back into Go code, in which case we'll exit the.          .    154:   // "system call", run the Go code (which may grow the stack), .          .    155:   // and then re-enter the "system call" reusing the PC and SP  .          .    156:   // saved by entersyscall here.21.94s     21.94s    157:   entersyscall().          .    158:.          .    159:   // Tell asynchronous preemption that we're entering external  .          .    168:.          .    169:   // Update accounting before exitsyscall because exitsyscall may.          .    170:   // reschedule us on to a different M..          .    171:   mp.incgo = false.          .    172:   mp.ncgo--.          .    173:20ms       40ms    174:   osPreemptExtExit(mp).          .    175:.      100ms    176:   exitsyscall().          .    177:.          .    178:   // Note that raceacquire must be called only after exitsyscall has.          .    179:   // wired this M to a P..          .    180:   if raceenabled {.          .    181:           raceacquire(unsafe.Pointer(&racecgosync))

通过分析发现大部分CPU资源被157行占用,耗时21.94s。

图形化

或者可以直接输入web,通过svg图的方式查看程序中详细的CPU占用情况。 想要查看图形化的界面首先需要安装graphviz图形化工具。由于我是Windows系统,进入官网下载graphviz:https://graphviz.gitlab.io/download/

下载完后打开exe文件进行安装。

这里勾选第二个,自动帮你配置环境变量。后面快捷方式我选择不创建。

安装完毕后打开终端运行dot -v检查是否安装成功,安装成功应该会显示以下内容:

(base) PS C:\Users\19393> dot -v
dot - graphviz version 8.1.0 (20230707.0739)
libdir = "F:\Program Files\Graphviz\bin"
Activated plugin library: gvplugin_dot_layout.dll
Using layout: dot:dot_layout
Activated plugin library: gvplugin_core.dll
Using render: dot:core
Using device: dot:dot:core
The plugin configuration file:F:\Program Files\Graphviz\bin\config6was successfully loaded.render      :  cairo dot dot_json fig gdiplus json json0 map mp pic pov ps svg tk xdot xdot_jsonlayout      :  circo dot fdp neato nop nop1 nop2 osage patchwork sfdp twopitextlayout  :  textlayoutdevice      :  bmp canon cmap cmapx cmapx_np dot dot_json emf emfplus eps fig gif gv imap imap_np ismap jpe jpeg jpg json json0 metafile mp pdf pic plain plain-ext png pov ps ps2 svg tif tiff tk xdot xdot1.2 xdot1.4 xdot_jsonloadimage   :  (lib) bmp eps gif jpe jpeg jpg png ps svg

输入web前确认graphviz安装目录下的bin文件夹有无被添加到Path环境变量(我添加的系统变量)中。

接下来我们尝试用图形化的界面来进行分析。

先保证自己的beego项目运行在本地上,再开一个终端跑压测:go-wrk -n 50000 http://localhost:8080/,另外再来一个和终端跑pprof,执行命令:go tool pprof http://127.0.0.1:8080/debug/pprof/profile

pprof的终端如下:

(base) PS F:\GolandProjects\beegoProject\blob> go tool pprof http://127.0.0.1:8080/debug/pprof/profile
Fetching profile over HTTP from http://127.0.0.1:8080/debug/pprof/profile
Saved profile in C:\Users\19393\pprof\pprof.blob.exe.samples.cpu.008.pb.gz
File: blob.exe
Build ID: F:\GolandProjects\beegoProject\blob\blob.exe2023-08-01 16:06:16.7719208 +0800 CST
Type: cpu
Time: Aug 1, 2023 at 7:02pm (CST)
Duration: 30s, Total samples = 44.25s (147.48%)
Entering interactive mode (type "help" for commands, "o" for options)
(pprof) web
(pprof)

由于输入了web命令,浏览器会自动弹出查看svg的页面:

关于图形的说明: 每个框代表一个函数,理论上框的越大表示占用的CPU资源越多。 方框之间的线条代表函数之间的调用关系。 线条上的数字表示函数调用的时间。 方框中的第一行数字表示当前函数占用CPU的百分比,第二行数字表示当前函数累计占用CPU的百分比。

除了分析CPU性能数据,pprof也支持分析内存性能数据。比如,使用下面的命令分析http服务的heap性能数据,查看当前程序的内存占用以及热点内存对象使用的情况。

# 查看内存占用数据
go tool pprof -inuse_space http://127.0.0.1:8080/debug/pprof/heap
go tool pprof -inuse_objects http://127.0.0.1:8080/debug/pprof/heap
# 查看临时内存分配数据
go tool pprof -alloc_space http://127.0.0.1:8080/debug/pprof/heap
go tool pprof -alloc_objects http://127.0.0.1:8080/debug/pprof/heap

以下是查看内存占用数据的示例:

火焰图

火焰图(Flame Graph)是 Bredan Gregg 创建的一种性能分析图表,因为它的样子近似 🔥而得名。

可以通过如下方式来打开火焰图:

  1. 先把压测跑上:go-wrk -n 50000 http://localhost:8080/
  2. 项目根目录新开一个终端,运行go tool pprof -http=:5200 http://127.0.0.1:8080/debug/pprof/profile,30s后,浏览器会自动跳出新界面:http://localhost:5200/ui/,如下:

  1. 跟之前的图形化界面差不多,接下来点击下图中图示任一个便能看到火焰图。

老版火焰图:

新版火焰图:

火焰图的优点是它是动态的:可以通过点击每个方块来 分析它下面的内容。

火焰图的调用顺序从上到下,每个方块代表一个函数,它下面一层表示这个函数会调用哪些函数,方块的大小代表了占用 CPU 使用的长短。火焰图的配色并没有特殊的意义,默认的红、黄配色是为了更像火焰而已。

火焰图的y轴表示cpu调用方法的先后,x轴表示在每个采样调用时间内,方法所占的时间百分比,越宽代表占据cpu时间越多。通过火焰图我们就可以更清楚的找出耗时长的函数调用,然后不断的修正代码,重新采样,不断优化。

此外还可以借助火焰图分析内存性能数据:

go tool pprof -http=:5200 -inuse_space http://127.0.0.1:8080/debug/pprof/heap
go tool pprof -http=:5200 -inuse_objects http://127.0.0.1:8080/debug/pprof/heap
go tool pprof -http=:5200 -alloc_space http://127.0.0.1:8080/debug/pprof/heap
go tool pprof -http=:5200 -alloc_objects http://127.0.0.1:8080/debug/pprof/heap

内存性能火焰图示例:

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/17836.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

使用redis-cli操作redis

redis-cli是原生redis自带的命令行工具&#xff0c;可以帮助我们通过简单的命令连接redis服务&#xff0c;并进行数据管理&#xff0c;即redis键&#xff08;key&#xff09;和redis数据结构的管理。 关于如何进入redis-cli命令行客户端&#xff0c;请查看文章&#xff1a;Redi…

CMake:为Eigen库使能向量化

CMake:为Eigen库使能向量化 导言构建Eigen项目结构CMakeLists.txt相关源码 导言 本篇开始将涉及检测外部库相关的内容&#xff0c;期间会穿插着一些其他的内容。为了能够使得系统在系统中运行Eigen库&#xff0c;我们首先需要在系统中配置好Eigen库。然后介绍与Eigen库相关的C…

【Android】APP启动优化学习笔记

启动优化目的 用户体验&#xff1a; 应用的启动速度直接影响用户体验。用户希望应用能够快速启动并迅速响应他们的操作。如果应用启动较慢&#xff0c;用户可能会感到不满&#xff0c;并且有可能选择卸载或切换到竞争对手的应用。通过启动优化&#xff0c;可以提高应用的启动…

132个心理性格趣味测试ACCESS\EXCEL数据库

今天又遇到了一个心理测试的数据库&#xff0c;这个数据库在表结构的设置上很直观&#xff0c;属于那种好的数据库结构&#xff0c;共分三个表&#xff0c;一个是测试项目描述表、一个是测试题选项得分表、一个是根据得分区间解析表&#xff0c;表与表之间通过“question_id”字…

【Python】pyqt6入门到入土系列,非常详细...

前言 嗨喽&#xff0c;大家好呀~这里是爱看美女的茜茜呐 一、什么是PyQt6? 简单介绍一下PyQt6 1、基础简介 PyQt6 Digia 公司的 Qt 程序的 Python 中间件。Qt库是最强大的GUI库之一。 PyQt6的官网&#xff1a;www.riverbankcomputing.co.uk/news。 PyQt6是由Riverbank Co…

MTK system_server 卡死导致手机重启案例分析

和你一起终身学习&#xff0c;这里是程序员Android 经典好文推荐&#xff0c;通过阅读本文&#xff0c;您将收获以下知识点: 一、MTK AEE Log分析工具二、AEE Log分析流程三、system_server 卡死案例分析及解决 本文主要针对 Exception Type: system_server_watchdog , system_…

力扣SQL之路:窗口函数应用

文章目录 1.引言2.力扣SQL题目3. 解题策略4.代码实现5.总结 1.引言 窗口函数是 SQL 中一种强大的分析函数&#xff0c;它可以在结果集中创建一个窗口&#xff0c;并对窗口内的数据进行计算和分析。在力扣&#xff08;LeetCode&#xff09;的 SQL 题目中&#xff0c;窗口函数经…

Linux进程概念(一)

文章目录 Linux进程概念查看进程杀死进程进程标识符 手动创建进程的方式fork函数创建进程 进程状态运行态阻塞态和挂起 Linux进程概念 前文我们了解了&#xff0c;进程的基本概念&#xff0c;在课本上被描述为&#xff0c;正在执行的程序&#xff0c;在linux内核上&#xff0c…

如何在 Ubuntu 22.04 下编译 StoneDB for MySQL 8.0 | StoneDB 使用教程 #1

作者&#xff1a;双飞&#xff08;花名&#xff1a;小鱼&#xff09; 杭州电子科技大学在读硕士 StoneDB 内核研发实习生 ❝ 大家好&#xff0c;我是 StoneDB 的实习生小鱼&#xff0c;目前正在做 StoneDB 8.0 内核升级相关的一些事情。刚开始接触数据库开发没多久&#xff0c…

解码“平台工程”,VMware 有备而来

随着全球数字化进程加快&#xff0c;企业使用前沿技术加快商业创新&#xff0c;以提高竞争力。其中如何加快开发效率&#xff0c;为客户创造更多价值成为新的关注焦点。 继DevOps后&#xff0c;“平台工程”&#xff08;Platform Engineering&#xff09; 一词引发热议。平台工…

MyBatis的使用方法

文章目录 一、MyBatis的创建准备工作 二、MyBatis的使用1.项目分层2.业务代码1&#xff09;使用XML的方法2&#xff09;直接使用注解 总结 一、MyBatis的创建 准备工作 1.添加依赖 旧项目 方法一&#xff1a;在pom.xml中添加MyBatis和MySQL Diver依赖 <!-- 添加 MyBati…

信息技术会考操作题excel,信息技术会考操作题目

大家好&#xff0c;小编来为大家解答以下问题&#xff0c;信息技术会考操作题python计算题&#xff0c;信息技术会考操作题没有保存&#xff0c;今天让我们一起来看看吧&#xff01; 1. 数据分析题&#xff08;17分&#xff09;&#xff1a; 流行病学通常关注单日治愈患者例数增…

网络知识介绍

一、TCP 传输控制协议&#xff0c;Transmission Control Protocol。 面向广域网的通信协议&#xff0c;跨域多个网络通信时&#xff0c;为两个通信端点之间提供一条具有如下特点的通信方式&#xff1a; 基于流、面向连接、可靠通信方式、网络状况不佳时尽量降低系统由于重传带…

初识Linux

今天简单了解了关于操作系统的发展史&#xff0c;学习了在Linux中如何远程连接云服务器的指令&#xff0c;以及在Linux中创建多个用户的指令。 1. ssh root 服务器远程地址 作用是用来连接XShell与云服务器&#xff0c;输入该指令后会自动生成输入密码的窗口&#xff0c;如…

【产品经理】高阶产品如何处理需求?(3方法论+2案例+1清单)

不管你是萌新小白&#xff0c;还是工作了几年的“老油条”&#xff0c;需求一直是产品经理工作的重点。只不过&#xff0c;不同年限的产品经理需要面对的需求大有不同&#xff0c;对能力的要求更高。 不知你是否遇过以下问题&#xff1f; 你接手一个项目后&#xff0c;不知从何…

DID以及社交网络中的ZKP

1. 引言 本文关键术语为&#xff1a; Decentralized Identity (DID&#xff0c;去中心化身份) or self-sovereign identity (SSI&#xff0c;自治身份) &#xff1a;是一个基于开放标准的框架&#xff0c;使用自主、独立的标识符和可验证证书&#xff0c;实现可信的数据交换。…

虹科案例|如何分析设备故障时间和次数,打破生产瓶颈?

虹科设备绩效管理系统 保障生产设备的稳定性和可靠性 生产设备的稳定性和可靠性是保证企业正常生产的重要条件之一&#xff0c;设备故障的频发严重影响企业的正常生产&#xff0c;那么如何分析设备故障时间和次数&#xff0c;查找设备故障原因&#xff0c;协助企业打破生产瓶…

树莓派通过天线+gps获取经纬度并调用高德地图api在地图上标点

完整项目为《基于机器视觉的行人和路面缺陷检测及其边缘设备部署》 完整功能视频演示地址&#xff1a;本科最后的课设&#xff1a;“车载系统的辅助系统——基于机器视觉的行人和路面缺陷检测”完结撒花*罒▽罒*_哔哩哔哩_bilibili 该博客介绍的功能为&#xff1a; 1&#xff1…

初步了解c#编程语言--(1)

初识c#编程语言 一、见识c#语言编写的各类应用程序 关于用c#语言编写的各类应用程序有以下几种&#xff1a; 1.Console 在编写Console程序时&#xff0c;要注意创建项目时&#xff0c;是选择控制台应用程序&#xff08;Console Application&#xff09;&#xff0c;在这里…

正泰电力携手图扑:VR 变电站事故追忆反演

VR(Virtual Reality&#xff0c;虚拟现实)技术作为近年来快速发展的一项新技术&#xff0c;具有广泛的应用前景&#xff0c;支持融合人工智能、机器学习、大数据等技术&#xff0c;实现更加智能化、个性化的应用。在电力能源领域&#xff0c;VR 技术在高性能计算机和专有设备支…