def setup_microbenchmark(workitem_directory, arch):
""" Perform setup of microbenchmarks
Args:
workitem_directory (string): Path to work
arch (string): Architecture for which dotnet will be installed
"""
performance_directory = os.path.join(workitem_directory, "performance")
run_command([
"git", "clone", "--quiet", "--depth", "1",
"https://github.com/dotnet/performance", performance_directory
])
with ChangeDir(performance_directory):
dotnet_directory = os.path.join(performance_directory, "tools",
"dotnet", arch)
dotnet_install_script = os.path.join(performance_directory, "scripts",
"dotnet.py")
if not os.path.isfile(dotnet_install_script):
print("Missing " + dotnet_install_script)
return
run_command(get_python_name() + [
dotnet_install_script, "install", "--architecture", arch,
"--install-dir", dotnet_directory, "--verbose"
])
def make_readable(folder_name):
"""Make file executable by changing the permission
Args:
folder_name (string): folder to mark with 744
"""
if is_windows:
return
print("Inside make_readable")
run_command(["ls", "-l", folder_name])
for file_path, dirs, files in os.walk(folder_name, topdown=True):
for d in dirs:
os.chmod(
os.path.join(file_path, d),
# read+write+execute for owner
(stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) |
# read for group
(stat.S_IRGRP) |
# read for other
(stat.S_IROTH))
for f in files:
os.chmod(
os.path.join(file_path, f),
# read+write+execute for owner
(stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) |
# read for group
(stat.S_IRGRP) |
# read for other
(stat.S_IROTH))
run_command(["ls", "-l", folder_name])
def strip_unrelated_mc(coreclr_args, old_mch_filename, new_mch_filename):
"""Perform the post processing of produced .mch file by stripping the method contexts
that are specific to BenchmarkDotnet boilerplate code and hard
Args:
coreclr_args (CoreclrArguments): Arguments
old_mch_filename (string): Name of source .mch file
new_mch_filename (string): Name of new .mch file to produce post-processing.
"""
performance_directory = coreclr_args.performance_directory
core_root = coreclr_args.core_root
methods_to_strip_list = os.path.join(performance_directory,
"methods_to_strip.mcl")
mcs_exe = os.path.join(core_root, "mcs")
mcs_command = [mcs_exe, "-dumpMap", old_mch_filename]
# Gather method list to strip
(mcs_out, _, return_code) = run_command(mcs_command)
if return_code != 0:
# If strip command fails, then just copy the old_mch to new_mch
print(
f"-dumpMap failed. Copying {old_mch_filename} to {new_mch_filename}."
)
copyfile(old_mch_filename, new_mch_filename)
copyfile(old_mch_filename + ".mct", new_mch_filename + ".mct")
return
method_context_list = mcs_out.decode("utf-8").split(os.linesep)
filtered_context_list = []
match_pattern = re.compile('^(\\d+),(BenchmarkDotNet|Perfolizer)')
print("Method indices to strip:")
for mc_entry in method_context_list:
matched = match_pattern.match(mc_entry)
if matched:
print(matched.group(1))
filtered_context_list.append(matched.group(1))
print(f"Total {len(filtered_context_list)} methods.")
with open(methods_to_strip_list, "w") as f:
f.write('\n'.join(filtered_context_list))
# Strip and produce new .mcs file
if run_command([
mcs_exe, "-strip", methods_to_strip_list, old_mch_filename,
new_mch_filename
])[2] != 0:
# If strip command fails, then just copy the old_mch to new_mch
print(
f"-strip failed. Copying {old_mch_filename} to {new_mch_filename}."
)
copyfile(old_mch_filename, new_mch_filename)
copyfile(old_mch_filename + ".mct", new_mch_filename + ".mct")
return
# Create toc file
run_command([mcs_exe, "-toc", new_mch_filename])
def main(main_args):
"""Main entrypoint
Args:
main_args ([type]): Arguments to the script
"""
coreclr_args = setup_args(main_args)
antigen_directory = coreclr_args.antigen_directory
core_root = coreclr_args.core_root
tag_name = "{}-{}".format(coreclr_args.run_configuration,
coreclr_args.partition)
output_directory = coreclr_args.output_directory
run_duration = coreclr_args.run_duration
if not run_duration:
run_duration = 60
path_to_corerun = os.path.join(core_root, "corerun")
path_to_tool = os.path.join(antigen_directory, "Antigen")
if is_windows:
path_to_corerun += ".exe"
path_to_tool += ".exe"
if not is_windows:
# Disable core dumps. The fuzzers have their own graceful handling for
# runtime crashes. Especially on macOS we can quickly fill up the drive
# with dumps if we find lots of crashes since dumps there are very big.
import resource
resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
try:
# Run tool such that issues are placed in a temp folder
with TempDir() as temp_location:
antigen_log = path.join(temp_location,
get_antigen_filename(tag_name))
run_command([
path_to_tool, "-c", path_to_corerun, "-o", temp_location, "-d",
str(run_duration)
],
_exit_on_fail=True,
_output_file=antigen_log)
# Copy issues for upload
print("Copying issues to " + output_directory)
copy_issues(temp_location, output_directory, tag_name)
except PermissionError as pe:
print("Got error: %s", pe)
def run(self):
num_reduced = 0
while not self.exit_evt.wait(0.5):
try:
new_line = self.examples_file.readline()
except ValueError:
# File closed, means other thread exited (probably ctrl-C)
return
if new_line:
evt = json.loads(new_line)
# Only reduce BadResult examples since crashes take very long to reduce.
# We will still report crashes, just not with a reduced example.
if evt["Kind"] == "ExampleFound":
ex = evt["Example"]
ex_assert_err = None
reduce_this = False
if ex["Kind"] == "BadResult":
reduce_this = True
elif ex["Kind"] == "HitsJitAssert":
ex_assert_err = extract_jit_assertion_error(
ex["Message"])
reduce_this = ex_assert_err is not None and ex_assert_err not in self.reduced_jit_asserts
if reduce_this:
print("Reducing {}".format(ex['Seed']))
output_path = path.join(self.examples_dir,
str(ex["Seed"]) + ".cs")
cmd = [
self.fuzzlyn_path, "--host", self.host_path,
"--reduce", "--seed",
str(ex['Seed']), "--output", output_path
]
run_command(cmd)
if path.exists(output_path):
num_reduced += 1
if num_reduced >= 5:
print(
"Skipping reduction of remaining examples (reached limit of 5)"
)
return
if ex_assert_err is not None:
self.reduced_jit_asserts.add(ex_assert_err)
def make_executable(file_name):
"""Make file executable by changing the permission
Args:
file_name (string): file to execute
"""
if is_windows:
return
print("Inside make_executable")
run_command(["ls", "-l", file_name])
os.chmod(file_name,
# read+execute for owner
(stat.S_IRUSR | stat.S_IXUSR) |
# read+execute for group
(stat.S_IRGRP | stat.S_IXGRP) |
# read+execute for other
(stat.S_IROTH | stat.S_IXOTH))
run_command(["ls", "-l", file_name])
def main(main_args):
"""Main entrypoint
Args:
main_args ([type]): Arguments to the script
"""
coreclr_args = setup_args(main_args)
antigen_directory = coreclr_args.antigen_directory
core_root = coreclr_args.core_root
tag_name = "{}-{}".format(coreclr_args.run_configuration,
coreclr_args.partition)
output_directory = coreclr_args.output_directory
run_duration = coreclr_args.run_duration
if not run_duration:
run_duration = 60
path_to_corerun = os.path.join(core_root, "corerun")
path_to_tool = os.path.join(antigen_directory, "Antigen")
if is_windows:
path_to_corerun += ".exe"
path_to_tool += ".exe"
try:
# Run tool such that issues are placed in a temp folder
with TempDir() as temp_location:
antigen_log = path.join(temp_location,
get_antigen_filename(tag_name))
run_command([
path_to_tool, "-c", path_to_corerun, "-o", temp_location, "-d",
str(run_duration)
],
_exit_on_fail=True,
_output_file=antigen_log)
# Copy issues for upload
print("Copying issues to " + output_directory)
copy_issues(temp_location, output_directory, tag_name)
except PermissionError as pe:
print("Got error: %s", pe)
def main(main_args):
"""Main entrypoint
Args:
main_args ([type]): Arguments to the script
"""
python_path = sys.executable
cwd = os.path.dirname(os.path.realpath(__file__))
coreclr_args = setup_args(main_args)
spmi_location = os.path.join(cwd, "artifacts", "spmi")
log_directory = coreclr_args.log_directory
platform_name = coreclr_args.platform
os_name = "win" if platform_name.lower() == "windows" else "unix"
arch_name = coreclr_args.arch
host_arch_name = "x64" if arch_name.endswith("64") else "x86"
os_name = "universal" if arch_name.startswith("arm") else os_name
jit_path = os.path.join(coreclr_args.jit_directory, 'clrjit_{}_{}_{}.dll'.format(os_name, arch_name, host_arch_name))
print("Running superpmi.py download")
run_command([python_path, os.path.join(cwd, "superpmi.py"), "download", "--no_progress", "-target_os", platform_name,
"-target_arch", arch_name, "-core_root", cwd, "-spmi_location", spmi_location], _exit_on_fail=True)
failed_runs = []
for jit_flag in jit_flags:
log_file = os.path.join(log_directory, 'superpmi_{}.log'.format(jit_flag.replace("=", "_")))
print("Running superpmi.py replay for {}".format(jit_flag))
_, _, return_code = run_command([
python_path,
os.path.join(cwd, "superpmi.py"),
"replay",
"-core_root", cwd,
"-jitoption", jit_flag,
"-jitoption", "TieredCompilation=0",
"-target_os", platform_name,
"-target_arch", arch_name,
"-arch", host_arch_name,
"-jit_path", jit_path,
"-spmi_location", spmi_location,
"-log_level", "debug",
"-log_file", log_file])
if return_code != 0:
failed_runs.append("Failure in {}".format(log_file))
# Consolidate all superpmi_*.logs in superpmi_platform_architecture.log
final_log_name = os.path.join(log_directory, "superpmi_{}_{}.log".format(platform_name, arch_name))
print("Consolidating final {}".format(final_log_name))
with open(final_log_name, "a") as final_superpmi_log:
for superpmi_log in os.listdir(log_directory):
if not superpmi_log.startswith("superpmi_Jit") or not superpmi_log.endswith(".log"):
continue
print("Appending {}".format(superpmi_log))
final_superpmi_log.write("======================================================={}".format(os.linesep))
final_superpmi_log.write("Contents from {}{}".format(superpmi_log, os.linesep))
final_superpmi_log.write("======================================================={}".format(os.linesep))
with open(os.path.join(log_directory, superpmi_log), "r") as current_superpmi_log:
contents = current_superpmi_log.read()
final_superpmi_log.write(contents)
# Log failures summary
if len(failed_runs) > 0:
final_superpmi_log.write(os.linesep)
final_superpmi_log.write(os.linesep)
final_superpmi_log.write("========Failed runs summary========".format(os.linesep))
final_superpmi_log.write(os.linesep.join(failed_runs))
return 0 if len(failed_runs) == 0 else 1
def build_and_run(coreclr_args):
"""Run perf scenarios under crank and collect data with SPMI"
Args:
coreclr_args (CoreClrArguments): Arguments use to drive
output_mch_name (string): Name of output mch file name
"""
source_directory = coreclr_args.source_directory
target_arch = coreclr_args.arch
target_os = coreclr_args.host_os
checked_root = path.join(source_directory, "artifacts", "bin", "coreclr", target_os + "." + coreclr_args.arch + ".Checked")
release_root = path.join(source_directory, "artifacts", "bin", "coreclr", target_os + "." + coreclr_args.arch + ".Release")
# We'll use repo script to install dotnet
dotnet_install_script_name = "dotnet-install.cmd" if is_windows else "dotnet-install.sh"
dotnet_install_script_path = path.join(source_directory, "eng", "common", dotnet_install_script_name)
with TempDir(skip_cleanup=True) as temp_location:
print ("Executing in " + temp_location)
# install dotnet 6.0
run_command([dotnet_install_script_path, "-Version", "6.0.4"], temp_location, _exit_on_fail=True)
os.environ['DOTNET_MULTILEVEL_LOOKUP'] = '0'
os.environ['DOTNET_SKIP_FIRST_TIME_EXPERIENCE'] = '1'
dotnet_path = path.join(source_directory, ".dotnet")
dotnet_exe = path.join(dotnet_path, "dotnet.exe") if is_windows else path.join(dotnet_path, "dotnet")
run_command([dotnet_exe, "--info"], temp_location, _exit_on_fail=True)
os.environ['DOTNET_ROOT'] = dotnet_path
## install crank as local tool
run_command(
[dotnet_exe, "tool", "install", "Microsoft.Crank.Controller", "--version", "0.2.0-*", "--tool-path", temp_location], _exit_on_fail=True)
## ideally just do sparse clone, but this doesn't work locally
## git clone --filter=blob:none --no-checkout https://github.com/aspnet/benchmarks
## cd benchmarks
## git sparse-checkout init --cone
## git sparse-checkout set scenarios
## could probably just pass a URL and avoid this
run_command(
["git", "clone", "--quiet", "--depth", "1", "https://github.com/aspnet/benchmarks"], temp_location, _exit_on_fail=True)
crank_app = path.join(temp_location, "crank")
mcs_path = determine_mcs_tool_path(coreclr_args)
superpmi_path = determine_superpmi_tool_path(coreclr_args)
# todo: add grpc/signalr, perhaps
configname_scenario_list = [
("platform", "plaintext"),
("json", "json"),
("plaintext", "mvc"),
("database", "fortunes_dapper"),
("database", "fortunes_ef_mvc_https"),
("database", "updates"),
("proxy", "proxy-yarp"),
("staticfiles", "static"),
("websocket", "websocket"),
("orchard", "about-sqlite")
]
# configname_scenario_list = [("platform", "plaintext")]
# note tricks to get one element tuples
runtime_options_list = [("Dummy=0",), ("TieredCompilation=0", ), ("TieredPGO=1",), ("TieredPGO=1", "ReadyToRun=0"),
("ReadyToRun=0", "OSR_HitLimit=0", "TC_OnStackReplacement_InitialCounter=10"),
("TieredPGO=1", "ReadyToRun=0", "OSR_HitLimit=0", "TC_OnStackReplacement_InitialCounter=10")]
# runtime_options_list = [("TieredCompilation=0", )]
mch_file = path.join(coreclr_args.output_mch_path, "aspnet.run." + target_os + "." + target_arch + ".checked.mch")
benchmark_machine = determine_benchmark_machine(coreclr_args)
jitname = determine_native_name(coreclr_args, "clrjit", target_os)
coreclrname = determine_native_name(coreclr_args, "coreclr", target_os)
spminame = determine_native_name(coreclr_args, "superpmi-shim-collector", target_os)
corelibname = "System.Private.CoreLib.dll"
jitpath = path.join(".", jitname)
jitlib = path.join(checked_root, jitname)
coreclr = path.join(release_root, coreclrname)
corelib = path.join(release_root, corelibname)
spmilib = path.join(checked_root, spminame)
for (configName, scenario) in configname_scenario_list:
configYml = configName + ".benchmarks.yml"
configFile = path.join(temp_location, "benchmarks", "scenarios", configYml)
crank_arguments = ["--config", configFile,
"--profile", benchmark_machine,
"--scenario", scenario,
"--application.framework", "net7.0",
"--application.channel", "edge",
"--application.sdkVersion", "latest",
"--application.environmentVariables", "COMPlus_JitName=" + spminame,
"--application.environmentVariables", "SuperPMIShimLogPath=.",
"--application.environmentVariables", "SuperPMIShimPath=" + jitpath,
"--application.environmentVariables", "COMPlus_EnableExtraSuperPmiQueries=1",
"--application.options.downloadFiles", "*.mc",
"--application.options.displayOutput", "true",
# "--application.options.dumpType", "full",
# "--application.options.fetch", "true",
"--application.options.outputFiles", spmilib,
"--application.options.outputFiles", jitlib,
"--application.options.outputFiles", coreclr,
"--application.options.outputFiles", corelib]
for runtime_options in runtime_options_list:
runtime_arguments = []
for runtime_option in runtime_options:
runtime_arguments.append("--application.environmentVariables")
runtime_arguments.append("COMPlus_" + runtime_option)
print("")
print("================================")
print("Config: " + configName + " scenario: " + scenario + " options: " + " ".join(runtime_options))
print("================================")
print("")
description = ["--description", configName + "-" + scenario + "-" + "-".join(runtime_options)]
subprocess.run([crank_app] + crank_arguments + description + runtime_arguments, cwd=temp_location)
# merge
command = [mcs_path, "-merge", "temp.mch", "*.mc", "-dedup", "-thin"]
run_command(command, temp_location)
# clean
command = [superpmi_path, "-v", "ewmi", "-f", "fail.mcl", jitlib, "temp.mch"]
run_command(command, temp_location)
# strip
if is_nonzero_length_file("fail.mcl"):
print("Replay had failures, cleaning...");
fail_file = path.join(coreclr_args.output_mch_path, "fail.mcl");
command = [mcs_path, "-strip", "fail.mcl", "temp.mch", mch_file]
run_command(command, temp_location)
else:
print("Replay was clean...");
shutil.copy2("temp.mch", mch_file)
# index
command = [mcs_path, "-toc", mch_file]
run_command(command, temp_location)
# overall summary
print("Merged summary for " + mch_file)
command = [mcs_path, "-jitflags", mch_file]
run_command(command, temp_location)
def main(main_args):
""" Run superpmi asmdiffs process on the Helix machines.
See superpmi_asmdiffs_checked_release_setup.py for how the directory structure is set up
in the correlation payload. This script lives in the root of that directory tree.
Args:
main_args ([type]): Arguments to the script
"""
python_path = sys.executable
script_dir = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
coreclr_args = setup_args(main_args)
# It doesn't really matter where we put the downloaded SPMI artifacts.
# Here, they are put in <correlation_payload>/artifacts/spmi.
spmi_location = os.path.join(script_dir, "artifacts", "spmi")
log_directory = coreclr_args.log_directory
platform_name = coreclr_args.platform
# Figure out which JITs to use
os_name = "win" if platform_name.lower() == "windows" else "unix"
arch_name = coreclr_args.arch
host_arch_name = "x64" if arch_name.endswith("64") else "x86"
os_name = "universal" if arch_name.startswith("arm") else os_name
base_jit_path = os.path.join(
coreclr_args.base_jit_directory,
'clrjit_{}_{}_{}.dll'.format(os_name, arch_name, host_arch_name))
diff_jit_path = os.path.join(
coreclr_args.diff_jit_directory,
'clrjit_{}_{}_{}.dll'.format(os_name, arch_name, host_arch_name))
# Core_Root is where the superpmi tools (superpmi.exe, mcs.exe) are expected to be found.
# We pass the full path of the JITs to use as arguments.
core_root_dir = script_dir
print("Running superpmi.py download to get MCH files")
log_file = os.path.join(
log_directory,
"superpmi_download_{}_{}.log".format(platform_name, arch_name))
run_command([
python_path,
os.path.join(script_dir, "superpmi.py"), "download", "--no_progress",
"-core_root", core_root_dir, "-target_os", platform_name,
"-target_arch", arch_name, "-spmi_location", spmi_location,
"-log_level", "debug", "-log_file", log_file
],
_exit_on_fail=True)
print("Running superpmi.py asmdiffs between checked and release binaries")
log_file = os.path.join(
log_directory, "superpmi_{}_{}.log".format(platform_name, arch_name))
_, _, return_code = run_command([
python_path,
os.path.join(script_dir, "superpmi.py"), "asmdiffs",
"--diff_with_release", "--no_progress", "-core_root", core_root_dir,
"-target_os", platform_name, "-target_arch", arch_name, "-arch",
host_arch_name, "-base_jit_path", base_jit_path, "-diff_jit_path",
diff_jit_path, "-spmi_location", spmi_location, "-error_limit", "100",
"-log_level", "debug", "-log_file", log_file
])
# TODO: the superpmi.py asmdiffs command returns a failure code if there are MISSING data even if there are
# no asm diffs. We should probably only fail if there are actual failures (not MISSING or asm diffs).
if return_code != 0:
print("Failure in {}".format(log_file))
return 1
return 0
def main(main_args):
""" Prepare the Helix data for SuperPMI asmdiffs Azure DevOps pipeline.
The Helix correlation payload directory is created and populated as follows:
<source_directory>\payload -- the correlation payload directory
-- contains the *.py scripts from <source_directory>\src\coreclr\scripts
-- contains superpmi.exe, mcs.exe from the target-specific build
<source_directory>\payload\base
-- contains the baseline JITs
<source_directory>\payload\diff
-- contains the diff JITs
<source_directory>\payload\jit-analyze
-- contains the self-contained jit-analyze build (from dotnet/jitutils)
<source_directory>\payload\git
-- contains a Portable ("xcopy installable") `git` tool, downloaded from:
https://netcorenativeassets.blob.core.windows.net/resource-packages/external/windows/git/Git-2.32.0-64-bit.zip
This is needed by jit-analyze to do `git diff` on the generated asm. The `<source_directory>\payload\git\cmd`
directory is added to the PATH.
NOTE: this only runs on Windows.
Then, AzDO pipeline variables are set.
Args:
main_args ([type]): Arguments to the script
Returns:
0 on success, otherwise a failure code
"""
# Set up logging.
logger = logging.getLogger()
logger.setLevel(logging.INFO)
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setLevel(logging.INFO)
logger.addHandler(stream_handler)
coreclr_args = setup_args(main_args)
arch = coreclr_args.arch
source_directory = coreclr_args.source_directory
product_directory = coreclr_args.product_directory
python_path = sys.executable
# CorrelationPayload directories
correlation_payload_directory = os.path.join(source_directory, "payload")
superpmi_scripts_directory = os.path.join(source_directory, 'src', 'coreclr', 'scripts')
base_jit_directory = os.path.join(correlation_payload_directory, "base")
diff_jit_directory = os.path.join(correlation_payload_directory, "diff")
jit_analyze_build_directory = os.path.join(correlation_payload_directory, "jit-analyze")
git_directory = os.path.join(correlation_payload_directory, "git")
######## Get the portable `git` package
git_url = "https://netcorenativeassets.blob.core.windows.net/resource-packages/external/windows/git/Git-2.32.0-64-bit.zip"
print('Downloading {} -> {}'.format(git_url, git_directory))
urls = [ git_url ]
# There are too many files to be verbose in the download and copy.
download_files(urls, git_directory, verbose=False, display_progress=False)
git_exe_tool = os.path.join(git_directory, "cmd", "git.exe")
if not os.path.isfile(git_exe_tool):
print('Error: `git` not found at {}'.format(git_exe_tool))
return 1
######## Get SuperPMI python scripts
# Copy *.py to CorrelationPayload
print('Copying {} -> {}'.format(superpmi_scripts_directory, correlation_payload_directory))
copy_directory(superpmi_scripts_directory, correlation_payload_directory, verbose_copy=True,
match_func=lambda path: any(path.endswith(extension) for extension in [".py"]))
######## Get baseline JIT
# Figure out which baseline JIT to use, and download it.
if not os.path.exists(base_jit_directory):
os.makedirs(base_jit_directory)
print("Fetching history of `main` branch so we can find the baseline JIT")
run_command(["git", "fetch", "--depth=500", "origin", "main"], source_directory, _exit_on_fail=True)
# Note: we only support downloading Windows versions of the JIT currently. To support downloading
# non-Windows JITs on a Windows machine, pass `-host_os <os>` to jitrollingbuild.py.
print("Running jitrollingbuild.py download to get baseline JIT")
jit_rolling_build_script = os.path.join(superpmi_scripts_directory, "jitrollingbuild.py")
_, _, return_code = run_command([
python_path,
jit_rolling_build_script,
"download",
"-arch", arch,
"-target_dir", base_jit_directory],
source_directory)
if return_code != 0:
print('{} failed with {}'.format(jit_rolling_build_script, return_code))
return return_code
######## Get diff JIT
print('Copying diff binaries {} -> {}'.format(product_directory, diff_jit_directory))
copy_directory(product_directory, diff_jit_directory, verbose_copy=True, match_func=match_jit_files)
######## Get SuperPMI tools
# Put the SuperPMI tools directly in the root of the correlation payload directory.
print('Copying SuperPMI tools {} -> {}'.format(product_directory, correlation_payload_directory))
copy_directory(product_directory, correlation_payload_directory, verbose_copy=True, match_func=match_superpmi_tool_files)
######## Clone and build jitutils: we only need jit-analyze
try:
with TempDir() as jitutils_directory:
run_command(
["git", "clone", "--quiet", "--depth", "1", "https://github.com/dotnet/jitutils", jitutils_directory])
# Make sure ".dotnet" directory exists, by running the script at least once
dotnet_script_name = "dotnet.cmd" if is_windows else "dotnet.sh"
dotnet_script_path = os.path.join(source_directory, dotnet_script_name)
run_command([dotnet_script_path, "--info"], jitutils_directory)
# Build jit-analyze only, and build it as a self-contained app (not framework-dependent).
# What target RID are we building? It depends on where we're going to run this code.
# The RID catalog is here: https://docs.microsoft.com/en-us/dotnet/core/rid-catalog.
# Windows x64 => win-x64
# Windows x86 => win-x86
# Windows arm32 => win-arm
# Windows arm64 => win-arm64
# Linux x64 => linux-x64
# Linux arm32 => linux-arm
# Linux arm64 => linux-arm64
# macOS x64 => osx-x64
# NOTE: we currently only support running on Windows x86/x64 (we don't pass the target OS)
RID = None
if arch == "x86":
RID = "win-x86"
if arch == "x64":
RID = "win-x64"
# Set dotnet path to run build
os.environ["PATH"] = os.path.join(source_directory, ".dotnet") + os.pathsep + os.environ["PATH"]
run_command([
"dotnet",
"publish",
"-c", "Release",
"--runtime", RID,
"--self-contained",
"--output", jit_analyze_build_directory,
os.path.join(jitutils_directory, "src", "jit-analyze", "jit-analyze.csproj")],
jitutils_directory)
except PermissionError as pe_error:
# Details: https://bugs.python.org/issue26660
print('Ignoring PermissionError: {0}'.format(pe_error))
jit_analyze_tool = os.path.join(jit_analyze_build_directory, "jit-analyze.exe")
if not os.path.isfile(jit_analyze_tool):
print('Error: {} not found'.format(jit_analyze_tool))
return 1
######## Set pipeline variables
helix_source_prefix = "official"
creator = ""
print('Setting pipeline variables:')
set_pipeline_variable("CorrelationPayloadDirectory", correlation_payload_directory)
set_pipeline_variable("Architecture", arch)
set_pipeline_variable("Creator", creator)
set_pipeline_variable("HelixSourcePrefix", helix_source_prefix)
return 0
def main(main_args):
"""Main entrypoint
Args:
main_args ([type]): Arguments to the script
"""
coreclr_args = setup_args(main_args)
fuzzlyn_directory = coreclr_args.fuzzlyn_directory
core_root = coreclr_args.core_root
tag_name = "{}-{}".format(coreclr_args.run_configuration,
coreclr_args.partition)
output_directory = coreclr_args.output_directory
if not coreclr_args.run_duration:
run_duration = 60 * 60 # 60 minutes by default
else:
run_duration = int(
coreclr_args.run_duration) * 60 # Run for duration in seconds
path_to_corerun = os.path.join(core_root, "corerun")
path_to_tool = os.path.join(fuzzlyn_directory, "Fuzzlyn")
if is_windows:
path_to_corerun += ".exe"
path_to_tool += ".exe"
os.makedirs(output_directory, exist_ok=True)
with TempDir() as temp_location:
summary_file_name = "issues-summary-{}.txt".format(tag_name)
summary_file_path = path.join(temp_location, summary_file_name)
with open(summary_file_path, 'w'):
pass
upload_fuzzer_output_path = path.join(
output_directory, "Fuzzlyn-{}.log".format(tag_name))
with open(summary_file_path, 'r') as fp:
exit_evt = threading.Event()
reduce_examples = ReduceExamples(fp, temp_location, path_to_tool,
path_to_corerun, exit_evt)
reduce_examples.start()
run_command([
path_to_tool, "--seconds-to-run",
str(run_duration), "--output-events-to", summary_file_path,
"--host", path_to_corerun, "--parallelism", "-1"
],
_exit_on_fail=True,
_output_file=upload_fuzzer_output_path)
exit_evt.set()
reduce_examples.join()
upload_summary_file_path = path.join(output_directory,
summary_file_name)
print("Copying summary: {} -> {}".format(summary_file_path,
upload_summary_file_path))
shutil.copy2(summary_file_path, upload_summary_file_path)
upload_issues_zip_path = path.join(output_directory,
"AllIssues-{}".format(tag_name))
print("Creating zip {}.zip".format(upload_issues_zip_path))
shutil.make_archive(upload_issues_zip_path, 'zip', temp_location)
def main(main_args):
"""Main entrypoint
Args:
main_args ([type]): Arguments to the script
"""
coreclr_args = setup_args(main_args)
arch_name = coreclr_args.arch
os_name = "win" if coreclr_args.platform.lower() == "windows" else "linux"
run_configuration = "{}-{}".format(os_name, arch_name)
source_directory = coreclr_args.source_directory
# CorrelationPayload directories
correlation_payload_directory = path.join(coreclr_args.source_directory,
"payload")
scripts_src_directory = path.join(source_directory, "src", "coreclr",
'scripts')
coreroot_directory = path.join(correlation_payload_directory, "CoreRoot")
dst_directory = path.join(correlation_payload_directory, "exploratory")
helix_source_prefix = "official"
creator = ""
repo_urls = {
"Antigen": "https://github.com/kunalspathak/Antigen.git",
"Fuzzlyn": "https://github.com/jakobbotsch/Fuzzlyn.git",
}
# tool_name is verifed in setup_args
assert coreclr_args.tool_name in repo_urls
repo_url = repo_urls[coreclr_args.tool_name]
# create exploratory directory
print('Copying {} -> {}'.format(scripts_src_directory, coreroot_directory))
copy_directory(scripts_src_directory,
coreroot_directory,
verbose_output=True,
match_func=lambda path: any(
path.endswith(extension) for extension in [".py"]))
if is_windows:
acceptable_copy = lambda path: any(
path.endswith(extension)
for extension in [".py", ".dll", ".exe", ".json"])
else:
# Need to accept files without any extension, which is how executable file's names look.
acceptable_copy = lambda path: (os.path.basename(path).find(
".") == -1) or any(
path.endswith(extension)
for extension in [".py", ".dll", ".so", ".json", ".a"])
# copy CORE_ROOT
print('Copying {} -> {}'.format(coreclr_args.core_root_directory,
coreroot_directory))
copy_directory(coreclr_args.core_root_directory,
coreroot_directory,
verbose_output=True,
match_func=acceptable_copy)
try:
with TempDir() as tool_code_directory:
# clone the tool
run_command([
"git", "clone", "--quiet", "--depth", "1", repo_url,
tool_code_directory
])
publish_dir = path.join(tool_code_directory, "publish")
# build the tool
with ChangeDir(tool_code_directory):
dotnet_cmd = os.path.join(source_directory, "dotnet.cmd")
if not is_windows:
dotnet_cmd = os.path.join(source_directory, "dotnet.sh")
run_command([
dotnet_cmd, "publish", "-c", "Release", "--self-contained",
"-r", run_configuration, "-o", publish_dir
],
_exit_on_fail=True)
dll_name = coreclr_args.tool_name + ".dll"
if not os.path.exists(path.join(publish_dir, dll_name)):
raise FileNotFoundError("{} not present at {}".format(
dll_name, publish_dir))
# copy tool
print('Copying {} -> {}'.format(publish_dir, dst_directory))
copy_directory(publish_dir,
dst_directory,
verbose_output=True,
match_func=acceptable_copy)
except PermissionError as pe:
print("Skipping file. Got error: %s", pe)
# create foo.txt in work_item directories
workitem_directory = path.join(source_directory, "workitem")
os.mkdir(workitem_directory)
foo_txt = os.path.join(workitem_directory, "foo.txt")
with open(foo_txt, "w") as foo_txt_file:
foo_txt_file.write("hello world!")
# Set variables
print('Setting pipeline variables:')
set_pipeline_variable("CorrelationPayloadDirectory",
correlation_payload_directory)
set_pipeline_variable("WorkItemDirectory", workitem_directory)
set_pipeline_variable("RunConfiguration", run_configuration)
set_pipeline_variable("Creator", creator)
set_pipeline_variable("HelixSourcePrefix", helix_source_prefix)
def build_and_run(coreclr_args, output_mch_name):
"""Build the microbenchmarks and run them under "superpmi collect"
Args:
coreclr_args (CoreClrArguments): Arguments use to drive
output_mch_name (string): Name of output mch file name
"""
arch = coreclr_args.arch
python_path = sys.executable
core_root = coreclr_args.core_root
superpmi_directory = coreclr_args.superpmi_directory
performance_directory = coreclr_args.performance_directory
log_file = coreclr_args.log_file
partition_count = coreclr_args.partition_count
partition_index = coreclr_args.partition_index
dotnet_directory = os.path.join(performance_directory, "tools", "dotnet", arch)
dotnet_exe = os.path.join(dotnet_directory, "dotnet")
artifacts_directory = os.path.join(performance_directory, "artifacts")
artifacts_packages_directory = os.path.join(artifacts_directory, "packages")
project_file = path.join(performance_directory, "src", "benchmarks", "micro", "MicroBenchmarks.csproj")
benchmarks_dll = path.join(artifacts_directory, "MicroBenchmarks.dll")
# Workaround https://github.com/dotnet/sdk/issues/23430
project_file = realpath(project_file)
if is_windows:
shim_name = "%JitName%"
corerun_exe = "CoreRun.exe"
script_name = "run_microbenchmarks.bat"
else:
shim_name = "$JitName"
corerun_exe = "corerun"
script_name = "run_microbenchmarks.sh"
make_executable(dotnet_exe)
run_command(
[dotnet_exe, "restore", project_file, "--packages",
artifacts_packages_directory], _exit_on_fail=True)
run_command(
[dotnet_exe, "build", project_file, "--configuration", "Release",
"--framework", "net7.0", "--no-restore", "/p:NuGetPackageRoot=" + artifacts_packages_directory,
"-o", artifacts_directory], _exit_on_fail=True)
# Disable ReadyToRun so we always JIT R2R methods and collect them
collection_command = f"{dotnet_exe} {benchmarks_dll} --filter \"*\" --corerun {path.join(core_root, corerun_exe)} --partition-count {partition_count} " \
f"--partition-index {partition_index} --envVars COMPlus_JitName:{shim_name} " \
" COMPlus_ZapDisable:1 COMPlus_ReadyToRun:0 " \
"--iterationCount 1 --warmupCount 0 --invocationCount 1 --unrollFactor 1 --strategy ColdStart"
# Generate the execution script in Temp location
with TempDir() as temp_location:
script_name = path.join(temp_location, script_name)
contents = []
# Unset the JitName so dotnet process will not fail
if is_windows:
contents.append("set JitName=%COMPlus_JitName%")
contents.append("set COMPlus_JitName=")
else:
contents.append("#!/bin/bash")
contents.append("export JitName=$COMPlus_JitName")
contents.append("unset COMPlus_JitName")
contents.append(f"pushd {performance_directory}")
contents.append(collection_command)
with open(script_name, "w") as collection_script:
collection_script.write(os.linesep.join(contents))
print()
print(f"{script_name} contents:")
print("******************************************")
print(os.linesep.join(contents))
print("******************************************")
make_executable(script_name)
run_command([
python_path, path.join(superpmi_directory, "superpmi.py"), "collect", "-core_root", core_root,
"-output_mch_path", output_mch_name, "-log_file", log_file, "-log_level", "debug",
script_name], _exit_on_fail=True)
def build_and_run(coreclr_args, output_mch_name):
"""Build the microbenchmarks and run them under "superpmi collect"
Args:
coreclr_args (CoreClrArguments): Arguments use to drive
output_mch_name (string): Name of output mch file name
"""
arch = coreclr_args.arch
python_path = sys.executable
core_root = coreclr_args.core_root
superpmi_directory = coreclr_args.superpmi_directory
performance_directory = coreclr_args.performance_directory
log_file = coreclr_args.log_file
partition_count = coreclr_args.partition_count
partition_index = coreclr_args.partition_index
dotnet_directory = os.path.join(performance_directory, "tools", "dotnet",
arch)
dotnet_exe = os.path.join(dotnet_directory, "dotnet")
artifacts_directory = os.path.join(performance_directory, "artifacts")
artifacts_packages_directory = os.path.join(artifacts_directory,
"packages")
project_file = os.path.join(performance_directory, "src", "benchmarks",
"micro", "MicroBenchmarks.csproj")
benchmarks_dll = os.path.join(artifacts_directory, "MicroBenchmarks.dll")
# Workaround https://github.com/dotnet/sdk/issues/23430
project_file = os.path.realpath(project_file)
if is_windows:
shim_name = "%JitName%"
corerun_exe = "CoreRun.exe"
script_name = "run_microbenchmarks.bat"
else:
shim_name = "$JitName"
corerun_exe = "corerun"
script_name = "run_microbenchmarks.sh"
make_executable(dotnet_exe)
# Start with a "dotnet --info" to see what we've got.
run_command([dotnet_exe, "--info"])
env_copy = os.environ.copy()
if is_windows:
# Try to work around problem with random NuGet failures in "dotnet restore":
# error NU3037: Package 'System.Runtime 4.1.0' from source 'https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public/nuget/v3/index.json':
# The repository primary signature validity period has expired. [C:\h\w\A3B008C0\w\B581097F\u\performance\src\benchmarks\micro\MicroBenchmarks.csproj]
# Using environment variable specified in https://github.com/NuGet/NuGet.Client/pull/4259.
env_copy["NUGET_EXPERIMENTAL_CHAIN_BUILD_RETRY_POLICY"] = "9,2000"
# If `dotnet restore` fails, retry.
num_tries = 3
for try_num in range(num_tries):
# On the last try, exit on fail
exit_on_fail = try_num + 1 == num_tries
(_, _, return_code) = run_command([
dotnet_exe, "restore", project_file, "--packages",
artifacts_packages_directory
],
_exit_on_fail=exit_on_fail,
_env=env_copy)
if return_code == 0:
# It succeeded!
break
print("Try {} of {} failed with error code {}: trying again".format(
try_num + 1, num_tries, return_code))
# Sleep 5 seconds before trying again
time.sleep(5)
run_command([
dotnet_exe, "build", project_file, "--configuration", "Release",
"--framework", "net7.0", "--no-restore", "/p:NuGetPackageRoot=" +
artifacts_packages_directory, "-o", artifacts_directory
],
_exit_on_fail=True)
# Disable ReadyToRun so we always JIT R2R methods and collect them
collection_command = f"{dotnet_exe} {benchmarks_dll} --filter \"*\" --corerun {os.path.join(core_root, corerun_exe)} --partition-count {partition_count} " \
f"--partition-index {partition_index} --envVars COMPlus_JitName:{shim_name} " \
" COMPlus_ZapDisable:1 COMPlus_ReadyToRun:0 " \
"--iterationCount 1 --warmupCount 0 --invocationCount 1 --unrollFactor 1 --strategy ColdStart"
# Generate the execution script in Temp location
with TempDir() as temp_location:
script_name = os.path.join(temp_location, script_name)
contents = []
# Unset the JitName so dotnet process will not fail
if is_windows:
contents.append("set JitName=%COMPlus_JitName%")
contents.append("set COMPlus_JitName=")
else:
contents.append("#!/bin/bash")
contents.append("export JitName=$COMPlus_JitName")
contents.append("unset COMPlus_JitName")
contents.append(f"pushd {performance_directory}")
contents.append(collection_command)
with open(script_name, "w") as collection_script:
collection_script.write(os.linesep.join(contents))
print()
print(f"{script_name} contents:")
print("******************************************")
print(os.linesep.join(contents))
print("******************************************")
make_executable(script_name)
run_command([
python_path,
os.path.join(superpmi_directory, "superpmi.py"), "collect",
"-core_root", core_root, "-output_mch_path", output_mch_name,
"-log_file", log_file, "-log_level", "debug", script_name
],
_exit_on_fail=True)
def main(main_args):
""" Main entrypoint
Args:
main_args ([type]): Arguments to the script
"""
coreclr_args = setup_args(main_args)
source_directory = coreclr_args.source_directory
# CorrelationPayload directories
correlation_payload_directory = os.path.join(coreclr_args.source_directory,
"payload")
superpmi_src_directory = os.path.join(source_directory, 'src', 'coreclr',
'scripts')
superpmi_dst_directory = os.path.join(correlation_payload_directory,
"superpmi")
arch = coreclr_args.arch
helix_source_prefix = "official"
creator = ""
ci = True
if is_windows:
helix_queue = "Windows.10.Arm64" if arch == "arm64" else "Windows.10.Amd64.X86.Rt"
else:
if arch == "arm":
helix_queue = "(Ubuntu.1804.Arm32)[email protected]/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm32v7-bfcd90a-20200121150440"
elif arch == "arm64":
helix_queue = "(Ubuntu.1804.Arm64)[email protected]/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8-20210531091519-97d8652"
else:
helix_queue = "Ubuntu.1804.Amd64"
# create superpmi directory
print('Copying {} -> {}'.format(superpmi_src_directory,
superpmi_dst_directory))
copy_directory(superpmi_src_directory,
superpmi_dst_directory,
verbose_output=True,
match_func=lambda path: any(
path.endswith(extension) for extension in [".py"]))
if is_windows:
acceptable_copy = lambda path: any(
path.endswith(extension)
for extension in [".py", ".dll", ".exe", ".json"])
else:
# Need to accept files without any extension, which is how executable file's names look.
acceptable_copy = lambda path: (os.path.basename(path).find(
".") == -1) or any(
path.endswith(extension)
for extension in [".py", ".dll", ".so", ".json"])
print('Copying {} -> {}'.format(coreclr_args.core_root_directory,
superpmi_dst_directory))
copy_directory(coreclr_args.core_root_directory,
superpmi_dst_directory,
verbose_output=True,
match_func=acceptable_copy)
# Copy all the test files to CORE_ROOT
# The reason is there are lot of dependencies with *.Tests.dll and to ensure we do not get
# Reflection errors, just copy everything to CORE_ROOT so for all individual partitions, the
# references will be present in CORE_ROOT.
if coreclr_args.collection_name == "libraries_tests":
print('Copying {} -> {}'.format(coreclr_args.input_directory,
superpmi_dst_directory))
def make_readable(folder_name):
"""Make file executable by changing the permission
Args:
folder_name (string): folder to mark with 744
"""
if is_windows:
return
print("Inside make_readable")
run_command(["ls", "-l", folder_name])
for file_path, dirs, files in os.walk(folder_name, topdown=True):
for d in dirs:
os.chmod(
os.path.join(file_path, d),
# read+write+execute for owner
(stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) |
# read for group
(stat.S_IRGRP) |
# read for other
(stat.S_IROTH))
for f in files:
os.chmod(
os.path.join(file_path, f),
# read+write+execute for owner
(stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR) |
# read for group
(stat.S_IRGRP) |
# read for other
(stat.S_IROTH))
run_command(["ls", "-l", folder_name])
make_readable(coreclr_args.input_directory)
copy_directory(coreclr_args.input_directory,
superpmi_dst_directory,
verbose_output=True,
match_func=acceptable_copy)
# Workitem directories
workitem_directory = os.path.join(source_directory, "workitem")
input_artifacts = ""
if coreclr_args.collection_name == "benchmarks":
# Setup microbenchmarks
setup_microbenchmark(workitem_directory, arch)
else:
# Setup for pmi/crossgen runs
# Clone and build jitutils
try:
with TempDir() as jitutils_directory:
run_command([
"git", "clone", "--quiet", "--depth", "1",
"https://github.com/dotnet/jitutils", jitutils_directory
])
# Make sure ".dotnet" directory exists, by running the script at least once
dotnet_script_name = "dotnet.cmd" if is_windows else "dotnet.sh"
dotnet_script_path = os.path.join(source_directory,
dotnet_script_name)
run_command([dotnet_script_path, "--info"], jitutils_directory)
# Set dotnet path to run build
os.environ["PATH"] = os.path.join(
source_directory,
".dotnet") + os.pathsep + os.environ["PATH"]
build_file = "build.cmd" if is_windows else "build.sh"
run_command(
[os.path.join(jitutils_directory, build_file), "-p"],
jitutils_directory)
copy_files(
os.path.join(jitutils_directory,
"bin"), superpmi_dst_directory,
[os.path.join(jitutils_directory, "bin", "pmi.dll")])
except PermissionError as pe_error:
# Details: https://bugs.python.org/issue26660
print('Ignoring PermissionError: {0}'.format(pe_error))
# NOTE: we can't use the build machine ".dotnet" to run on all platforms. E.g., the Windows x86 build uses a
# Windows x64 .dotnet\dotnet.exe that can't load a 32-bit shim. Thus, we always use corerun from Core_Root to invoke crossgen2.
# The following will copy .dotnet to the correlation payload in case we change our mind, and need or want to use it for some scenarios.
# # Copy ".dotnet" to correlation_payload_directory for crossgen2 job; it is needed to invoke crossgen2.dll
# if coreclr_args.collection_type == "crossgen2":
# dotnet_src_directory = os.path.join(source_directory, ".dotnet")
# dotnet_dst_directory = os.path.join(correlation_payload_directory, ".dotnet")
# print('Copying {} -> {}'.format(dotnet_src_directory, dotnet_dst_directory))
# copy_directory(dotnet_src_directory, dotnet_dst_directory, verbose_output=False)
# payload
pmiassemblies_directory = os.path.join(workitem_directory,
"pmiAssembliesDirectory")
input_artifacts = os.path.join(pmiassemblies_directory,
coreclr_args.collection_name)
exclude_directory = [
'Core_Root'
] if coreclr_args.collection_name == "coreclr_tests" else []
exclude_files = native_binaries_to_ignore
if coreclr_args.collection_type == "crossgen2":
print('Adding exclusions for crossgen2')
# Currently, trying to crossgen2 R2RTest\Microsoft.Build.dll causes a pop-up failure, so exclude it.
exclude_files += ["Microsoft.Build.dll"]
if coreclr_args.collection_name == "libraries_tests":
# libraries_tests artifacts contains files from core_root folder. Exclude them.
core_root_dir = coreclr_args.core_root_directory
exclude_files += [
item for item in os.listdir(core_root_dir)
if os.path.isfile(os.path.join(core_root_dir, item)) and (
item.endswith(".dll") or item.endswith(".exe"))
]
partition_files(coreclr_args.input_directory, input_artifacts,
coreclr_args.max_size, exclude_directory,
exclude_files)
# Set variables
print('Setting pipeline variables:')
set_pipeline_variable("CorrelationPayloadDirectory",
correlation_payload_directory)
set_pipeline_variable("WorkItemDirectory", workitem_directory)
set_pipeline_variable("InputArtifacts", input_artifacts)
set_pipeline_variable("Python", ' '.join(get_python_name()))
set_pipeline_variable("Architecture", arch)
set_pipeline_variable("Creator", creator)
set_pipeline_variable("Queue", helix_queue)
set_pipeline_variable("HelixSourcePrefix", helix_source_prefix)
set_pipeline_variable("MchFileTag", coreclr_args.mch_file_tag)
def main(main_args):
"""Main entrypoint
Args:
main_args ([type]): Arguments to the script
"""
coreclr_args = setup_args(main_args)
fuzzlyn_directory = coreclr_args.fuzzlyn_directory
core_root = coreclr_args.core_root
tag_name = "{}-{}".format(coreclr_args.run_configuration,
coreclr_args.partition)
output_directory = coreclr_args.output_directory
if not coreclr_args.run_duration:
run_duration = 60 * 60 # 60 minutes by default
else:
run_duration = int(
coreclr_args.run_duration) * 60 # Run for duration in seconds
path_to_corerun = os.path.join(core_root, "corerun")
path_to_tool = os.path.join(fuzzlyn_directory, "Fuzzlyn")
if is_windows:
path_to_corerun += ".exe"
path_to_tool += ".exe"
os.makedirs(output_directory, exist_ok=True)
if not is_windows:
# Disable core dumps. The fuzzers have their own graceful handling for
# runtime crashes. Especially on macOS we can quickly fill up the drive
# with dumps if we find lots of crashes since dumps there are very big.
import resource
resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
with TempDir() as temp_location:
summary_file_name = "issues-summary-{}.txt".format(tag_name)
summary_file_path = path.join(temp_location, summary_file_name)
with open(summary_file_path, 'w'):
pass
upload_fuzzer_output_path = path.join(
output_directory, "Fuzzlyn-{}.log".format(tag_name))
with open(summary_file_path, 'r') as fp:
exit_evt = threading.Event()
reduce_examples = ReduceExamples(fp, temp_location, path_to_tool,
path_to_corerun, exit_evt)
reduce_examples.start()
run_command([
path_to_tool, "--seconds-to-run",
str(run_duration), "--output-events-to", summary_file_path,
"--host", path_to_corerun, "--parallelism", "-1",
"--known-errors", "dotnet/runtime"
],
_exit_on_fail=True,
_output_file=upload_fuzzer_output_path)
exit_evt.set()
reduce_examples.join()
upload_summary_file_path = path.join(output_directory,
summary_file_name)
print("Copying summary: {} -> {}".format(summary_file_path,
upload_summary_file_path))
shutil.copy2(summary_file_path, upload_summary_file_path)
upload_issues_zip_path = path.join(output_directory,
"AllIssues-{}".format(tag_name))
print("Creating zip {}.zip".format(upload_issues_zip_path))
shutil.make_archive(upload_issues_zip_path, 'zip', temp_location)
def main(main_args):
""" Run superpmi asmdiffs process on the Helix machines.
See superpmi_asmdiffs_setup.py for how the directory structure is set up in the
correlation payload. This script lives in the root of that directory tree.
Args:
main_args ([type]): Arguments to the script
"""
python_path = sys.executable
script_dir = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
coreclr_args = setup_args(main_args)
# It doesn't really matter where we put the downloaded SPMI artifacts.
# Here, they are put in <correlation_payload>/artifacts/spmi.
spmi_location = os.path.join(script_dir, "artifacts", "spmi")
log_directory = coreclr_args.log_directory
platform_name = coreclr_args.platform
# Find the built jit-analyze and put its directory on the PATH
jit_analyze_dir = os.path.join(script_dir, "jit-analyze")
if not os.path.isdir(jit_analyze_dir):
print("Error: jit-analyze not found in {} (continuing)".format(
jit_analyze_dir))
else:
# Put the jit-analyze directory on the PATH so superpmi.py can find it.
print("Adding {} to PATH".format(jit_analyze_dir))
os.environ["PATH"] = jit_analyze_dir + os.pathsep + os.environ["PATH"]
# Find the portable `git` installation, and put `git.exe` on the PATH, for use by `jit-analyze`.
git_directory = os.path.join(script_dir, "git", "cmd")
git_exe_tool = os.path.join(git_directory, "git.exe")
if not os.path.isfile(git_exe_tool):
print("Error: `git` not found at {} (continuing)".format(git_exe_tool))
else:
# Put the git/cmd directory on the PATH so jit-analyze can find it.
print("Adding {} to PATH".format(git_directory))
os.environ["PATH"] = git_directory + os.pathsep + os.environ["PATH"]
# Figure out which JITs to use
os_name = "win" if platform_name.lower() == "windows" else "unix"
arch_name = coreclr_args.arch
host_arch_name = "x64" if arch_name.endswith("64") else "x86"
os_name = "universal" if arch_name.startswith("arm") else os_name
base_jit_path = os.path.join(
coreclr_args.base_jit_directory,
'clrjit_{}_{}_{}.dll'.format(os_name, arch_name, host_arch_name))
diff_jit_path = os.path.join(
coreclr_args.diff_jit_directory,
'clrjit_{}_{}_{}.dll'.format(os_name, arch_name, host_arch_name))
# Core_Root is where the superpmi tools (superpmi.exe, mcs.exe) are expected to be found.
# We pass the full path of the JITs to use as arguments.
core_root_dir = script_dir
print("Running superpmi.py download to get MCH files")
log_file = os.path.join(
log_directory,
"superpmi_download_{}_{}.log".format(platform_name, arch_name))
run_command([
python_path,
os.path.join(script_dir, "superpmi.py"), "download", "--no_progress",
"-core_root", core_root_dir, "-target_os", platform_name,
"-target_arch", arch_name, "-spmi_location", spmi_location,
"-log_level", "debug", "-log_file", log_file
],
_exit_on_fail=True)
print("Running superpmi.py asmdiffs")
log_file = os.path.join(
log_directory, "superpmi_{}_{}.log".format(platform_name, arch_name))
overall_md_summary_file = os.path.join(spmi_location, "diff_summary.md")
if os.path.isfile(overall_md_summary_file):
os.remove(overall_md_summary_file)
_, _, return_code = run_command([
python_path,
os.path.join(script_dir, "superpmi.py"), "asmdiffs", "--no_progress",
"-core_root", core_root_dir, "-target_os", platform_name,
"-target_arch", arch_name, "-arch", host_arch_name, "-base_jit_path",
base_jit_path, "-diff_jit_path", diff_jit_path, "-spmi_location",
spmi_location, "-error_limit", "100", "-log_level", "debug",
"-log_file", log_file, "-retainOnlyTopFiles"
])
# If there are asm diffs, and jit-analyze ran, we'll get a diff_summary.md file in the spmi_location directory.
# We make sure the file doesn't exist before we run diffs, so we don't need to worry about superpmi.py creating
# a unique, numbered file. If there are no diffs, we still want to create this file and indicate there were no diffs.
overall_md_summary_file_target = os.path.join(
log_directory,
"superpmi_diff_summary_{}_{}.md".format(platform_name, arch_name))
if os.path.isfile(overall_md_summary_file):
try:
print("Copying summary file {} -> {}".format(
overall_md_summary_file, overall_md_summary_file_target))
shutil.copy2(overall_md_summary_file,
overall_md_summary_file_target)
except PermissionError as pe_error:
print('Ignoring PermissionError: {0}'.format(pe_error))
else:
# Write a basic summary file. Ideally, we should not generate a summary.md file. However, currently I'm seeing
# errors where the Helix work item fails to upload this specified file if it doesn't exist. We should change the
# upload to be conditional, or otherwise not error.
with open(overall_md_summary_file_target, "a") as f:
f.write("""\
No diffs found
""")
# Finally prepare files to upload from helix.
copy_dasm_files(spmi_location, log_directory,
"{}_{}".format(platform_name, arch_name))
if return_code != 0:
print("Failure in {}".format(log_file))
return 1
return 0
