写点什么

Go 语言性能剖析利器 --pprof 实战

  • 2022-12-15
    北京
  • 本文字数:12517 字

    阅读完需:约 41 分钟

Go语言性能剖析利器--pprof实战

作者:耿宗杰

前言

关于 pprof 的文章在网上已是汗牛充栋,却是千篇一律的命令介绍,鲜有真正实操的,本文将参考 Go 社区资料,结合自己的经验,实战 Go 程序的性能分析与优化过程。

优化思路

首先说一下性能优化的一般思路。系统性能的分析优化,一定是从大到小的步骤来进行的,即从业务架构的优化,到系统架构的优化,再到系统模块间的优化,最后到代码编写层面的优化。业务架构的优化是最具性价比的,技术难度相对较小,却可以带来大幅的性能提升。比如通过和同事或外部门沟通,减少了一些接口调用或者去掉了不必要的复杂的业务逻辑,可以轻松提升整个系统的性能。


系统架构的优化,比如加入缓存,由 http 改进为 rpc 等,也可以在少量投入下带来较大的性能提升。最后是程序代码级别的性能优化,这又分为两方面,一是合格的数据结构与使用,二才是在此基础上的性能剖析。比如在 Go 语言中使用 slice 这种方便的数据结构时,尽可能提前申请足够的内存防止 append 超过容量时的内存申请和数据拷贝;使用并发保护时尽量由 RWMutex 代替 mutex,甚至在极高并发场景下使用更细粒度的原子操作代替锁等等。

优化实践

下面进入正文,待优化程序是社区中一个例子,代码有点长,实现的算法是著名的计算机科学家 Tarjan 的求图的强连通分量算法,关于这个算法的思想请自行 google(就别自行百度了~)。以下为实操过程(会有那么一丢丢长。。。):


初始版本代码 havlak1.go:


// Go from multi-language-benchmark/src/havlak/go_pro// Copyright 2011 Google Inc.//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at////     http://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.// Test Program for the Havlak loop finder.//// This program constructs a fairly large control flow// graph and performs loop recognition. This is the Go// version.//package mainimport (   "flag"   "fmt"   "log"   "os"   "runtime/pprof")type BasicBlock struct {   Name     int   InEdges  []*BasicBlock   OutEdges []*BasicBlock}func NewBasicBlock(name int) *BasicBlock {   return &BasicBlock{Name: name}}func (bb *BasicBlock) Dump() {   fmt.Printf("BB#%06d:", bb.Name)   if len(bb.InEdges) > 0 {      fmt.Printf(" in :")      for _, iter := range bb.InEdges {         fmt.Printf(" BB#%06d", iter.Name)      }   }   if len(bb.OutEdges) > 0 {      fmt.Print(" out:")      for _, iter := range bb.OutEdges {         fmt.Printf(" BB#%06d", iter.Name)      }   }   fmt.Printf("\n")}func (bb *BasicBlock) NumPred() int {   return len(bb.InEdges)}func (bb *BasicBlock) NumSucc() int {   return len(bb.OutEdges)}func (bb *BasicBlock) AddInEdge(from *BasicBlock) {   bb.InEdges = append(bb.InEdges, from)}func (bb *BasicBlock) AddOutEdge(to *BasicBlock) {   bb.OutEdges = append(bb.OutEdges, to)}//-----------------------------------------------------------type CFG struct {   Blocks []*BasicBlock   Start  *BasicBlock}func NewCFG() *CFG {   return &CFG{}}func (cfg *CFG) NumNodes() int {   return len(cfg.Blocks)}func (cfg *CFG) CreateNode(node int) *BasicBlock {   if node < len(cfg.Blocks) {      return cfg.Blocks[node]   }   if node != len(cfg.Blocks) {      println("oops", node, len(cfg.Blocks))      panic("wtf")   }   bblock := NewBasicBlock(node)   cfg.Blocks = append(cfg.Blocks, bblock)   if len(cfg.Blocks) == 1 {      cfg.Start = bblock   }   return bblock}func (cfg *CFG) Dump() {   for _, n := range cfg.Blocks {      n.Dump()   }}//-----------------------------------------------------------type BasicBlockEdge struct {   Dst *BasicBlock   Src *BasicBlock}func NewBasicBlockEdge(cfg *CFG, from int, to int) *BasicBlockEdge {   self := new(BasicBlockEdge)   self.Src = cfg.CreateNode(from)   self.Dst = cfg.CreateNode(to)   self.Src.AddOutEdge(self.Dst)   self.Dst.AddInEdge(self.Src)   return self}//-----------------------------------------------------------// Basic Blocks and Loops are being classified as regular, irreducible,// and so on. This enum contains a symbolic name for all these classifications//const (   _             = iota // Go has an interesting iota concept   bbTop                // uninitialized   bbNonHeader          // a regular BB   bbReducible          // reducible loop   bbSelf               // single BB loop   bbIrreducible        // irreducible loop   bbDead               // a dead BB   bbLast               // sentinel)// UnionFindNode is used in the Union/Find algorithm to collapse// complete loops into a single node. These nodes and the// corresponding functionality are implemented with this class//type UnionFindNode struct {   parent    *UnionFindNode   bb        *BasicBlock   loop      *SimpleLoop   dfsNumber int}// Init explicitly initializes UnionFind nodes.//func (u *UnionFindNode) Init(bb *BasicBlock, dfsNumber int) {   u.parent = u   u.bb = bb   u.dfsNumber = dfsNumber   u.loop = nil}// FindSet implements the Find part of the Union/Find Algorithm//// Implemented with Path Compression (inner loops are only// visited and collapsed once, however, deep nests would still// result in significant traversals).//func (u *UnionFindNode) FindSet() *UnionFindNode {   var nodeList []*UnionFindNode   node := u   for ; node != node.parent; node = node.parent {      if node.parent != node.parent.parent {         nodeList = append(nodeList, node)      }   }   // Path Compression, all nodes' parents point to the 1st level parent.   for _, ll := range nodeList {      ll.parent = node.parent   }   return node}// Union relies on path compression.//func (u *UnionFindNode) Union(B *UnionFindNode) {   u.parent = B}// Constants//// Marker for uninitialized nodes.const unvisited = -1// Safeguard against pathological algorithm behavior.const maxNonBackPreds = 32 * 1024// IsAncestor//// As described in the paper, determine whether a node 'w' is a// "true" ancestor for node 'v'.//// Dominance can be tested quickly using a pre-order trick// for depth-first spanning trees. This is why DFS is the first// thing we run below.//// Go comment: Parameters can be written as w,v int, inlike in C, where//   each parameter needs its own type.//func isAncestor(w, v int, last []int) bool {   return ((w <= v) && (v <= last[w]))}// listContainsNode//// Check whether a list contains a specific element. //func listContainsNode(l []*UnionFindNode, u *UnionFindNode) bool {   for _, ll := range l {      if ll == u {         return true      }   }   return false}// DFS - Depth-First-Search and node numbering.//func DFS(currentNode *BasicBlock, nodes []*UnionFindNode, number map[*BasicBlock]int, last []int, current int) int {   nodes[current].Init(currentNode, current)   number[currentNode] = current   lastid := current   for _, target := range currentNode.OutEdges {      if number[target] == unvisited {         lastid = DFS(target, nodes, number, last, lastid+1)      }   }   last[number[currentNode]] = lastid   return lastid}// FindLoops//// Find loops and build loop forest using Havlak's algorithm, which// is derived from Tarjan. Variable names and step numbering has// been chosen to be identical to the nomenclature in Havlak's// paper (which, in turn, is similar to the one used by Tarjan).//func FindLoops(cfgraph *CFG, lsgraph *LSG) {   if cfgraph.Start == nil {      return   }   size := cfgraph.NumNodes()   nonBackPreds := make([]map[int]bool, size)   backPreds := make([][]int, size)   number := make(map[*BasicBlock]int)   header := make([]int, size, size)   types := make([]int, size, size)   last := make([]int, size, size)   nodes := make([]*UnionFindNode, size, size)   for i := 0; i < size; i++ {      nodes[i] = new(UnionFindNode)   }   // Step a:   //   - initialize all nodes as unvisited.   //   - depth-first traversal and numbering.   //   - unreached BB's are marked as dead.   //   for i, bb := range cfgraph.Blocks {      number[bb] = unvisited      nonBackPreds[i] = make(map[int]bool)   }   DFS(cfgraph.Start, nodes, number, last, 0)   // Step b:   //   - iterate over all nodes.   //   //   A backedge comes from a descendant in the DFS tree, and non-backedges   //   from non-descendants (following Tarjan).   //   //   - check incoming edges 'v' and add them to either   //     - the list of backedges (backPreds) or   //     - the list of non-backedges (nonBackPreds)   //   for w := 0; w < size; w++ {      header[w] = 0      types[w] = bbNonHeader      nodeW := nodes[w].bb      if nodeW == nil {         types[w] = bbDead         continue // dead BB      }      if nodeW.NumPred() > 0 {         for _, nodeV := range nodeW.InEdges {            v := number[nodeV]            if v == unvisited {               continue // dead node            }            if isAncestor(w, v, last) {               backPreds[w] = append(backPreds[w], v)            } else {               nonBackPreds[w][v] = true            }         }      }   }   // Start node is root of all other loops.   header[0] = 0   // Step c:   //   // The outer loop, unchanged from Tarjan. It does nothing except   // for those nodes which are the destinations of backedges.   // For a header node w, we chase backward from the sources of the   // backedges adding nodes to the set P, representing the body of   // the loop headed by w.   //   // By running through the nodes in reverse of the DFST preorder,   // we ensure that inner loop headers will be processed before the   // headers for surrounding loops.   //   for w := size - 1; w >= 0; w-- {      // this is 'P' in Havlak's paper      var nodePool []*UnionFindNode      nodeW := nodes[w].bb      if nodeW == nil {         continue // dead BB      }      // Step d:      for _, v := range backPreds[w] {         if v != w {            nodePool = append(nodePool, nodes[v].FindSet())         } else {            types[w] = bbSelf         }      }      // Copy nodePool to workList.      //      workList := append([]*UnionFindNode(nil), nodePool...)      if len(nodePool) != 0 {         types[w] = bbReducible      }      // work the list...      //      for len(workList) > 0 {         x := workList[0]         workList = workList[1:]         // Step e:         //         // Step e represents the main difference from Tarjan's method.         // Chasing upwards from the sources of a node w's backedges. If         // there is a node y' that is not a descendant of w, w is marked         // the header of an irreducible loop, there is another entry         // into this loop that avoids w.         //         // The algorithm has degenerated. Break and         // return in this case.         //         nonBackSize := len(nonBackPreds[x.dfsNumber])         if nonBackSize > maxNonBackPreds {            return         }         for iter := range nonBackPreds[x.dfsNumber] {            y := nodes[iter]            ydash := y.FindSet()            if !isAncestor(w, ydash.dfsNumber, last) {               types[w] = bbIrreducible               nonBackPreds[w][ydash.dfsNumber] = true            } else {               if ydash.dfsNumber != w {                  if !listContainsNode(nodePool, ydash) {                     workList = append(workList, ydash)                     nodePool = append(nodePool, ydash)                  }               }            }         }      }      // Collapse/Unionize nodes in a SCC to a single node      // For every SCC found, create a loop descriptor and link it in.      //      if (len(nodePool) > 0) || (types[w] == bbSelf) {         loop := lsgraph.NewLoop()         loop.SetHeader(nodeW)         if types[w] != bbIrreducible {            loop.IsReducible = true         }         // At this point, one can set attributes to the loop, such as:         //         // the bottom node:         //    iter  = backPreds[w].begin();         //    loop bottom is: nodes[iter].node);         //         // the number of backedges:         //    backPreds[w].size()         //         // whether this loop is reducible:         //    type[w] != BasicBlockClass.bbIrreducible         //         nodes[w].loop = loop         for _, node := range nodePool {            // Add nodes to loop descriptor.            header[node.dfsNumber] = w            node.Union(nodes[w])            // Nested loops are not added, but linked together.            if node.loop != nil {               node.loop.Parent = loop            } else {               loop.AddNode(node.bb)            }         }         lsgraph.AddLoop(loop)      } // nodePool.size   } // Step c}// External entry point.func FindHavlakLoops(cfgraph *CFG, lsgraph *LSG) int {   FindLoops(cfgraph, lsgraph)   return lsgraph.NumLoops()}//======================================================// Scaffold Code//======================================================// Basic representation of loops, a loop has an entry point,// one or more exit edges, a set of basic blocks, and potentially// an outer loop - a "parent" loop.//// Furthermore, it can have any set of properties, e.g.,// it can be an irreducible loop, have control flow, be// a candidate for transformations, and what not.//type SimpleLoop struct {   // No set, use map to bool   basicBlocks map[*BasicBlock]bool   Children    map[*SimpleLoop]bool   Parent      *SimpleLoop   header      *BasicBlock   IsRoot       bool   IsReducible  bool   Counter      int   NestingLevel int   DepthLevel   int}func (loop *SimpleLoop) AddNode(bb *BasicBlock) {   loop.basicBlocks[bb] = true}func (loop *SimpleLoop) AddChildLoop(child *SimpleLoop) {   loop.Children[child] = true}func (loop *SimpleLoop) Dump(indent int) {   for i := 0; i < indent; i++ {      fmt.Printf("  ")   }   // No ? operator ?   fmt.Printf("loop-%d nest: %d depth %d ",      loop.Counter, loop.NestingLevel, loop.DepthLevel)   if !loop.IsReducible {      fmt.Printf("(Irreducible) ")   }   // must have > 0   if len(loop.Children) > 0 {      fmt.Printf("Children: ")      for ll := range loop.Children {         fmt.Printf("loop-%d", ll.Counter)      }   }   if len(loop.basicBlocks) > 0 {      fmt.Printf("(")      for bb := range loop.basicBlocks {         fmt.Printf("BB#%06d ", bb.Name)         if loop.header == bb {            fmt.Printf("*")         }      }      fmt.Printf("\b)")   }   fmt.Printf("\n")}func (loop *SimpleLoop) SetParent(parent *SimpleLoop) {   loop.Parent = parent   loop.Parent.AddChildLoop(loop)}func (loop *SimpleLoop) SetHeader(bb *BasicBlock) {   loop.AddNode(bb)   loop.header = bb}//------------------------------------// Helper (No templates or such)//func max(x, y int) int {   if x > y {      return x   }   return y}// LoopStructureGraph//// Maintain loop structure for a given CFG.//// Two values are maintained for this loop graph, depth, and nesting level.// For example://// loop        nesting level    depth//----------------------------------------// loop-0      2                0//   loop-1    1                1//   loop-3    1                1//     loop-2  0                2//var loopCounter = 0type LSG struct {   root  *SimpleLoop   loops []*SimpleLoop}func NewLSG() *LSG {   lsg := new(LSG)   lsg.root = lsg.NewLoop()   lsg.root.NestingLevel = 0   return lsg}func (lsg *LSG) NewLoop() *SimpleLoop {   loop := new(SimpleLoop)   loop.basicBlocks = make(map[*BasicBlock]bool)   loop.Children = make(map[*SimpleLoop]bool)   loop.Parent = nil   loop.header = nil   loop.Counter = loopCounter   loopCounter++   return loop}func (lsg *LSG) AddLoop(loop *SimpleLoop) {   lsg.loops = append(lsg.loops, loop)}func (lsg *LSG) Dump() {   lsg.dump(lsg.root, 0)}func (lsg *LSG) dump(loop *SimpleLoop, indent int) {   loop.Dump(indent)   for ll := range loop.Children {      lsg.dump(ll, indent+1)   }}func (lsg *LSG) CalculateNestingLevel() {   for _, sl := range lsg.loops {      if sl.IsRoot {         continue      }      if sl.Parent == nil {         sl.SetParent(lsg.root)      }   }   lsg.calculateNestingLevel(lsg.root, 0)}func (lsg *LSG) calculateNestingLevel(loop *SimpleLoop, depth int) {   loop.DepthLevel = depth   for ll := range loop.Children {      lsg.calculateNestingLevel(ll, depth+1)      ll.NestingLevel = max(loop.NestingLevel, ll.NestingLevel+1)   }}func (lsg *LSG) NumLoops() int {   return len(lsg.loops)}func (lsg *LSG) Root() *SimpleLoop {   return lsg.root}//======================================================// Testing Code//======================================================func buildDiamond(cfgraph *CFG, start int) int {   bb0 := start   NewBasicBlockEdge(cfgraph, bb0, bb0+1)   NewBasicBlockEdge(cfgraph, bb0, bb0+2)   NewBasicBlockEdge(cfgraph, bb0+1, bb0+3)   NewBasicBlockEdge(cfgraph, bb0+2, bb0+3)   return bb0 + 3}func buildConnect(cfgraph *CFG, start int, end int) {   NewBasicBlockEdge(cfgraph, start, end)}func buildStraight(cfgraph *CFG, start int, n int) int {   for i := 0; i < n; i++ {      buildConnect(cfgraph, start+i, start+i+1)   }   return start + n}func buildBaseLoop(cfgraph *CFG, from int) int {   header := buildStraight(cfgraph, from, 1)   diamond1 := buildDiamond(cfgraph, header)   d11 := buildStraight(cfgraph, diamond1, 1)   diamond2 := buildDiamond(cfgraph, d11)   footer := buildStraight(cfgraph, diamond2, 1)   buildConnect(cfgraph, diamond2, d11)   buildConnect(cfgraph, diamond1, header)   buildConnect(cfgraph, footer, from)   footer = buildStraight(cfgraph, footer, 1)   return footer}var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to this file")func main() {   flag.Parse()   if *cpuprofile != "" {      f, err := os.Create(*cpuprofile)      if err != nil {         log.Fatal(err)      }      pprof.StartCPUProfile(f)      defer pprof.StopCPUProfile()   }   lsgraph := NewLSG()   cfgraph := NewCFG()   cfgraph.CreateNode(0) // top   cfgraph.CreateNode(1) // bottom   NewBasicBlockEdge(cfgraph, 0, 2)   for dummyloop := 0; dummyloop < 15000; dummyloop++ {      FindHavlakLoops(cfgraph, NewLSG())   }   n := 2   for parlooptrees := 0; parlooptrees < 10; parlooptrees++ {      cfgraph.CreateNode(n + 1)      buildConnect(cfgraph, 2, n+1)      n = n + 1      for i := 0; i < 100; i++ {         top := n         n = buildStraight(cfgraph, n, 1)         for j := 0; j < 25; j++ {            n = buildBaseLoop(cfgraph, n)         }         bottom := buildStraight(cfgraph, n, 1)         buildConnect(cfgraph, n, top)         n = bottom      }      buildConnect(cfgraph, n, 1)   }   FindHavlakLoops(cfgraph, lsgraph)   for i := 0; i < 50; i++ {      FindHavlakLoops(cfgraph, NewLSG())   }   fmt.Printf("# of loops: %d (including 1 artificial root node)\n", lsgraph.NumLoops())   lsgraph.CalculateNestingLevel()}
复制代码


