1 # stackcollapse.py - format perf samples with 1 # stackcollapse.py - format perf samples with one line per distinct call stack
2 # SPDX-License-Identifier: GPL-2.0 2 # SPDX-License-Identifier: GPL-2.0
3 # 3 #
4 # This script's output has two space-separated 4 # This script's output has two space-separated fields. The first is a semicolon
5 # separated stack including the program name ( 5 # separated stack including the program name (from the "comm" field) and the
6 # function names from the call stack. The sec 6 # function names from the call stack. The second is a count:
7 # 7 #
8 # swapper;start_kernel;rest_init;cpu_idle;def 8 # swapper;start_kernel;rest_init;cpu_idle;default_idle;native_safe_halt 2
9 # 9 #
10 # The file is sorted according to the first fi 10 # The file is sorted according to the first field.
11 # 11 #
12 # Input may be created and processed using: 12 # Input may be created and processed using:
13 # 13 #
14 # perf record -a -g -F 99 sleep 60 14 # perf record -a -g -F 99 sleep 60
15 # perf script report stackcollapse > out.stac 15 # perf script report stackcollapse > out.stacks-folded
16 # 16 #
17 # (perf script record stackcollapse works too) 17 # (perf script record stackcollapse works too).
18 # 18 #
19 # Written by Paolo Bonzini <pbonzini@redhat.com 19 # Written by Paolo Bonzini <pbonzini@redhat.com>
20 # Based on Brendan Gregg's stackcollapse-perf. 20 # Based on Brendan Gregg's stackcollapse-perf.pl script.
21 21
22 from __future__ import print_function <<
23 <<
24 import os 22 import os
25 import sys 23 import sys
26 from collections import defaultdict 24 from collections import defaultdict
27 from optparse import OptionParser, make_option 25 from optparse import OptionParser, make_option
28 26
29 sys.path.append(os.environ['PERF_EXEC_PATH'] + 27 sys.path.append(os.environ['PERF_EXEC_PATH'] + \
30 '/scripts/python/Perf-Trace-Util/lib/Perf/ !! 28 '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
31 29
32 from perf_trace_context import * 30 from perf_trace_context import *
33 from Core import * 31 from Core import *
34 from EventClass import * 32 from EventClass import *
35 33
36 # command line parsing 34 # command line parsing
37 35
38 option_list = [ 36 option_list = [
39 # formatting options for the bottom entry 37 # formatting options for the bottom entry of the stack
40 make_option("--include-tid", dest="include 38 make_option("--include-tid", dest="include_tid",
41 action="store_true", default= 39 action="store_true", default=False,
42 help="include thread id in st 40 help="include thread id in stack"),
43 make_option("--include-pid", dest="include 41 make_option("--include-pid", dest="include_pid",
44 action="store_true", default= 42 action="store_true", default=False,
45 help="include process id in s 43 help="include process id in stack"),
46 make_option("--no-comm", dest="include_com 44 make_option("--no-comm", dest="include_comm",
47 action="store_false", default 45 action="store_false", default=True,
48 help="do not separate stacks 46 help="do not separate stacks according to comm"),
49 make_option("--tidy-java", dest="tidy_java 47 make_option("--tidy-java", dest="tidy_java",
50 action="store_true", default= 48 action="store_true", default=False,
51 help="beautify Java signature 49 help="beautify Java signatures"),
52 make_option("--kernel", dest="annotate_ker 50 make_option("--kernel", dest="annotate_kernel",
53 action="store_true", default= 51 action="store_true", default=False,
54 help="annotate kernel functio 52 help="annotate kernel functions with _[k]")
55 ] 53 ]
56 54
57 parser = OptionParser(option_list=option_list) 55 parser = OptionParser(option_list=option_list)
58 (opts, args) = parser.parse_args() 56 (opts, args) = parser.parse_args()
59 57
60 if len(args) != 0: 58 if len(args) != 0:
61 parser.error("unexpected command line argu 59 parser.error("unexpected command line argument")
62 if opts.include_tid and not opts.include_comm: 60 if opts.include_tid and not opts.include_comm:
63 parser.error("requesting tid but not comm 61 parser.error("requesting tid but not comm is invalid")
64 if opts.include_pid and not opts.include_comm: 62 if opts.include_pid and not opts.include_comm:
65 parser.error("requesting pid but not comm 63 parser.error("requesting pid but not comm is invalid")
66 64
67 # event handlers 65 # event handlers
68 66
69 lines = defaultdict(lambda: 0) 67 lines = defaultdict(lambda: 0)
70 68
71 def process_event(param_dict): 69 def process_event(param_dict):
72 def tidy_function_name(sym, dso): 70 def tidy_function_name(sym, dso):
73 if sym is None: 71 if sym is None:
74 sym = '[unknown]' 72 sym = '[unknown]'
75 73
76 sym = sym.replace(';', ':') 74 sym = sym.replace(';', ':')
77 if opts.tidy_java: 75 if opts.tidy_java:
78 # the original stackcollapse-perf. 76 # the original stackcollapse-perf.pl script gives the
79 # example of converting this: 77 # example of converting this:
80 # Lorg/mozilla/javascript/Membe 78 # Lorg/mozilla/javascript/MemberBox;.<init>(Ljava/lang/reflect/Method;)V
81 # to this: 79 # to this:
82 # org/mozilla/javascript/Member 80 # org/mozilla/javascript/MemberBox:.init
83 sym = sym.replace('<', '') 81 sym = sym.replace('<', '')
84 sym = sym.replace('>', '') 82 sym = sym.replace('>', '')
85 if sym[0] == 'L' and sym.find('/') 83 if sym[0] == 'L' and sym.find('/'):
86 sym = sym[1:] 84 sym = sym[1:]
87 try: 85 try:
88 sym = sym[:sym.index('(')] 86 sym = sym[:sym.index('(')]
89 except ValueError: 87 except ValueError:
90 pass 88 pass
91 89
92 if opts.annotate_kernel and dso == '[k 90 if opts.annotate_kernel and dso == '[kernel.kallsyms]':
93 return sym + '_[k]' 91 return sym + '_[k]'
94 else: 92 else:
95 return sym 93 return sym
96 94
97 stack = list() 95 stack = list()
98 if 'callchain' in param_dict: 96 if 'callchain' in param_dict:
99 for entry in param_dict['callchain']: 97 for entry in param_dict['callchain']:
100 entry.setdefault('sym', dict()) 98 entry.setdefault('sym', dict())
101 entry['sym'].setdefault('name', No 99 entry['sym'].setdefault('name', None)
102 entry.setdefault('dso', None) 100 entry.setdefault('dso', None)
103 stack.append(tidy_function_name(en 101 stack.append(tidy_function_name(entry['sym']['name'],
104 en 102 entry['dso']))
105 else: 103 else:
106 param_dict.setdefault('symbol', None) 104 param_dict.setdefault('symbol', None)
107 param_dict.setdefault('dso', None) 105 param_dict.setdefault('dso', None)
108 stack.append(tidy_function_name(param_ 106 stack.append(tidy_function_name(param_dict['symbol'],
109 param_ 107 param_dict['dso']))
110 108
111 if opts.include_comm: 109 if opts.include_comm:
112 comm = param_dict["comm"].replace(' ', 110 comm = param_dict["comm"].replace(' ', '_')
113 sep = "-" 111 sep = "-"
114 if opts.include_pid: 112 if opts.include_pid:
115 comm = comm + sep + str(param_dict 113 comm = comm + sep + str(param_dict['sample']['pid'])
116 sep = "/" 114 sep = "/"
117 if opts.include_tid: 115 if opts.include_tid:
118 comm = comm + sep + str(param_dict 116 comm = comm + sep + str(param_dict['sample']['tid'])
119 stack.append(comm) 117 stack.append(comm)
120 118
121 stack_string = ';'.join(reversed(stack)) 119 stack_string = ';'.join(reversed(stack))
122 lines[stack_string] = lines[stack_string] 120 lines[stack_string] = lines[stack_string] + 1
123 121
124 def trace_end(): 122 def trace_end():
125 list = sorted(lines) !! 123 list = lines.keys()
>> 124 list.sort()
126 for stack in list: 125 for stack in list:
127 print("%s %d" % (stack, lines[stack])) !! 126 print "%s %d" % (stack, lines[stack])
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.