process_angle_perf_results.py

#!/usr/bin/env vpython
#
# Copyright 2021 The ANGLE Project Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
#
# process_angle_perf_results.py:
# Perf result merging and upload. Adapted from the Chromium script:
# https://chromium.googlesource.com/chromium/src/+/main/tools/perf/process_perf_results.py

from __future__ importprint_function

importargparse
importcollections
importdatetime
importjson
importlogging
importmultiprocessing
importos
importpathlib
importshutil
importsubprocess
importsys
importtempfile
importtime
importuuid

logging.basicConfig(
level=logging.INFO,
format='(%(levelname)s) %(asctime)s pid=%(process)d'
' %(module)s.%(funcName)s:%(lineno)d %(message)s')

PY_UTILS=str(pathlib.Path(__file__).resolve().parents[1] /'src'/'tests'/'py_utils')
ifPY_UTILSnotinsys.path:
os.stat(PY_UTILS) andsys.path.insert(0, PY_UTILS)
importangle_metrics
importangle_path_util

angle_path_util.AddDepsDirToPath('tools/perf')
fromcoreimportpath_util

path_util.AddTelemetryToPath()
fromcoreimportupload_results_to_perf_dashboard
fromcoreimportresults_merger

path_util.AddAndroidPylibToPath()
try:
frompylib.utilsimportlogdog_helper
exceptImportError:
pass

path_util.AddTracingToPath()
fromtracing.valueimporthistogram
fromtracing.valueimporthistogram_set
fromtracing.value.diagnosticsimportgeneric_set
fromtracing.value.diagnosticsimportreserved_infos

RESULTS_URL='https://chromeperf.appspot.com'
JSON_CONTENT_TYPE='application/json'
MACHINE_GROUP='ANGLE'
BUILD_URL='https://ci.chromium.org/ui/p/angle/builders/ci/%s/%d'

GSUTIL_PY_PATH=str(
pathlib.Path(__file__).resolve().parents[1] /'third_party'/'depot_tools'/'gsutil.py')


def_upload_perf_results(json_to_upload, name, configuration_name, build_properties,
output_json_file):
"""Upload the contents of result JSON(s) to the perf dashboard."""
args= [
'--buildername',
build_properties['buildername'],
'--buildnumber',
str(build_properties['buildnumber']),
'--name',
name,
'--configuration-name',
configuration_name,
'--results-file',
json_to_upload,
'--results-url',
RESULTS_URL,
'--output-json-file',
output_json_file,
'--perf-dashboard-machine-group',
MACHINE_GROUP,
'--got-angle-revision',
build_properties['got_angle_revision'],
'--send-as-histograms',
'--project',
'angle',
 ]

ifbuild_properties.get('git_revision'):
args.append('--git-revision')
args.append(build_properties['git_revision'])

#TODO(crbug.com/1072729): log this in top level
logging.info('upload_results_to_perf_dashboard: %s.'%args)

returnupload_results_to_perf_dashboard.main(args)


def_merge_json_output(output_json, jsons_to_merge, extra_links, test_cross_device=False):
"""Merges the contents of one or more results JSONs.

 Args:
 output_json: A path to a JSON file to which the merged results should be
 written.
 jsons_to_merge: A list of JSON files that should be merged.
 extra_links: a (key, value) map in which keys are the human-readable strings
 which describe the data, and value is logdog url that contain the data.
 """
begin_time=time.time()
merged_results=results_merger.merge_test_results(jsons_to_merge, test_cross_device)

# Only append the perf results links if present
ifextra_links:
merged_results['links'] =extra_links

withopen(output_json, 'w') asf:
json.dump(merged_results, f)

end_time=time.time()
print_duration('Merging json test results', begin_time, end_time)
return0


def_handle_perf_json_test_results(benchmark_directory_map, test_results_list):
"""Checks the test_results.json under each folder:

 1. mark the benchmark 'enabled' if tests results are found
 2. add the json content to a list for non-ref.
 """
