Debian Codegraph @

llvm-project/clang/utils/perf-training/perf-helper.py

raw
1 #===- perf-helper.py - Clang Python Bindings -----------------*- python -*--===#
2 #
3 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 # See https://llvm.org/LICENSE.txt for license information.
5 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 #
7 #===------------------------------------------------------------------------===#
8
9 from __future__ import absolute_import, division, print_function
10
11 import sys
12 import os
13 import subprocess
14 import argparse
15 import time
16 import bisect
17 import shlex
18 import tempfile
19
20 test_env = { 'PATH' : os.environ['PATH'] }
21
22 def findFilesWithExtension(path, extension):
23 filenames = []
24 for root, dirs, files in os.walk(path):
25 for filename in files:
26 if filename.endswith(f".{extension}"):
27 filenames.append(os.path.join(root, filename))
28 return filenames
29
30 def clean(args):
31 if len(args) != 2:
32 print('Usage: %s clean <path> <extension>\n' % __file__ +
33 '\tRemoves all files with extension from <path>.')
34 return 1
35 for filename in findFilesWithExtension(args[0], args[1]):
36 os.remove(filename)
37 return 0
38
39 def merge(args):
40 if len(args) != 3:
41 print('Usage: %s merge <llvm-profdata> <output> <path>\n' % __file__ +
42 '\tMerges all profraw files from path into output.')
43 return 1
44 cmd = [args[0], 'merge', '-o', args[1]]
45 cmd.extend(findFilesWithExtension(args[2], "profraw"))
46 subprocess.check_call(cmd)
47 return 0
48
49 def merge_fdata(args):
50 if len(args) != 3:
51 print('Usage: %s merge-fdata <merge-fdata> <output> <path>\n' % __file__ +
52 '\tMerges all fdata files from path into output.')
53 return 1
54 cmd = [args[0], '-o', args[1]]
55 cmd.extend(findFilesWithExtension(args[2], "fdata"))
56 subprocess.check_call(cmd)
57 return 0
58
59 def dtrace(args):
60 parser = argparse.ArgumentParser(prog='perf-helper dtrace',
61 description='dtrace wrapper for order file generation')
62 parser.add_argument('--buffer-size', metavar='size', type=int, required=False,
63 default=1, help='dtrace buffer size in MB (default 1)')
64 parser.add_argument('--use-oneshot', required=False, action='store_true',
65 help='Use dtrace\'s oneshot probes')
66 parser.add_argument('--use-ustack', required=False, action='store_true',
67 help='Use dtrace\'s ustack to print function names')
68 parser.add_argument('--cc1', required=False, action='store_true',
69 help='Execute cc1 directly (don\'t profile the driver)')
70 parser.add_argument('cmd', nargs='*', help='')
71
72 # Use python's arg parser to handle all leading option arguments, but pass
73 # everything else through to dtrace
74 first_cmd = next(arg for arg in args if not arg.startswith("--"))
75 last_arg_idx = args.index(first_cmd)
76
77 opts = parser.parse_args(args[:last_arg_idx])
78 cmd = args[last_arg_idx:]
79
80 if opts.cc1:
81 cmd = get_cc1_command_for_args(cmd, test_env)
82
83 if opts.use_oneshot:
84 target = "oneshot$target:::entry"
85 else:
86 target = "pid$target:::entry"
87 predicate = '%s/probemod=="%s"/' % (target, os.path.basename(cmd[0]))
88 log_timestamp = 'printf("dtrace-TS: %d\\n", timestamp)'
89 if opts.use_ustack:
90 action = 'ustack(1);'
91 else:
92 action = 'printf("dtrace-Symbol: %s\\n", probefunc);'
93 dtrace_script = "%s { %s; %s }" % (predicate, log_timestamp, action)
94
95 dtrace_args = []
96 if not os.geteuid() == 0:
97 print(
98 'Script must be run as root, or you must add the following to your sudoers:'
99 + '%%admin ALL=(ALL) NOPASSWD: /usr/sbin/dtrace')
100 dtrace_args.append("sudo")
101
102 dtrace_args.extend((
103 'dtrace', '-xevaltime=exec',
104 '-xbufsize=%dm' % (opts.buffer_size),
105 '-q', '-n', dtrace_script,
106 '-c', ' '.join(cmd)))
107
108 if sys.platform == "darwin":
109 dtrace_args.append('-xmangled')
110
111 start_time = time.time()
112
113 with open("%d.dtrace" % os.getpid(), "w") as f:
114 f.write("### Command: %s" % dtrace_args)
115 subprocess.check_call(dtrace_args, stdout=f, stderr=subprocess.PIPE)
116
117 elapsed = time.time() - start_time
118 print("... data collection took %.4fs" % elapsed)
119
120 return 0
121
122 def get_cc1_command_for_args(cmd, env):
123 # Find the cc1 command used by the compiler. To do this we execute the
124 # compiler with '-###' to figure out what it wants to do.
125 cmd = cmd + ['-###']
126 cc_output = subprocess.check_output(cmd, stderr=subprocess.STDOUT, env=env, universal_newlines=True).strip()
127 cc_commands = []
128 for ln in cc_output.split('\n'):
129 # Filter out known garbage.
130 if (ln == 'Using built-in specs.' or
131 ln.startswith('Configured with:') or
132 ln.startswith('Target:') or
133 ln.startswith('Thread model:') or
134 ln.startswith('InstalledDir:') or
135 ln.startswith('LLVM Profile Note') or
136 ln.startswith(' (in-process)') or
137 ' version ' in ln):
138 continue
139 cc_commands.append(ln)
140
141 if len(cc_commands) != 1:
142 print('Fatal error: unable to determine cc1 command: %r' % cc_output)
143 exit(1)
144
145 cc1_cmd = shlex.split(cc_commands[0])
146 if not cc1_cmd:
147 print('Fatal error: unable to determine cc1 command: %r' % cc_output)
148 exit(1)
149
150 return cc1_cmd
151
152 def cc1(args):
153 parser = argparse.ArgumentParser(prog='perf-helper cc1',
154 description='cc1 wrapper for order file generation')
155 parser.add_argument('cmd', nargs='*', help='')
156
157 # Use python's arg parser to handle all leading option arguments, but pass
158 # everything else through to dtrace
159 first_cmd = next(arg for arg in args if not arg.startswith("--"))
160 last_arg_idx = args.index(first_cmd)
161
162 opts = parser.parse_args(args[:last_arg_idx])
163 cmd = args[last_arg_idx:]
164
165 # clear the profile file env, so that we don't generate profdata
166 # when capturing the cc1 command
167 cc1_env = test_env
168 cc1_env["LLVM_PROFILE_FILE"] = os.devnull
169 cc1_cmd = get_cc1_command_for_args(cmd, cc1_env)
170
171 subprocess.check_call(cc1_cmd)
172 return 0
173
174 def parse_dtrace_symbol_file(path, all_symbols, all_symbols_set,
175 missing_symbols, opts):
176 def fix_mangling(symbol):
177 if sys.platform == "darwin":
178 if symbol[0] != '_' and symbol != 'start':
179 symbol = '_' + symbol
180 return symbol
181
182 def get_symbols_with_prefix(symbol):
183 start_index = bisect.bisect_left(all_symbols, symbol)
184 for s in all_symbols[start_index:]:
185 if not s.startswith(symbol):
186 break
187 yield s
188
189 # Extract the list of symbols from the given file, which is assumed to be
190 # the output of a dtrace run logging either probefunc or ustack(1) and
191 # nothing else. The dtrace -xdemangle option needs to be used.
192 #
193 # This is particular to OS X at the moment, because of the '_' handling.
194 with open(path) as f:
195 current_timestamp = None
196 for ln in f:
197 # Drop leading and trailing whitespace.
198 ln = ln.strip()
199 if not ln.startswith("dtrace-"):
200 continue
201
202 # If this is a timestamp specifier, extract it.
203 if ln.startswith("dtrace-TS: "):
204 _,data = ln.split(': ', 1)
205 if not data.isdigit():
206 print("warning: unrecognized timestamp line %r, ignoring" % ln,
207 file=sys.stderr)
208 continue
209 current_timestamp = int(data)
210 continue
211 elif ln.startswith("dtrace-Symbol: "):
212
213 _,ln = ln.split(': ', 1)
214 if not ln:
215 continue
216
217 # If there is a '`' in the line, assume it is a ustack(1) entry in
218 # the form of <modulename>`<modulefunc>, where <modulefunc> is never
219 # truncated (but does need the mangling patched).
220 if '`' in ln:
221 yield (current_timestamp, fix_mangling(ln.split('`',1)[1]))
222 continue
223
224 # Otherwise, assume this is a probefunc printout. DTrace on OS X
225 # seems to have a bug where it prints the mangled version of symbols
226 # which aren't C++ mangled. We just add a '_' to anything but start
227 # which doesn't already have a '_'.
228 symbol = fix_mangling(ln)
229
230 # If we don't know all the symbols, or the symbol is one of them,
231 # just return it.
232 if not all_symbols_set or symbol in all_symbols_set:
233 yield (current_timestamp, symbol)
234 continue
235
236 # Otherwise, we have a symbol name which isn't present in the
237 # binary. We assume it is truncated, and try to extend it.
238
239 # Get all the symbols with this prefix.
240 possible_symbols = list(get_symbols_with_prefix(symbol))
241 if not possible_symbols:
242 continue
243
244 # If we found too many possible symbols, ignore this as a prefix.
245 if len(possible_symbols) > 100:
246 print( "warning: ignoring symbol %r " % symbol +
247 "(no match and too many possible suffixes)", file=sys.stderr)
248 continue
249
250 # Report that we resolved a missing symbol.
251 if opts.show_missing_symbols and symbol not in missing_symbols:
252 print("warning: resolved missing symbol %r" % symbol, file=sys.stderr)
253 missing_symbols.add(symbol)
254
255 # Otherwise, treat all the possible matches as having occurred. This
256 # is an over-approximation, but it should be ok in practice.
257 for s in possible_symbols:
258 yield (current_timestamp, s)
259
260 def uniq(list):
261 seen = set()
262 for item in list:
263 if item not in seen:
264 yield item
265 seen.add(item)
266
267 def form_by_call_order(symbol_lists):
268 # Simply strategy, just return symbols in order of occurrence, even across
269 # multiple runs.
270 return uniq(s for symbols in symbol_lists for s in symbols)
271
272 def form_by_call_order_fair(symbol_lists):
273 # More complicated strategy that tries to respect the call order across all
274 # of the test cases, instead of giving a huge preference to the first test
275 # case.
276
277 # First, uniq all the lists.
278 uniq_lists = [list(uniq(symbols)) for symbols in symbol_lists]
279
280 # Compute the successors for each list.
281 succs = {}
282 for symbols in uniq_lists:
283 for a,b in zip(symbols[:-1], symbols[1:]):
284 succs[a] = items = succs.get(a, [])
285 if b not in items:
286 items.append(b)
287
288 # Emit all the symbols, but make sure to always emit all successors from any
289 # call list whenever we see a symbol.
290 #
291 # There isn't much science here, but this sometimes works better than the
292 # more naive strategy. Then again, sometimes it doesn't so more research is
293 # probably needed.
294 return uniq(s
295 for symbols in symbol_lists
296 for node in symbols
297 for s in ([node] + succs.get(node,[])))
298
299 def form_by_frequency(symbol_lists):
300 # Form the order file by just putting the most commonly occurring symbols
301 # first. This assumes the data files didn't use the oneshot dtrace method.
302
303 counts = {}
304 for symbols in symbol_lists:
305 for a in symbols:
306 counts[a] = counts.get(a,0) + 1
307
308 by_count = list(counts.items())
309 by_count.sort(key = lambda __n: -__n[1])
310 return [s for s,n in by_count]
311
312 def form_by_random(symbol_lists):
313 # Randomize the symbols.
314 merged_symbols = uniq(s for symbols in symbol_lists
315 for s in symbols)
316 random.shuffle(merged_symbols)
317 return merged_symbols
318
319 def form_by_alphabetical(symbol_lists):
320 # Alphabetize the symbols.
321 merged_symbols = list(set(s for symbols in symbol_lists for s in symbols))
322 merged_symbols.sort()
323 return merged_symbols
324
325 methods = dict((name[len("form_by_"):],value)
326 for name,value in locals().items() if name.startswith("form_by_"))
327
328 def genOrderFile(args):
329 parser = argparse.ArgumentParser(
330 "%prog [options] <dtrace data file directories>]")
331 parser.add_argument('input', nargs='+', help='')
332 parser.add_argument("--binary", metavar="PATH", type=str, dest="binary_path",
333 help="Path to the binary being ordered (for getting all symbols)",
334 default=None)
335 parser.add_argument("--output", dest="output_path",
336 help="path to output order file to write", default=None, required=True,
337 metavar="PATH")
338 parser.add_argument("--show-missing-symbols", dest="show_missing_symbols",
339 help="show symbols which are 'fixed up' to a valid name (requires --binary)",
340 action="store_true", default=None)
341 parser.add_argument("--output-unordered-symbols",
342 dest="output_unordered_symbols_path",
343 help="write a list of the unordered symbols to PATH (requires --binary)",
344 default=None, metavar="PATH")
345 parser.add_argument("--method", dest="method",
346 help="order file generation method to use", choices=list(methods.keys()),
347 default='call_order')
348 opts = parser.parse_args(args)
349
350 # If the user gave us a binary, get all the symbols in the binary by
351 # snarfing 'nm' output.
352 if opts.binary_path is not None:
353 output = subprocess.check_output(['nm', '-P', opts.binary_path], universal_newlines=True)
354 lines = output.split("\n")
355 all_symbols = [ln.split(' ',1)[0]
356 for ln in lines
357 if ln.strip()]
358 print("found %d symbols in binary" % len(all_symbols))
359 all_symbols.sort()
360 else:
361 all_symbols = []
362 all_symbols_set = set(all_symbols)
363
364 # Compute the list of input files.
365 input_files = []
366 for dirname in opts.input:
367 input_files.extend(findFilesWithExtension(dirname, "dtrace"))
368
369 # Load all of the input files.
370 print("loading from %d data files" % len(input_files))
371 missing_symbols = set()
372 timestamped_symbol_lists = [
373 list(parse_dtrace_symbol_file(path, all_symbols, all_symbols_set,
374 missing_symbols, opts))
375 for path in input_files]
376
377 # Reorder each symbol list.
378 symbol_lists = []
379 for timestamped_symbols_list in timestamped_symbol_lists:
380 timestamped_symbols_list.sort()
381 symbol_lists.append([symbol for _,symbol in timestamped_symbols_list])
382
383 # Execute the desire order file generation method.
384 method = methods.get(opts.method)
385 result = list(method(symbol_lists))
386
387 # Report to the user on what percentage of symbols are present in the order
388 # file.
389 num_ordered_symbols = len(result)
390 if all_symbols:
391 print("note: order file contains %d/%d symbols (%.2f%%)" % (
392 num_ordered_symbols, len(all_symbols),
393 100.*num_ordered_symbols/len(all_symbols)), file=sys.stderr)
394
395 if opts.output_unordered_symbols_path:
396 ordered_symbols_set = set(result)
397 with open(opts.output_unordered_symbols_path, 'w') as f:
398 f.write("\n".join(s for s in all_symbols if s not in ordered_symbols_set))
399
400 # Write the order file.
401 with open(opts.output_path, 'w') as f:
402 f.write("\n".join(result))
403 f.write("\n")
404
405 return 0
406
407 commands = {'clean' : clean,
408 'merge' : merge,
409 'dtrace' : dtrace,
410 'cc1' : cc1,
411 'gen-order-file' : genOrderFile,
412 'merge-fdata' : merge_fdata,
413 }
414
415 def main():
416 f = commands[sys.argv[1]]
417 sys.exit(f(sys.argv[2:]))
418
419 if __name__ == '__main__':
420 main()