# ===- perf-helper.py - Clang Python Bindings -----------------*- python -*--===#
#
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#
# ===------------------------------------------------------------------------===#
from __future__ import absolute_import, division, print_function
import sys
import os
import subprocess
import argparse
import time
import bisect
import shlex
import tempfile
test_env = {"PATH": os.environ["PATH"]}
def findFilesWithExtension(path, extension):
filenames = []
for root, dirs, files in os.walk(path):
for filename in files:
if filename.endswith(f".{extension}"):
filenames.append(os.path.join(root, filename))
return filenames
def clean(args):
if len(args) < 2:
print(
"Usage: %s clean <paths> <extension>\n" % __file__
+ "\tRemoves all files with extension from <path>."
)
return 1
for path in args[1:-1]:
for filename in findFilesWithExtension(path, args[-1]):
os.remove(filename)
return 0
def merge(args):
if len(args) < 3:
print(
"Usage: %s merge <llvm-profdata> <output> <paths>\n" % __file__
+ "\tMerges all profraw files from path into output."
)
return 1
cmd = [args[0], "merge", "-o", args[1]]
for path in args[2:]:
cmd.extend(findFilesWithExtension(path, "profraw"))
subprocess.check_call(cmd)
return 0
def merge_fdata(args):
if len(args) != 3:
print(
"Usage: %s merge-fdata <merge-fdata> <output> <path>\n" % __file__
+ "\tMerges all fdata files from path into output."
)
return 1
cmd = [args[0], "-o", args[1]]
cmd.extend(findFilesWithExtension(args[2], "fdata"))
subprocess.check_call(cmd)
return 0
def perf(args):
parser = argparse.ArgumentParser(
prog="perf-helper perf", description="perf wrapper for BOLT profile collection"
)
parser.add_argument(
"--lbr", action="store_true", help="Use perf with branch stacks"
)
parser.add_argument("cmd", nargs=argparse.REMAINDER, help="")
opts = parser.parse_args(args)
cmd = opts.cmd[1:]
perf_args = [
"perf",
"record",
"--event=cycles:u",
"--freq=max",
"--output=%d.perf.data" % os.getpid(),
]
if opts.lbr:
perf_args += ["--branch-filter=any,u"]
perf_args.extend(cmd)
start_time = time.time()
subprocess.check_call(perf_args)
elapsed = time.time() - start_time
print("... data collection took %.4fs" % elapsed)
return 0
def perf2bolt(args):
parser = argparse.ArgumentParser(
prog="perf-helper perf2bolt",
description="perf2bolt conversion wrapper for perf.data files",
)
parser.add_argument("bolt", help="Path to llvm-bolt")
parser.add_argument("path", help="Path containing perf.data files")
parser.add_argument("binary", help="Input binary")
parser.add_argument("--lbr", action="store_true", help="Use LBR perf2bolt mode")
opts = parser.parse_args(args)
p2b_args = [
opts.bolt,
opts.binary,
"--aggregate-only",
"--profile-format=yaml",
]
if not opts.lbr:
p2b_args += ["-nl"]
p2b_args += ["-p"]
for filename in findFilesWithExtension(opts.path, "perf.data"):
subprocess.check_call(p2b_args + [filename, "-o", filename + ".fdata"])
return 0
def dtrace(args):
parser = argparse.ArgumentParser(
prog="perf-helper dtrace",
description="dtrace wrapper for order file generation",
)
parser.add_argument(
"--buffer-size",
metavar="size",
type=int,
required=False,
default=1,
help="dtrace buffer size in MB (default 1)",
)
parser.add_argument(
"--use-oneshot",
required=False,
action="store_true",
help="Use dtrace's oneshot probes",
)
parser.add_argument(
"--use-ustack",
required=False,
action="store_true",
help="Use dtrace's ustack to print function names",
)
parser.add_argument(
"--cc1",
required=False,
action="store_true",
help="Execute cc1 directly (don't profile the driver)",
)
parser.add_argument("cmd", nargs="*", help="")
# Use python's arg parser to handle all leading option arguments, but pass
# everything else through to dtrace
first_cmd = next(arg for arg in args if not arg.startswith("--"))
last_arg_idx = args.index(first_cmd)
opts = parser.parse_args(args[:last_arg_idx])
cmd = args[last_arg_idx:]
if opts.cc1:
cmd = get_cc1_command_for_args(cmd, test_env)
if opts.use_oneshot:
target = "oneshot$target:::entry"
else:
target = "pid$target:::entry"
predicate = '%s/probemod=="%s"/' % (target, os.path.basename(cmd[0]))
log_timestamp = 'printf("dtrace-TS: %d\\n", timestamp)'
if opts.use_ustack:
action = "ustack(1);"
else:
action = 'printf("dtrace-Symbol: %s\\n", probefunc);'
dtrace_script = "%s { %s; %s }" % (predicate, log_timestamp, action)
dtrace_args = []
if not os.geteuid() == 0:
print(
"Script must be run as root, or you must add the following to your sudoers:"
+ "%%admin ALL=(ALL) NOPASSWD: /usr/sbin/dtrace"
)
dtrace_args.append("sudo")
dtrace_args.extend(
(
"dtrace",
"-xevaltime=exec",
"-xbufsize=%dm" % (opts.buffer_size),
"-q",
"-n",
dtrace_script,
"-c",
" ".join(cmd),
)
)
if sys.platform == "darwin":
dtrace_args.append("-xmangled")
start_time = time.time()
with open("%d.dtrace" % os.getpid(), "w") as f:
f.write("### Command: %s" % dtrace_args)
subprocess.check_call(dtrace_args, stdout=f, stderr=subprocess.PIPE)
elapsed = time.time() - start_time
print("... data collection took %.4fs" % elapsed)
return 0
def get_cc1_command_for_args(cmd, env):
# Find the cc1 command used by the compiler. To do this we execute the
# compiler with '-###' to figure out what it wants to do.
cmd = cmd + ["-###"]
cc_output = subprocess.check_output(
cmd, stderr=subprocess.STDOUT, env=env, universal_newlines=True
).strip()
cc_commands = []
for ln in cc_output.split("\n"):
# Filter out known garbage.
if (
ln == "Using built-in specs."
or ln.startswith("Configured with:")
or ln.startswith("Target:")
or ln.startswith("Thread model:")
or ln.startswith("InstalledDir:")
or ln.startswith("LLVM Profile Note")
or ln.startswith(" (in-process)")
or " version " in ln
):
continue
cc_commands.append(ln)
if len(cc_commands) != 1:
print("Fatal error: unable to determine cc1 command: %r" % cc_output)
exit(1)
cc1_cmd = shlex.split(cc_commands[0])
if not cc1_cmd:
print("Fatal error: unable to determine cc1 command: %r" % cc_output)
exit(1)
return cc1_cmd
def cc1(args):
parser = argparse.ArgumentParser(
prog="perf-helper cc1", description="cc1 wrapper for order file generation"
)
parser.add_argument("cmd", nargs="*", help="")
# Use python's arg parser to handle all leading option arguments, but pass
# everything else through to dtrace
first_cmd = next(arg for arg in args if not arg.startswith("--"))
last_arg_idx = args.index(first_cmd)
opts = parser.parse_args(args[:last_arg_idx])
cmd = args[last_arg_idx:]
# clear the profile file env, so that we don't generate profdata
# when capturing the cc1 command
cc1_env = test_env
cc1_env["LLVM_PROFILE_FILE"] = os.devnull
cc1_cmd = get_cc1_command_for_args(cmd, cc1_env)
subprocess.check_call(cc1_cmd)
return 0
def parse_dtrace_symbol_file(path, all_symbols, all_symbols_set, missing_symbols, opts):
def fix_mangling(symbol):
if sys.platform == "darwin":
if symbol[0] != "_" and symbol != "start":
symbol = "_" + symbol
return symbol
def get_symbols_with_prefix(symbol):
start_index = bisect.bisect_left(all_symbols, symbol)
for s in all_symbols[start_index:]:
if not s.startswith(symbol):
break
yield s
# Extract the list of symbols from the given file, which is assumed to be
# the output of a dtrace run logging either probefunc or ustack(1) and
# nothing else. The dtrace -xdemangle option needs to be used.
#
# This is particular to OS X at the moment, because of the '_' handling.
with open(path) as f:
current_timestamp = None
for ln in f:
# Drop leading and trailing whitespace.
ln = ln.strip()
if not ln.startswith("dtrace-"):
continue
# If this is a timestamp specifier, extract it.
if ln.startswith("dtrace-TS: "):
_, data = ln.split(": ", 1)
if not data.isdigit():
print(
"warning: unrecognized timestamp line %r, ignoring" % ln,
file=sys.stderr,
)
continue
current_timestamp = int(data)
continue
elif ln.startswith("dtrace-Symbol: "):
_, ln = ln.split(": ", 1)
if not ln:
continue
# If there is a '`' in the line, assume it is a ustack(1) entry in
# the form of <modulename>`<modulefunc>, where <modulefunc> is never
# truncated (but does need the mangling patched).
if "`" in ln:
yield (current_timestamp, fix_mangling(ln.split("`", 1)[1]))
continue
# Otherwise, assume this is a probefunc printout. DTrace on OS X
# seems to have a bug where it prints the mangled version of symbols
# which aren't C++ mangled. We just add a '_' to anything but start
# which doesn't already have a '_'.
symbol = fix_mangling(ln)
# If we don't know all the symbols, or the symbol is one of them,
# just return it.
if not all_symbols_set or symbol in all_symbols_set:
yield (current_timestamp, symbol)
continue
# Otherwise, we have a symbol name which isn't present in the
# binary. We assume it is truncated, and try to extend it.
# Get all the symbols with this prefix.
possible_symbols = list(get_symbols_with_prefix(symbol))
if not possible_symbols:
continue
# If we found too many possible symbols, ignore this as a prefix.
if len(possible_symbols) > 100:
print(
"warning: ignoring symbol %r " % symbol
+ "(no match and too many possible suffixes)",
file=sys.stderr,
)
continue
# Report that we resolved a missing symbol.
if opts.show_missing_symbols and symbol not in missing_symbols:
print(
"warning: resolved missing symbol %r" % symbol, file=sys.stderr
)
missing_symbols.add(symbol)
# Otherwise, treat all the possible matches as having occurred. This
# is an over-approximation, but it should be ok in practice.
for s in possible_symbols:
yield (current_timestamp, s)
def uniq(list):
seen = set()
for item in list:
if item not in seen:
yield item
seen.add(item)
def form_by_call_order(symbol_lists):
# Simply strategy, just return symbols in order of occurrence, even across
# multiple runs.
return uniq(s for symbols in symbol_lists for s in symbols)
def form_by_call_order_fair(symbol_lists):
# More complicated strategy that tries to respect the call order across all
# of the test cases, instead of giving a huge preference to the first test
# case.
# First, uniq all the lists.
uniq_lists = [list(uniq(symbols)) for symbols in symbol_lists]
# Compute the successors for each list.
succs = {}
for symbols in uniq_lists:
for a, b in zip(symbols[:-1], symbols[1:]):
succs[a] = items = succs.get(a, [])
if b not in items:
items.append(b)
# Emit all the symbols, but make sure to always emit all successors from any
# call list whenever we see a symbol.
#
# There isn't much science here, but this sometimes works better than the
# more naive strategy. Then again, sometimes it doesn't so more research is
# probably needed.
return uniq(
s
for symbols in symbol_lists
for node in symbols
for s in ([node] + succs.get(node, []))
)
def form_by_frequency(symbol_lists):
# Form the order file by just putting the most commonly occurring symbols
# first. This assumes the data files didn't use the oneshot dtrace method.
counts = {}
for symbols in symbol_lists:
for a in symbols:
counts[a] = counts.get(a, 0) + 1
by_count = list(counts.items())
by_count.sort(key=lambda __n: -__n[1])
return [s for s, n in by_count]
def form_by_random(symbol_lists):
# Randomize the symbols.
merged_symbols = uniq(s for symbols in symbol_lists for s in symbols)
random.shuffle(merged_symbols)
return merged_symbols
def form_by_alphabetical(symbol_lists):
# Alphabetize the symbols.
merged_symbols = list(set(s for symbols in symbol_lists for s in symbols))
merged_symbols.sort()
return merged_symbols
methods = dict(
(name[len("form_by_") :], value)
for name, value in locals().items()
if name.startswith("form_by_")
)
def genOrderFile(args):
parser = argparse.ArgumentParser("%prog [options] <dtrace data file directories>]")
parser.add_argument("input", nargs="+", help="")
parser.add_argument(
"--binary",
metavar="PATH",
type=str,
dest="binary_path",
help="Path to the binary being ordered (for getting all symbols)",
default=None,
)
parser.add_argument(
"--output",
dest="output_path",
help="path to output order file to write",
default=None,
required=True,
metavar="PATH",
)
parser.add_argument(
"--show-missing-symbols",
dest="show_missing_symbols",
help="show symbols which are 'fixed up' to a valid name (requires --binary)",
action="store_true",
default=None,
)
parser.add_argument(
"--output-unordered-symbols",
dest="output_unordered_symbols_path",
help="write a list of the unordered symbols to PATH (requires --binary)",
default=None,
metavar="PATH",
)
parser.add_argument(
"--method",
dest="method",
help="order file generation method to use",
choices=list(methods.keys()),
default="call_order",
)
opts = parser.parse_args(args)
# If the user gave us a binary, get all the symbols in the binary by
# snarfing 'nm' output.
if opts.binary_path is not None:
output = subprocess.check_output(
["nm", "-P", opts.binary_path], universal_newlines=True
)
lines = output.split("\n")
all_symbols = [ln.split(" ", 1)[0] for ln in lines if ln.strip()]
print("found %d symbols in binary" % len(all_symbols))
all_symbols.sort()
else:
all_symbols = []
all_symbols_set = set(all_symbols)
# Compute the list of input files.
input_files = []
for dirname in opts.input:
input_files.extend(findFilesWithExtension(dirname, "dtrace"))
# Load all of the input files.
print("loading from %d data files" % len(input_files))
missing_symbols = set()
timestamped_symbol_lists = [
list(
parse_dtrace_symbol_file(
path, all_symbols, all_symbols_set, missing_symbols, opts
)
)
for path in input_files
]
# Reorder each symbol list.
symbol_lists = []
for timestamped_symbols_list in timestamped_symbol_lists:
timestamped_symbols_list.sort()
symbol_lists.append([symbol for _, symbol in timestamped_symbols_list])
# Execute the desire order file generation method.
method = methods.get(opts.method)
result = list(method(symbol_lists))
# Report to the user on what percentage of symbols are present in the order
# file.
num_ordered_symbols = len(result)
if all_symbols:
print(
"note: order file contains %d/%d symbols (%.2f%%)"
% (
num_ordered_symbols,
len(all_symbols),
100.0 * num_ordered_symbols / len(all_symbols),
),
file=sys.stderr,
)
if opts.output_unordered_symbols_path:
ordered_symbols_set = set(result)
with open(opts.output_unordered_symbols_path, "w") as f:
f.write("\n".join(s for s in all_symbols if s not in ordered_symbols_set))
# Write the order file.
with open(opts.output_path, "w") as f:
f.write("\n".join(result))
f.write("\n")
return 0
commands = {
"clean": clean,
"merge": merge,
"dtrace": dtrace,
"cc1": cc1,
"gen-order-file": genOrderFile,
"merge-fdata": merge_fdata,
"perf": perf,
"perf2bolt": perf2bolt,
}
def main():
f = commands[sys.argv[1]]
sys.exit(f(sys.argv[2:]))
if __name__ == "__main__":
main()
Codebase Browser
llvm