begin_time=time.time()
benchmark_enabled_map= {}
forbenchmark_name, directoriesinbenchmark_directory_map.items():
fordirectoryindirectories:
# Obtain the test name we are running
is_ref='.reference'inbenchmark_name
enabled=True
try:
withopen(os.path.join(directory, 'test_results.json')) asjson_data:
json_results=json.load(json_data)
ifnotjson_results:
# Output is null meaning the test didn't produce any results.
# Want to output an error and continue loading the rest of the
# test results.
logging.warning('No results produced for %s, skipping upload'%directory)
continue
ifjson_results.get('version') ==3:
# Non-telemetry tests don't have written json results but
# if they are executing then they are enabled and will generate
# chartjson results.
ifnotbool(json_results.get('tests')):
enabled=False
ifnotis_ref:
# We don't need to upload reference build data to the
# flakiness dashboard since we don't monitor the ref build
test_results_list.append(json_results)
exceptIOErrorase:
# TODO(crbug.com/936602): Figure out how to surface these errors. Should
# we have a non-zero exit code if we error out?
logging.error('Failed to obtain test results for %s: %s', benchmark_name, e)
continue
ifnotenabled:
# We don't upload disabled benchmarks or tests that are run
# as a smoke test
logging.info('Benchmark %s ran no tests on at least one shard'%benchmark_name)
continue
benchmark_enabled_map[benchmark_name] =True

end_time=time.time()
print_duration('Analyzing perf json test results', begin_time, end_time)
returnbenchmark_enabled_map


def_generate_unique_logdog_filename(name_prefix):
returnname_prefix+'_'+str(uuid.uuid4())


def_handle_perf_logs(benchmark_directory_map, extra_links):
""" Upload benchmark logs to logdog and add a page entry for them. """
begin_time=time.time()
benchmark_logs_links=collections.defaultdict(list)

forbenchmark_name, directoriesinbenchmark_directory_map.items():
fordirectoryindirectories:
benchmark_log_file=os.path.join(directory, 'benchmark_log.txt')
ifos.path.exists(benchmark_log_file):
withopen(benchmark_log_file) asf:
uploaded_link=logdog_helper.text(
name=_generate_unique_logdog_filename(benchmark_name), data=f.read())
benchmark_logs_links[benchmark_name].append(uploaded_link)

logdog_file_name=_generate_unique_logdog_filename('Benchmarks_Logs')
logdog_stream=logdog_helper.text(
logdog_file_name,
json.dumps(benchmark_logs_links, sort_keys=True, indent=4, separators=(',', ': ')),
content_type=JSON_CONTENT_TYPE)
extra_links['Benchmarks logs'] =logdog_stream
end_time=time.time()
print_duration('Generating perf log streams', begin_time, end_time)


def_handle_benchmarks_shard_map(benchmarks_shard_map_file, extra_links):
begin_time=time.time()
withopen(benchmarks_shard_map_file) asf:
benchmarks_shard_data=f.read()
logdog_file_name=_generate_unique_logdog_filename('Benchmarks_Shard_Map')
logdog_stream=logdog_helper.text(
logdog_file_name, benchmarks_shard_data, content_type=JSON_CONTENT_TYPE)
extra_links['Benchmarks shard map'] =logdog_stream
end_time=time.time()
print_duration('Generating benchmark shard map stream', begin_time, end_time)


def_get_benchmark_name(directory):
returnos.path.basename(directory).replace(" benchmark", "")


def_scan_output_dir(task_output_dir):
benchmark_directory_map= {}
benchmarks_shard_map_file=None

directory_list= [
fforfinos.listdir(task_output_dir)
ifnotos.path.isfile(os.path.join(task_output_dir, f))
 ]