我们借助 macbook 系统上的 time 命令来打印程序运行的时间(内核态、用户态、总时间):


编译后运行程序:



用户态耗时 23.07s,内核态耗时 0.4s,总耗时 13.7s(用了两个核,170%)。因为程序里面已经先开启了 pprof 统计 cpu 耗时,直接 top 命令看:



可以看到,pprof 数据采集持续了 12.99s,采样时长是 19.49s(还是两核的缘故)。


这里要说一下,无论是 cpu 耗时统计还是内存占用统计,都是间隔采样。cpu 耗时时每隔一段时间(大概是 10ms)对调用栈的函数进行记录,最后分析在所有的记录次数中,各个函数出现的次数,包括在运行中的次数,和入栈次数(说明它调用了别的函数)。内存占用统计是每分配 512K 记录一次分配路径。


耗时最多的是 mapaccess1_fast64,这是运行时中的 map 读写时的数据查询函数。如果编译程序时没有禁用内联,看到的会有所不同,其中会显示 FindHavlakLoops 函数,并标识为 inline。因为 FindHavlakLoops 里面就调用了 FindLoops,所以在编译器会直接把这个函数展开,用 FindLoops 替换 FindHavlakLoops 函数。也可以在不禁用内联编译时,设置 pprof 的 noinlines 开关为 true,默认为 false,即 noinlines=true。


