美洲杯赔率golang利用pprof与go-torch如何做性能分析
分类：计算机教程

前言

程序各种指标

是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。在程序中一个不小心的操作可能会导致内存泄漏，但是写程序的人可能根本没有意识到，所以我们要对我们的项目做测试，检查程序那些地方的内存没有被回收导致了内存的泄漏。
好在golang为我们提供了pprof包，通过它的HTTP服务端提供pprof可视化工具期望格式的运行时剖面文件数据服务。关于pprof的更多信息，参见http://code.google.com/p/google-perftools/。

  1. 如果你的程序是web程序
  • 在没有使用任何框架的前提下，在程序中导入import _ "net/http/pprof"，然后同样监听本地的一个端口http.ListenAndServe("localhost:6060", nil），即可，启动程序，你可以访问localhost:6060/debug/pprof监控页面，大致样子是：
/debug/pprof/

profiles:
    0block
    7goroutine
   86heap
    0mutex
   13threadcreate

full goroutine stack dump
  • 如果你使用了其他的go-web框架，那么也可以自己添加路由"/debug/pprof/profile，handler方法即使用net/http/pprof下的方法即可。

gin-web框架的/debug/pprof可以参考：github.com/DeanThompson/ginpprof

net/http/pprof下的方法有很多个，都是为我们提供程序运行的一些参数的，你可以在$GOROOT/src/net/http/pprof下查看。/net/http/pprof其实也只是对/runtime/pprof的一层封装而已

  1. 如果你的程序不是web程序
  • 同时也不想开一个端口来获得程序运行时的cpu，内存和其他的一些参数。那么可以直接使用/runtime/下的一些包
import  （
    "runtime/pprof"
    "log"
)
func main() {
    f, err := os.OpenFile("cpu.prof", os.O_RDWR|os.O_CREATE, 0644)
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    /**
      省略操作
    */
    pprof.StartCPUProfile(f)
    defer pprof.StopCPUProfile()
}

os.O_CREATE表示该文件不存在则创建，运行这个程序后就会在该目录下生成一个cpu.prof文件
现在使用go tool pprof来分析这个prof文件。

pprof分析.prof文件命令为：go tool pprof <程序名称> <.prof文件路径>

然后进入pprof的控制台，输入help会得到一些常用命令，如top 10。
美洲杯赔率，更多命令以及其中的含义可以参见：go tool pprof

软件开发过程中，项目上线并不是终点。上线后，还要对程序的取样分析运行情况，并重构现有的功能，让程序执行更高效更稳写。 golang的工具包内自带pprof功能，使找出程序中占内存和CPU较多的部分功能方便了不少。加上uber的火焰图，可视化显示，让我们在分析程序时更简单明了。

进一步分析(svg)

pprof有两个包用来分析程序一个是net/http/pprof另一个是runtime/pprof，net/http/pprof只是对runtime/pprof包进行封装并用http暴露出来，如下图源码所示：

安装FlameGraph

git clone https://github.com/brendangregg/FlameGraph.git
cp FlameGraph/flamegraph.pl /usr/local/bin
然后执行命令flamegraph.pl -h查看是否有help信息表明是否安装成功

美洲杯赔率 1

web浏览

假设现在已经启动了一个web程序，然后我们开一个终端用命令go tool pprof --seconds 25 http://localhost:8080/debug/pprof/profile设置采样时间和路径，再开一个终端用wrk压测工具：压测30s，其他参数自定义。等到时间结束后，在第一个终端那里会出现(pprof)，这和之前分析.prof文件效果是一样的，不同的是这里没有生成文件。然后我们输入命令web——表示用web浏览器打开。如果出现如下提示

Failed to execute dot. Is Graphviz installed? Error: exec: "dot": executable file not found in$PATH

此时可用如下命令安装Graphviz

sudo apt install graphviz

然后再次输入web，那么会在web页面看到

美洲杯赔率 2

Screenshot from 2017-10-25 21-53-44.png

这是一个很简单程序生成的svg图都这么多内容，难以想象一个复杂的程序读这样的图时该从哪个地方下手，找出部分函数的cpu使用超标，内存使用超标来进行性能的优化。

使用net/http/pprof分析web服务

更加直观的火焰图go-torch

go-torch是Uber开发的一个工具，它的github地址

go get github.com/uber/go-torch
go install github.com/uber/go-torch
即可完成go-torch的安装

  • 现在打开一个终端，运行go-torch
  • 另开一个终端，再次使用wrk压测工具压测30s等到时间结束之后，大致可以在go-torch的目录下看到这样的信息