benchmark_directory_list= []
fordirectoryindirectory_list:
forfinos.listdir(os.path.join(task_output_dir, directory)):
path=os.path.join(task_output_dir, directory, f)
ifos.path.isdir(path):
benchmark_directory_list.append(path)
elifpath.endswith('benchmarks_shard_map.json'):
benchmarks_shard_map_file=path
# Now create a map of benchmark name to the list of directories
# the lists were written to.
fordirectoryinbenchmark_directory_list:
benchmark_name=_get_benchmark_name(directory)
logging.debug('Found benchmark %s directory %s'% (benchmark_name, directory))
ifbenchmark_nameinbenchmark_directory_map.keys():
benchmark_directory_map[benchmark_name].append(directory)
else:
benchmark_directory_map[benchmark_name] = [directory]

returnbenchmark_directory_map, benchmarks_shard_map_file


def_upload_to_skia_perf(benchmark_directory_map, benchmark_enabled_map, build_properties_map):
metric_filenames= []

forbenchmark_name, directoriesinbenchmark_directory_map.items():
ifnotbenchmark_enabled_map.get(benchmark_name, False):
continue

fordirectoryindirectories:
metric_filenames.append(os.path.join(directory, 'angle_metrics.json'))

assertmetric_filenames

buildername=build_properties_map['buildername'] # e.g. win10-nvidia-gtx1660-perf
skia_data= {
'version': 1,
'git_hash': build_properties_map['got_angle_revision'],
'key': {
'buildername': buildername,
 },
'results': angle_metrics.ConvertToSkiaPerf(metric_filenames),
 }

skia_perf_dir=tempfile.mkdtemp('skia_perf')
try:
local_file=os.path.join(skia_perf_dir, '%s.%s.json'% (buildername, time.time()))
withopen(local_file, 'w') asf:
json.dump(skia_data, f, indent=2)
gs_dir='gs://angle-perf-skia/angle_perftests/%s/'% (
datetime.datetime.now().strftime('%Y/%m/%d/%H'))
upload_cmd= ['vpython3', GSUTIL_PY_PATH, 'cp', local_file, gs_dir]
logging.info('Skia upload: %s', ' '.join(upload_cmd))
subprocess.check_call(upload_cmd)
finally:
shutil.rmtree(skia_perf_dir)


defprocess_perf_results(output_json,
configuration_name,
build_properties,
task_output_dir,
smoke_test_mode,
output_results_dir,
lightweight=False,
skip_perf=False):
"""Process perf results.

 Consists of merging the json-test-format output, uploading the perf test
 output (histogram), and store the benchmark logs in logdog.

 Each directory in the task_output_dir represents one benchmark
 that was run. Within this directory, there is a subdirectory with the name
 of the benchmark that was run. In that subdirectory, there is a
 perftest-output.json file containing the performance results in histogram
 format and an output.json file containing the json test results for the
 benchmark.

 Returns:
 (return_code, upload_results_map):
 return_code is 0 if the whole operation is successful, non zero otherwise.
 benchmark_upload_result_map: the dictionary that describe which benchmarks
 were successfully uploaded.
 """
handle_perf=notlightweightornotskip_perf
handle_non_perf=notlightweightorskip_perf
logging.info('lightweight mode: %r; handle_perf: %r; handle_non_perf: %r'%
 (lightweight, handle_perf, handle_non_perf))

begin_time=time.time()
return_code=0
benchmark_upload_result_map= {}

benchmark_directory_map, benchmarks_shard_map_file=_scan_output_dir(task_output_dir)

test_results_list= []
extra_links= {}

ifhandle_non_perf:
# First, upload benchmarks shard map to logdog and add a page
# entry for it in extra_links.
ifbenchmarks_shard_map_file:
_handle_benchmarks_shard_map(benchmarks_shard_map_file, extra_links)

# Second, upload all the benchmark logs to logdog and add a page entry for
# those links in extra_links.
_handle_perf_logs(benchmark_directory_map, extra_links)

