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