INFO[21:37:37] Run pprof command: go tool pprof -raw -seconds 30 http://localhost:8080/debug/pprof/profile
INFO[21:38:08] Writing svg to torch.svg

对于这个torch.svg，使用浏览器打开，效果如下：

美洲杯赔率 3

Screenshot from 2017-10-25 21-47-58.png

  • 每一个小方块都是可以点击查看详细信息
  • y轴表示cpu调用方法的先后
  • x轴表示在每个采样调用时间内，方法所占的时间百分比，越宽代表占据cpu时间越多。

pprof分析web项目，非常的简单只需要导入包即可。

trace

前面讲的pprof适合于跟踪运行缓慢的函数，或者找到大部分CPU时间花费在哪里，并且显示在每个函数中花费的CPU时间的百分比；而trace则更适合于找出程序在一段时间内正在做什么，而不是总体上的开销。

func main() {
    f, err := os.Create("trace.out")
    if err != nil {
        panic(err)
    }
    defer f.Close()
    err = trace.Start(f)
    if err != nil {
        panic(err)
    }
    defer trace.Stop()
    //每10s执行一次GC
    t1 := time.NewTicker(time.Second * 10)
    go func() {
        for {
            select {
            case <-t1.C:
                log.Println("runtime.gc()")
                runtime.GC()
            }
        }
    }()

    // Your logic code here
}
  1. 这是代码的一部分，当程序运行起来之后，每隔10s就会向trace.out中写入gc的信息。
  • 如果你想在控制台看到gc的信息，可以运行如下命令

go build yourProgram
GODEBUG=gctrace=1 ./yourProgram

控制台打印信息类似于

gc 1 @10.003s 0%: 0.086 1.2 0.026 ms clock, 0.25 0/1.2/0 0.078 ms cpu, 1->1->0 MB, 4 MB goal, 4 P (forced)
gc 2 @20.003s 0%: 0.061 0.44 0.016 ms clock, 0.18 0/0.42/0.41 0.050 ms cpu, 0->0->0 MB, 4 MB goal, 4 P (forced)
scvg0: inuse: 1, idle: 1, sys: 2, released: 0, consumed: 2 (MB)

控制台打印信息的说明

  1. gc后面的数字表示第几次执行gc
  2. 0%表示表示垃圾回收时间占用的百分比
  3. 0.086 1.2 0.026ms clock表示垃圾回收的时间。分别为STW（stop-the-world）清扫的时间, 并发标记和扫描的时间，STW标记的时间
  4. 0.25 0/1.2/0 0.078 ms cpu表示垃圾回收占用cpu时间
  5. 1->1->0 MB表示堆的大小，gc后堆的大小，存活堆的大小
  6. 4 MB goal表示整体堆的大小
  7. 4 P表示处理器的数量
  8. 系统内存回收信息
    scvg0: inuse: 1, idle: 1, sys: 2, released: 0, consumed: 2 (MB)
    inuse:使用多少M内存
    idle:剩下要清除的内存
    sys:系统映射的内存
    released:释放的系统内存
    consumed:申请的系统内存
  • 或者使用go tool trace分析trace.out文件，看看gc更加详细的情况

go tool trace -http="localhost:8888" <yourProgramName> trace.out

该命令在go1.6以下的版本中需要<yourProgramName>参数，即可运行的二进制文件，在go1.6之后的版本则不再需要这个参数。
现在你可以访问localhost:8888看看trace文件中都记录了什么内容，访问localhost:8888/trace即可看到更详细的信息。

  1. 上述代码是直接在程序中生成trace.out二进制文件，如果你为trace开通了http服务，那么直接运行如下命令可进行10s的采样数据
    curl 127.0.0.1:port/debug/pprof/trace?seconds=10 trace.data
    如果提示curl(6)错误，那么你可以直接在浏览器访问localhost:port/debug/pprof/trace?seconds=10也会得到相应的采样数据，获得采样数据之后可以利用上述步骤分析trace文件
_ "net/http/pprof"

编写一个小的web服务器

package main

import (
 _ "net/http/pprof"
 "net/http"
 "time"
 "math/rand"
 "fmt"
)

var Count int64 = 0
func main() {
 go calCount()

 http.HandleFunc("/test", test)
 http.HandleFunc("/data", handlerData)

 err := http.ListenAndServe(":9909", nil )
 if err != nil {
 panic(err)
 }
}

