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 = 120 # Run for 2 hours 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" # Run tool such that issues are placed in a temp folder with TempDir() as temp_location: run_command([ path_to_tool, "-c", path_to_corerun, "-o", temp_location, "-d", str(run_duration) ], _exit_on_fail=True, _long_running=True) # Copy issues for upload print("Copying issues to " + output_directory) copy_issues(temp_location, output_directory, tag_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 = path.join(performance_directory, "methods_to_strip.mcl") mcs_exe = 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 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) 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_dst_directory = path.join(correlation_payload_directory, "CoreRoot") antigen_dst_directory = path.join(correlation_payload_directory, "exploratory") helix_source_prefix = "official" creator = "" ci = True if is_windows: helix_queue = "Windows.10.Arm64" if arch_name == "arm64" else "Windows.10.Amd64.X86" else: if arch_name == "arm": helix_queue = "(Ubuntu.1804.Arm32)[email protected]/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm32v7-bfcd90a-20200121150440" elif arch_name == "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 exploratory directory print('Copying {} -> {}'.format(scripts_src_directory, coreroot_dst_directory)) copy_directory(scripts_src_directory, coreroot_dst_directory, 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_dst_directory)) copy_directory(coreclr_args.core_root_directory, coreroot_dst_directory, match_func=acceptable_copy) try: with TempDir() as tool_code_directory: # clone the tool run_command( ["git", "clone", "--quiet", "--depth", "1", "https://github.com/kunalspathak/Antigen.git", tool_code_directory]) antigen_bin_directory = path.join(tool_code_directory, "bin", "Release", "net5.0") # 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", antigen_bin_directory], _exit_on_fail=True) if not os.path.exists(path.join(antigen_bin_directory, "Antigen.dll")): raise FileNotFoundError("Antigen.dll not present at {}".format(antigen_bin_directory)) # copy antigen tool print('Copying {} -> {}'.format(antigen_bin_directory, antigen_dst_directory)) copy_directory(antigen_bin_directory, antigen_dst_directory, 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("Queue", helix_queue) set_pipeline_variable("HelixSourcePrefix", helix_source_prefix)
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 = 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" jit_path = 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, 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 = 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, 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 = 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 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(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, 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") 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", "net6.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)