# Then try to obtain the list of json test results to merge
# and determine the status of each benchmark.
benchmark_enabled_map=_handle_perf_json_test_results(benchmark_directory_map,
test_results_list)

ifnotsmoke_test_modeandhandle_perf:
build_properties_map=json.loads(build_properties)
ifnotconfiguration_name:
# we are deprecating perf-id crbug.com/817823
configuration_name=build_properties_map['buildername']

try:
return_code, benchmark_upload_result_map=_handle_perf_results(
benchmark_enabled_map, benchmark_directory_map, configuration_name,
build_properties_map, extra_links, output_results_dir)
exceptException:
logging.exception('Error handling perf results jsons')
return_code=1

try:
_upload_to_skia_perf(benchmark_directory_map, benchmark_enabled_map,
build_properties_map)
exceptException:
logging.exception('Error uploading to skia perf')
return_code=1

ifhandle_non_perf:
# Finally, merge all test results json, add the extra links and write out to
# output location
try:
_merge_json_output(output_json, test_results_list, extra_links)
exceptException:
logging.exception('Error handling test results jsons.')

end_time=time.time()
print_duration('Total process_perf_results', begin_time, end_time)
returnreturn_code, benchmark_upload_result_map


def_merge_histogram_results(histogram_lists):
merged_results= []
forhistogram_listinhistogram_lists:
merged_results+=histogram_list

returnmerged_results


def_load_histogram_set_from_dict(data):
histograms=histogram_set.HistogramSet()
histograms.ImportDicts(data)
returnhistograms


def_add_build_info(results, benchmark_name, build_properties):
histograms=_load_histogram_set_from_dict(results)

common_diagnostics= {
reserved_infos.MASTERS:
build_properties['builder_group'],
reserved_infos.BOTS:
build_properties['buildername'],
reserved_infos.POINT_ID:
build_properties['angle_commit_pos'],
reserved_infos.BENCHMARKS:
benchmark_name,
reserved_infos.ANGLE_REVISIONS:
build_properties['got_angle_revision'],
reserved_infos.BUILD_URLS:
BUILD_URL% (build_properties['buildername'], build_properties['buildnumber']),
 }

fork, vincommon_diagnostics.items():
histograms.AddSharedDiagnosticToAllHistograms(k.name, generic_set.GenericSet([v]))

returnhistograms.AsDicts()


def_merge_perf_results(benchmark_name, results_filename, directories, build_properties):
begin_time=time.time()
collected_results= []
fordirectoryindirectories:
filename=os.path.join(directory, 'perf_results.json')
try:
withopen(filename) aspf:
collected_results.append(json.load(pf))
exceptIOErrorase:
# TODO(crbug.com/936602): Figure out how to surface these errors. Should
# we have a non-zero exit code if we error out?
logging.error('Failed to obtain perf results from %s: %s', directory, e)
ifnotcollected_results:
logging.error('Failed to obtain any perf results from %s.', benchmark_name)
return

# Assuming that multiple shards will be histogram set
# Non-telemetry benchmarks only ever run on one shard
merged_results= []
assert (isinstance(collected_results[0], list))
merged_results=_merge_histogram_results(collected_results)

# Write additional histogram build info.
merged_results=_add_build_info(merged_results, benchmark_name, build_properties)

withopen(results_filename, 'w') asrf:
json.dump(merged_results, rf)

end_time=time.time()
print_duration(('%s results merging'% (benchmark_name)), begin_time, end_time)


def_upload_individual(benchmark_name, directories, configuration_name, build_properties,
output_json_file):
tmpfile_dir=tempfile.mkdtemp()
try:
upload_begin_time=time.time()
# There are potentially multiple directores with results, re-write and
# merge them if necessary
results_filename=None
iflen(directories) >1:
merge_perf_dir=os.path.join(os.path.abspath(tmpfile_dir), benchmark_name)
ifnotos.path.exists(merge_perf_dir):
os.makedirs(merge_perf_dir)
results_filename=os.path.join(merge_perf_dir, 'merged_perf_results.json')
_merge_perf_results(benchmark_name, results_filename, directories, build_properties)
else:
# It was only written to one shard, use that shards data
results_filename=os.path.join(directories[0], 'perf_results.json')