这里看到最大的函数并不是业务函数而是系统函数,那没啥好优化系统函数的(只能是咱用的不对了呗~)。就看是哪里调用的这个系统函数:


web mapaccess1_fast64



可以看到,调用最多的是 DFS 和 FindLoops。那就看看这俩函数里面是怎么使用 map 的,来看 DFS:



可以看到,DFS 函数里耗时较长又是 map 操作的,是 242 246 和 250 三行。对于这里的优化方法,是用 list 结构代替 map 结构,因为能用 list 达到效果的情况下没必要用 map。这个咋一看没问题,但好像又有点别扭对吧?其实是因为这个程序的本身特点,这里有明显的一点,就是 BasicBlock 结构的特殊性,本身的 Name 属性就是自身的索引下标。查找某个 BasicBlock 不需要使用 map 来记录,直接通过下标访问显然是最低的时间复杂度(关于 map 和 list 的时间复杂度就不多说了,map 看起来是 O1,但其实没有考虑 hash 计算本身的过程和解决 hash 冲突的成本,而 list 是必然的 O1)。通过把这部分的 map 修改为 list 数据结构,版本 H2,再编译查看耗时情况:



此时耗时降低到了 8s。再次查看 cpu 耗时分布:



可以看到,top1 变成了 scanobject 函数,不再是 map 读写了。看到这个函数,以及下边的 mallocgc,我们要知道,这都是内存相关的,前者是内存对象扫描的处理函数,是垃圾回收三色标记的一个过程,后者则是直接管理内存分配和回收的(注意是同时负责内存分配和回收,malloc && gc)。这说明目前程序花了很多时间在进行内存管理,看比例是 8%。那就要分析一下了,是什么东西产生了这么多内存变化,合不合理。分析内存,就是 pprof 的 memprofile 功能了。添加一下相关的内存统计代码,具体怎么添加大家肯定都会,就不贴了(网上多得是)。添加完之后,重新编译生成版本 H3,执行 H3,生成对应的内存监测文件:



查看内存的分配情况,在这里不禁止内联,因为在实际运行时该内联的函数也是会被展开替换掉的:



可以看到,节点创建是第一,FindLoops 是第二。因为创建 BasicBlock 首先很简单,没有复杂的过程,其次这是程序中的一个基础对象结构,若要改结构体,那可能涉及到算法也得改,这个显然是不合适的,不仅可能改出 bug,还可能收益不高。那我们就顺着看第二位的 FindLoops,这个就是前边我们看到的调用 mapaccess 内置函数的另一个业务函数,所以优化的方法跟上面类似,还是优化 map 的使用,替换为 list。这里有一点特殊的是,替换成 list 之后,map 的追加需要改一下,加一个判断重复的逻辑,所以新加了一个 appendUnique 方法。再次编译,版本 H4,查看耗时:



这时程序耗时降到了 5.6s。再次查看内存分配,确认优化效果:



可以看到,FindLoops 函数已经不在高位,内存消耗降下去了。再看一下此时的 cpu 耗时分布:



可以看到,FindLoops 成为 top1,scanobject 函数成了第二位。这就对了,因为我们就是要让 cpu 更多的去运行业务代码,把时间花到真正需要的地方


这时就可以进行下一轮的性能优化了(这就是性能调优,一遍一遍的排查耗时,压缩不必要的 cpu 时间,压榨计算性能)。继续看一下此时 FindLoops 到底在哪儿化的时间多,是否合理:



从各个语句的耗时来看,好像没啥大问题,没有很离谱的耗时(360ms 那行是因为循环的缘故)。这说明编码上没有大问题,按照我们前边一开始说的程序优化的步骤,就需要往上找了,看能不能优化逻辑来减少不必要的计算,以达到提升性能的目的(即,每一个计算步骤处理的都没啥大问题了,那能不能少算点儿)。这里 FindLoops 在程序入口,花了不少时间来初始化一系列临时变量,加起来有 180ms,这就意味着每次调用 FindLoops 函数,都要先花 180ms 的准备工作。这部分临时变量的多次创建+初始化,可以通过加内存缓存的方式来减少重复创建和申请,这里涉及到的标准解法其实就是对象池(像 Go 创建的 web 服务,在并发量很高的情况下,每一次 http 请求的解析都需要创建对象+申请内存+反序列这一系列的初始动作,这时就可以借助 sync.Pool 来减少这种重复工作,提升性能)。同理,这里也是加入了一个内存缓存对象 cache:



把原本的内存申请初始化过程做了替换。在原有缓存不够的情况下,申请新的变量,否者截取原有缓存使用,减少内存申请:



调整完毕后,编译新版本 H5,再看下耗时:



这时候程序的耗时已经降到 4.1s,相比一开始的 13.7s,已经提升了两倍多。看下现在的 cpu 耗时分布:



可以看到,相比上次的分布,前两位都是业务代码函数了,说明进一步提高了业务代码的耗时占比,降低了无关系统函数的负载。这种直接使用全局变量的方式加 cache 不是并发安全的,但是因为这里程序的逻辑本身也不是并发的,所以这里没问题。


到这里,实操的优化过程就走完了。提炼总结一下优化的步骤和使用的主要方法命令有:


1.通过 top5 查看 cpu 耗时:确定是字典数据操作占比最大;


2.通过 web 命令查看是谁主要调用了字典操作函数:确定有 DFS 和 FindLoops;


3.使用 list 命令查看 DFS 函数中每行代码的耗时,找到跟 map 操作相关的部分,确定优化方法:把 map 换成 list;


4.重新运行,再用 top 命令查看 cpu 耗时分布:找到耗时最大的是内存对象扫描函数 scanobject;


5.加入内存剖析代码,运行查看内存分配的大小分布:确定 FindLoops 占用较大;


6.使用 list 命令查看 FindLoops 函数的每行内存开销:确定是 map 创建占用内存较大;


7.同样使用 list 数据结构替换 map,重新运行,再看内存大小分布:确定 FindLoops 已不在高位,同时再看 CPU 耗时时,scanobject 已经降下去了,目的达到;


8.此时又开始新的一轮排查,继续查看 cpu 耗时排行榜,FindLoops 耗时居首;


9.继续使用 list 方法看 FindLoops 函数每行的耗时,没有明显的问题。那就要换思路,从排查编码问题转换为排查逻辑问题,减少计算过程:这里是加缓存;


10.加完缓存看到性能明显提升了,说明优化对了。这时又该循环进入下一轮的排查的优化了,以此往复。。。直到压榨出我们能达到的最大性能!


以上就是本次程序优化的整体步骤和思路,过程中秉持的思路方法是一贯的,就是不断的用 pprof 排查 top 级的函数耗时和内存占用,通过优化数据结构、减少不必要的计算过程、降低内存分配和回收的负担等方式来提升性能,这一点对所有的程序都适用,也是后续可以借鉴的方法论

两点感悟

1.优化程序的大前提是你一定要对程序有足够深入的理解! (或者说我们不能优化程序优化出 bug 来啊。。。)。最后生产 H6 版本,之所以又对性能提升了一倍,全是建立在作者对程序完全理解的基础之上的,所以他才可以调整循环逻辑,复用程序对象,调整调用逻辑等等。这一层再往上层思考,就到了程序逻辑,系统架构内置整体的业务架构层面了。这其实就又回到了一开始我们说的程序优化由大到小的总体思路上了。


2.带 GC 的语言相比不带的,反而更考验内存管理的技术。Go 语言在开发效率上的提升,是把垃圾回收交给了系统来处理,但别忘了,消耗的依然是我们自己的 cpu 时间(羊毛,那不得从羊身上来...)。所以我们在使用每种结构体,进行每种计算操作时,都要明白其背后涉及的内存开销,要把内存变化放到潜意识里去管理。


以上就是本次 pprof 优化 Go 程序的实操过程及总结感想,供参考,感谢~

发布于: 刚刚阅读数: 3
用户头像

拥抱技术,与开发者携手创造未来! 2018-11-20 加入

我们将持续为人工智能、大数据、云计算、物联网等相关领域的开发者,提供技术干货、行业技术内容、技术落地实践等文章内容。京东云开发者社区官方网站【https://developer.jdcloud.com/】,欢迎大家来玩

评论

发布
暂无评论
Go语言性能剖析利器--pprof实战_Go_京东科技开发者_InfoQ写作社区