Source file src/cmd/vendor/github.com/google/pprof/profile/prune.go

     1	// Copyright 2014 Google Inc. All Rights Reserved.
     2	//
     3	// Licensed under the Apache License, Version 2.0 (the "License");
     4	// you may not use this file except in compliance with the License.
     5	// You may obtain a copy of the License at
     6	//
     7	//     http://www.apache.org/licenses/LICENSE-2.0
     8	//
     9	// Unless required by applicable law or agreed to in writing, software
    10	// distributed under the License is distributed on an "AS IS" BASIS,
    11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12	// See the License for the specific language governing permissions and
    13	// limitations under the License.
    14	
    15	// Implements methods to remove frames from profiles.
    16	
    17	package profile
    18	
    19	import (
    20		"fmt"
    21		"regexp"
    22		"strings"
    23	)
    24	
    25	var (
    26		reservedNames = []string{"(anonymous namespace)", "operator()"}
    27		bracketRx     = func() *regexp.Regexp {
    28			var quotedNames []string
    29			for _, name := range append(reservedNames, "(") {
    30				quotedNames = append(quotedNames, regexp.QuoteMeta(name))
    31			}
    32			return regexp.MustCompile(strings.Join(quotedNames, "|"))
    33		}()
    34	)
    35	
    36	// simplifyFunc does some primitive simplification of function names.
    37	func simplifyFunc(f string) string {
    38		// Account for leading '.' on the PPC ELF v1 ABI.
    39		funcName := strings.TrimPrefix(f, ".")
    40		// Account for unsimplified names -- try  to remove the argument list by trimming
    41		// starting from the first '(', but skipping reserved names that have '('.
    42		for _, ind := range bracketRx.FindAllStringSubmatchIndex(funcName, -1) {
    43			foundReserved := false
    44			for _, res := range reservedNames {
    45				if funcName[ind[0]:ind[1]] == res {
    46					foundReserved = true
    47					break
    48				}
    49			}
    50			if !foundReserved {
    51				funcName = funcName[:ind[0]]
    52				break
    53			}
    54		}
    55		return funcName
    56	}
    57	
    58	// Prune removes all nodes beneath a node matching dropRx, and not
    59	// matching keepRx. If the root node of a Sample matches, the sample
    60	// will have an empty stack.
    61	func (p *Profile) Prune(dropRx, keepRx *regexp.Regexp) {
    62		prune := make(map[uint64]bool)
    63		pruneBeneath := make(map[uint64]bool)
    64	
    65		for _, loc := range p.Location {
    66			var i int
    67			for i = len(loc.Line) - 1; i >= 0; i-- {
    68				if fn := loc.Line[i].Function; fn != nil && fn.Name != "" {
    69					funcName := simplifyFunc(fn.Name)
    70					if dropRx.MatchString(funcName) {
    71						if keepRx == nil || !keepRx.MatchString(funcName) {
    72							break
    73						}
    74					}
    75				}
    76			}
    77	
    78			if i >= 0 {
    79				// Found matching entry to prune.
    80				pruneBeneath[loc.ID] = true
    81	
    82				// Remove the matching location.
    83				if i == len(loc.Line)-1 {
    84					// Matched the top entry: prune the whole location.
    85					prune[loc.ID] = true
    86				} else {
    87					loc.Line = loc.Line[i+1:]
    88				}
    89			}
    90		}
    91	
    92		// Prune locs from each Sample
    93		for _, sample := range p.Sample {
    94			// Scan from the root to the leaves to find the prune location.
    95			// Do not prune frames before the first user frame, to avoid
    96			// pruning everything.
    97			foundUser := false
    98			for i := len(sample.Location) - 1; i >= 0; i-- {
    99				id := sample.Location[i].ID
   100				if !prune[id] && !pruneBeneath[id] {
   101					foundUser = true
   102					continue
   103				}
   104				if !foundUser {
   105					continue
   106				}
   107				if prune[id] {
   108					sample.Location = sample.Location[i+1:]
   109					break
   110				}
   111				if pruneBeneath[id] {
   112					sample.Location = sample.Location[i:]
   113					break
   114				}
   115			}
   116		}
   117	}
   118	
   119	// RemoveUninteresting prunes and elides profiles using built-in
   120	// tables of uninteresting function names.
   121	func (p *Profile) RemoveUninteresting() error {
   122		var keep, drop *regexp.Regexp
   123		var err error
   124	
   125		if p.DropFrames != "" {
   126			if drop, err = regexp.Compile("^(" + p.DropFrames + ")$"); err != nil {
   127				return fmt.Errorf("failed to compile regexp %s: %v", p.DropFrames, err)
   128			}
   129			if p.KeepFrames != "" {
   130				if keep, err = regexp.Compile("^(" + p.KeepFrames + ")$"); err != nil {
   131					return fmt.Errorf("failed to compile regexp %s: %v", p.KeepFrames, err)
   132				}
   133			}
   134			p.Prune(drop, keep)
   135		}
   136		return nil
   137	}
   138	
   139	// PruneFrom removes all nodes beneath the lowest node matching dropRx, not including itself.
   140	//
   141	// Please see the example below to understand this method as well as
   142	// the difference from Prune method.
   143	//
   144	// A sample contains Location of [A,B,C,B,D] where D is the top frame and there's no inline.
   145	//
   146	// PruneFrom(A) returns [A,B,C,B,D] because there's no node beneath A.
   147	// Prune(A, nil) returns [B,C,B,D] by removing A itself.
   148	//
   149	// PruneFrom(B) returns [B,C,B,D] by removing all nodes beneath the first B when scanning from the bottom.
   150	// Prune(B, nil) returns [D] because a matching node is found by scanning from the root.
   151	func (p *Profile) PruneFrom(dropRx *regexp.Regexp) {
   152		pruneBeneath := make(map[uint64]bool)
   153	
   154		for _, loc := range p.Location {
   155			for i := 0; i < len(loc.Line); i++ {
   156				if fn := loc.Line[i].Function; fn != nil && fn.Name != "" {
   157					funcName := simplifyFunc(fn.Name)
   158					if dropRx.MatchString(funcName) {
   159						// Found matching entry to prune.
   160						pruneBeneath[loc.ID] = true
   161						loc.Line = loc.Line[i:]
   162						break
   163					}
   164				}
   165			}
   166		}
   167	
   168		// Prune locs from each Sample
   169		for _, sample := range p.Sample {
   170			// Scan from the bottom leaf to the root to find the prune location.
   171			for i, loc := range sample.Location {
   172				if pruneBeneath[loc.ID] {
   173					sample.Location = sample.Location[i:]
   174					break
   175				}
   176			}
   177		}
   178	}
   179	

View as plain text