results_size_in_mib=os.path.getsize(results_filename) / (2**20)
logging.info('Uploading perf results from %s benchmark (size %s Mib)'%
 (benchmark_name, results_size_in_mib))
upload_return_code=_upload_perf_results(results_filename, benchmark_name,
configuration_name, build_properties,
output_json_file)
upload_end_time=time.time()
print_duration(('%s upload time'% (benchmark_name)), upload_begin_time, upload_end_time)
return (benchmark_name, upload_return_code==0)
finally:
shutil.rmtree(tmpfile_dir)


def_upload_individual_benchmark(params):
try:
return_upload_individual(*params)
exceptException:
benchmark_name=params[0]
upload_succeed=False
logging.exception('Error uploading perf result of %s'%benchmark_name)
returnbenchmark_name, upload_succeed


def_GetCpuCount(log=True):
try:
cpu_count=multiprocessing.cpu_count()
ifsys.platform=='win32':
# TODO(crbug.com/1190269) - we can't use more than 56
# cores on Windows or Python3 may hang.
cpu_count=min(cpu_count, 56)
returncpu_count
exceptNotImplementedError:
iflog:
logging.warn('Failed to get a CPU count for this bot. See crbug.com/947035.')
# TODO(crbug.com/948281): This is currently set to 4 since the mac masters
# only have 4 cores. Once we move to all-linux, this can be increased or
# we can even delete this whole function and use multiprocessing.cpu_count()
# directly.
return4


def_load_shard_id_from_test_results(directory):
shard_id=None
test_json_path=os.path.join(directory, 'test_results.json')
try:
withopen(test_json_path) asf:
test_json=json.load(f)
all_results=test_json['tests']
for_, benchmark_resultsinall_results.items():
for_, measurement_resultinbenchmark_results.items():
shard_id=measurement_result['shard']
break
exceptIOErrorase:
logging.error('Failed to open test_results.json from %s: %s', test_json_path, e)
exceptKeyErrorase:
logging.error('Failed to locate results in test_results.json: %s', e)
returnshard_id


def_find_device_id_by_shard_id(benchmarks_shard_map_file, shard_id):
try:
withopen(benchmarks_shard_map_file) asf:
shard_map_json=json.load(f)
device_id=shard_map_json['extra_infos']['bot #%s'%shard_id]
exceptKeyErrorase:
logging.error('Failed to locate device name in shard map: %s', e)
returndevice_id


def_update_perf_json_with_summary_on_device_id(directory, device_id):
perf_json_path=os.path.join(directory, 'perf_results.json')
try:
withopen(perf_json_path, 'r') asf:
perf_json=json.load(f)
exceptIOErrorase:
logging.error('Failed to open perf_results.json from %s: %s', perf_json_path, e)
summary_key_guid=str(uuid.uuid4())
summary_key_generic_set= {
'values': ['device_id'],
'guid': summary_key_guid,
'type': 'GenericSet'
 }
perf_json.insert(0, summary_key_generic_set)
logging.info('Inserted summary key generic set for perf result in %s: %s', directory,
summary_key_generic_set)
stories_guids=set()
forentryinperf_json:
if'diagnostics'inentry:
entry['diagnostics']['summaryKeys'] =summary_key_guid
stories_guids.add(entry['diagnostics']['stories'])
forentryinperf_json:
if'guid'inentryandentry['guid'] instories_guids:
entry['values'].append(device_id)
try:
withopen(perf_json_path, 'w') asf:
json.dump(perf_json, f)
exceptIOErrorase:
logging.error('Failed to writing perf_results.json to %s: %s', perf_json_path, e)
logging.info('Finished adding device id %s in perf result.', device_id)