func handlerData(w http.ResponseWriter, r *http.Request) {
 qUrl := r.URL
 fmt.Println(qUrl)
 fibRev := Fib()
 var fib uint64
 for i:= 0; i < 5000; i   {
 fib = fibRev()
 fmt.Println("fib = ", fib)
 }
 str := RandomStr(RandomInt(100, 500))
 str = fmt.Sprintf("Fib = %d; String = %s", fib, str)
 w.Write([]byte(str))
}

func test(w http.ResponseWriter, r *http.Request) {
 fibRev := Fib()
 var fib uint64
 index := Count
 arr := make([]uint64, index)
 var i int64
 for ; i < index; i   {
 fib = fibRev()
 arr[i] = fib
 fmt.Println("fib = ", fib)
 }
 time.Sleep(time.Millisecond * 500)
 str := fmt.Sprintf("Fib = %v", arr)
 w.Write([]byte(str))
}

func Fib() func() uint64 {
 var x, y uint64 = 0, 1
 return func() uint64 {
 x, y = y, x   y
 return x
 }
}

var letterRunes = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890")
func RandomStr(num int) string {
 seed := time.Now().UnixNano()
 if seed <= 0 {
 seed = time.Now().UnixNano()
 }
 rand.Seed(seed)
 b := make([]rune, num)
 for i := range b {
 b[i] = letterRunes[rand.Intn(len(letterRunes))]
 }
 return string(b)
}

func RandomInt(min, max int) int {
 rand.Seed(time.Now().UnixNano())
 return rand.Intn(max - min   1)   min
}

func calCount() {
 timeInterval := time.Tick(time.Second)

 for {
 select {
 case i := <- timeInterval:
  Count = int64(i.Second())
 }
 }
}

web服务监听9909端口

web服务器有两个http方法

test： 根据当前的秒数做斐波那契计算

data： 做一个5000的斐波那契计算并返回一个随机的字符串

运行程序,通过访问 http://192.168.3.34:9909/debug/pprof/可以查看web版的profiles相关信息

美洲杯赔率 4

这几个路径表示的是

/debug/pprof/profile：访问这个链接会自动进行 CPU profiling，持续 30s，并生成一个文件供下载

/debug/pprof/block：Goroutine阻塞事件的记录。默认每发生一次阻塞事件时取样一次。

/debug/pprof/goroutines：活跃Goroutine的信息的记录。仅在获取时取样一次。

/debug/pprof/heap： 堆内存分配情况的记录。默认每分配512K字节时取样一次。

/debug/pprof/mutex: 查看争用互斥锁的持有者。

/debug/pprof/threadcreate: 系统线程创建情况的记录。 仅在获取时取样一次。

除了这些golang为我提供了更多方便的方法，用于分析，下面我们来用命令去访问详细的信息

我们用wrk来访问我们的两个方法，这样我们的服务会处在高速运行状态，取样的结果会更准确

wrk -c 20 -t 5 -d 3m http://192.168.3.34:9909/data
wrk -c 20 -t 5 -d 3m http://192.168.3.34:9909/test

分析CPU使用情况

使用命令分析CPU使用情况

go tool pprof httpdemo http://192.168.3.34:9909/debug/pprof/profile

在默认情况下，Go语言的运行时系统会以100 Hz的的频率对CPU使用情况进行取样。也就是说每秒取样100次，即每10毫秒会取样一次。为什么使用这个频率呢？因为100 Hz既足够产生有用的数据，又不至于让系统产生停顿。并且100这个数上也很容易做换算，比如把总取样计数换算为每秒的取样数。实际上，这里所说的对CPU使用情况的取样就是对当前的Goroutine的堆栈上的程序计数器的取样。

默认的取样时间是30s 你可以通过-seconds 命令来指定取样时间 。取样完成后会进入命令行状态：

美洲杯赔率 5

可以输入help查看相关的命令.这里说几个常用的命令

top命令，输入top命令默认是返加前10的占用cpu的方法。当然人可以在命令后面加数字指定top数

美洲杯赔率 6

list命令根据你的正则输出相关的方法.直接跟可选项o 会输出所有的方法。也可以指定方法名

美洲杯赔率 7

如： handlerData方法占cpu的74.81%

web命令：以网页的形式展现：更直观的显示cpu的使用情况

本文由美洲杯赔率发布于计算机教程,转载请注明出处：美洲杯赔率golang利用pprof与go-torch如何做性能分析

上一篇：我是如何跨专业零基础学习Python爬虫的（2 爬虫所 下一篇：没有了
猜你喜欢
热门排行
精彩图文