def_handle_perf_results(benchmark_enabled_map, benchmark_directory_map, configuration_name,
build_properties, extra_links, output_results_dir):
"""
 Upload perf results to the perf dashboard.

 This method also upload the perf results to logdog and augment it to
 |extra_links|.

 Returns:
 (return_code, benchmark_upload_result_map)
 return_code is 0 if this upload to perf dashboard successfully, 1
 otherwise.
 benchmark_upload_result_map is a dictionary describes which benchmark
 was successfully uploaded.
 """
begin_time=time.time()
# Upload all eligible benchmarks to the perf dashboard
results_dict= {}

invocations= []
forbenchmark_name, directoriesinbenchmark_directory_map.items():
ifnotbenchmark_enabled_map.get(benchmark_name, False):
continue
# Create a place to write the perf results that you will write out to
# logdog.
output_json_file=os.path.join(output_results_dir, (str(uuid.uuid4()) +benchmark_name))
results_dict[benchmark_name] =output_json_file
#TODO(crbug.com/1072729): pass final arguments instead of build properties
# and configuration_name
invocations.append(
 (benchmark_name, directories, configuration_name, build_properties, output_json_file))

# Kick off the uploads in multiple processes
# crbug.com/1035930: We are hitting HTTP Response 429. Limit ourselves
# to 2 processes to avoid this error. Uncomment the following code once
# the problem is fixed on the dashboard side.
# pool = multiprocessing.Pool(_GetCpuCount())
pool=multiprocessing.Pool(2)
upload_result_timeout=False
try:
async_result=pool.map_async(_upload_individual_benchmark, invocations)
# TODO(crbug.com/947035): What timeout is reasonable?
results=async_result.get(timeout=4000)
exceptmultiprocessing.TimeoutError:
upload_result_timeout=True
logging.error('Timeout uploading benchmarks to perf dashboard in parallel')
results= []
forbenchmark_nameinbenchmark_directory_map:
results.append((benchmark_name, False))
finally:
pool.terminate()

# Keep a mapping of benchmarks to their upload results
benchmark_upload_result_map= {}
forrinresults:
benchmark_upload_result_map[r[0]] =r[1]

logdog_dict= {}
upload_failures_counter=0
logdog_stream=None
logdog_label='Results Dashboard'
forbenchmark_name, output_fileinresults_dict.items():
upload_succeed=benchmark_upload_result_map[benchmark_name]
ifnotupload_succeed:
upload_failures_counter+=1
is_reference='.reference'inbenchmark_name
_write_perf_data_to_logfile(
benchmark_name,
output_file,
configuration_name,
build_properties,
logdog_dict,
is_reference,
upload_failure=notupload_succeed)

logdog_file_name=_generate_unique_logdog_filename('Results_Dashboard_')
logdog_stream=logdog_helper.text(
logdog_file_name,
json.dumps(dict(logdog_dict), sort_keys=True, indent=4, separators=(',', ': ')),
content_type=JSON_CONTENT_TYPE)
ifupload_failures_counter>0:
logdog_label+= (' %s merge script perf data upload failures'%upload_failures_counter)
extra_links[logdog_label] =logdog_stream
end_time=time.time()
print_duration('Uploading results to perf dashboard', begin_time, end_time)
ifupload_result_timeoutorupload_failures_counter>0:
return1, benchmark_upload_result_map
return0, benchmark_upload_result_map


def_write_perf_data_to_logfile(benchmark_name, output_file, configuration_name, build_properties,
logdog_dict, is_ref, upload_failure):
viewer_url=None
# logdog file to write perf results to
ifos.path.exists(output_file):
results=None
withopen(output_file) asf:
try:
results=json.load(f)
exceptValueError:
logging.error('Error parsing perf results JSON for benchmark %s'%benchmark_name)
ifresults:
try:
json_fname=_generate_unique_logdog_filename(benchmark_name)
output_json_file=logdog_helper.open_text(json_fname)
json.dump(results, output_json_file, indent=4, separators=(',', ': '))
exceptValueErrorase:
logging.error('ValueError: "%s" while dumping output to logdog'%e)
finally:
output_json_file.close()
viewer_url=output_json_file.get_viewer_url()
else:
logging.warning("Perf results JSON file doesn't exist for benchmark %s"%benchmark_name)

base_benchmark_name=benchmark_name.replace('.reference', '')

ifbase_benchmark_namenotinlogdog_dict:
logdog_dict[base_benchmark_name] = {}

# add links for the perf results and the dashboard url to
# the logs section of buildbot
ifis_ref:
ifviewer_url:
logdog_dict[base_benchmark_name]['perf_results_ref'] =viewer_url
ifupload_failure:
logdog_dict[base_benchmark_name]['ref_upload_failed'] ='True'
else:
# TODO(jmadill): Figure out if we can get a dashboard URL here. http://anglebug.com/40096778
# logdog_dict[base_benchmark_name]['dashboard_url'] = (
# upload_results_to_perf_dashboard.GetDashboardUrl(benchmark_name, configuration_name,
# RESULTS_URL,
# build_properties['got_revision_cp'],
# _GetMachineGroup(build_properties)))
ifviewer_url:
logdog_dict[base_benchmark_name]['perf_results'] =viewer_url
ifupload_failure:
logdog_dict[base_benchmark_name]['upload_failed'] ='True'


defprint_duration(step, start, end):
logging.info('Duration of %s: %d seconds'% (step, end-start))


defmain():
""" See collect_task.collect_task for more on the merge script API. """
logging.info(sys.argv)
parser=argparse.ArgumentParser()
# configuration-name (previously perf-id) is the name of bot the tests run on
# For example, buildbot-test is the name of the android-go-perf bot
# configuration-name and results-url are set in the json file which is going
# away tools/perf/core/chromium.perf.fyi.extras.json
parser.add_argument('--configuration-name', help=argparse.SUPPRESS)
parser.add_argument('--build-properties', help=argparse.SUPPRESS)
parser.add_argument('--summary-json', required=True, help=argparse.SUPPRESS)
parser.add_argument('--task-output-dir', required=True, help=argparse.SUPPRESS)
parser.add_argument('-o', '--output-json', required=True, help=argparse.SUPPRESS)
parser.add_argument(
'--skip-perf',
action='store_true',
help='In lightweight mode, using --skip-perf will skip the performance'
' data handling.')
parser.add_argument(
'--lightweight',
action='store_true',
help='Choose the lightweight mode in which the perf result handling'
' is performed on a separate VM.')
parser.add_argument('json_files', nargs='*', help=argparse.SUPPRESS)
parser.add_argument(
'--smoke-test-mode',
action='store_true',
help='This test should be run in smoke test mode'
' meaning it does not upload to the perf dashboard')

args=parser.parse_args()

withopen(args.summary_json) asf:
shard_summary=json.load(f)
shard_failed=any(int(shard.get('exit_code', 1)) !=0forshardinshard_summary['shards'])

output_results_dir=tempfile.mkdtemp('outputresults')
try:
return_code, _=process_perf_results(args.output_json, args.configuration_name,
args.build_properties, args.task_output_dir,
args.smoke_test_mode, output_results_dir,
args.lightweight, args.skip_perf)
exceptException:
logging.exception('process_perf_results raised an exception')
return_code=1
finally:
shutil.rmtree(output_results_dir)

ifreturn_code!=0andshard_failed:
logging.warning('Perf processing failed but one or more shards failed earlier')
return_code=0# Enables the failed build info to be rendered normally

returnreturn_code


if__name__=='__main__':
sys.exit(main())