Blame - tools/cygprofile/orderfile_generator_backend.py - chromium/src

blob: 54d5a34d13697a1bc31d2c06118c60cc77e17105 [file] [log] [blame]

Egor Pasko	0462e852d	2018-03-29 15:52:09	[diff] [blame]	1	#!/usr/bin/env vpython
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	2	# Copyright (c) 2013 The Chromium Authors. All rights reserved.
				3	# Use of this source code is governed by a BSD-style license that can be
				4	# found in the LICENSE file.
				5
				6	""" A utility to generate an up-to-date orderfile.
				7
				8	The orderfile is used by the linker to order text sections such that the
				9	sections are placed consecutively in the order specified. This allows us
				10	to page in less code during start-up.
				11
				12	Example usage:
Egor Pasko	93e514e	2017-10-31 13:32:36	[diff] [blame]	13	tools/cygprofile/orderfile_generator_backend.py -l 20 -j 1000 --use-goma \
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	14	--target-arch=arm
				15	"""
				16
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	17	import argparse
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	18	import hashlib
				19	import json
Matthew Cary	69e9e42	2018-08-10 18:30:06	[diff] [blame]	20	import glob
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	21	import logging
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	22	import os
				23	import re
				24	import shutil
				25	import subprocess
				26	import sys
Benoit Lize	a87e5bc	2017-11-07 15:12:57	[diff] [blame]	27	import tempfile
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	28	import time
				29
Matthew Cary	91df979	2018-11-30 14:35:15	[diff] [blame^]	30	import cluster
Matthew Cary	e840064	2018-06-14 15:43:02	[diff] [blame]	31	import cyglog_to_orderfile
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	32	import cygprofile_utils
Benoit Lize	fefbb27c	2018-01-17 13:54:18	[diff] [blame]	33	import patch_orderfile
Benoit Lize	a87e5bc	2017-11-07 15:12:57	[diff] [blame]	34	import process_profiles
Egor Pasko	3bc0b93	2018-04-03 10:08:27	[diff] [blame]	35	import profile_android_startup
Benoit Lize	fefbb27c	2018-01-17 13:54:18	[diff] [blame]	36	import symbol_extractor
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	37
				38
				39	_SRC_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)),
				40	os.pardir, os.pardir)
				41	sys.path.append(os.path.join(_SRC_PATH, 'build', 'android'))
				42	import devil_chromium
				43	from pylib import constants
				44
				45
				46	# Needs to happen early for GetBuildType()/GetOutDirectory() to work correctly
				47	constants.SetBuildType('Release')
				48
				49
				50	class CommandError(Exception):
				51	"""Indicates that a dispatched shell command exited with a non-zero status."""
				52
				53	def __init__(self, value):
				54	super(CommandError, self).__init__()
				55	self.value = value
				56
				57	def __str__(self):
				58	return repr(self.value)
				59
				60
				61	def _GenerateHash(file_path):
				62	"""Calculates and returns the hash of the file at file_path."""
				63	sha1 = hashlib.sha1()
				64	with open(file_path, 'rb') as f:
				65	while True:
				66	# Read in 1mb chunks, so it doesn't all have to be loaded into memory.
				67	chunk = f.read(1024 * 1024)
				68	if not chunk:
				69	break
				70	sha1.update(chunk)
				71	return sha1.hexdigest()
				72
				73
				74	def _GetFileExtension(file_name):
				75	"""Calculates the file extension from a file name.
				76
				77	Args:
				78	file_name: The source file name.
				79	Returns:
				80	The part of file_name after the dot (.) or None if the file has no
				81	extension.
				82	Examples: /home/user/foo.bar -> bar
				83	/home/user.name/foo -> None
				84	/home/user/.foo -> None
				85	/home/user/foo.bar.baz -> baz
				86	"""
				87	file_name_parts = os.path.basename(file_name).split('.')
				88	if len(file_name_parts) > 1:
				89	return file_name_parts[-1]
				90	else:
				91	return None
				92
				93
				94	def _StashOutputDirectory(buildpath):
				95	"""Takes the output directory and stashes it in the default output directory.
				96
				97	This allows it to be used for incremental builds next time (after unstashing)
				98	by keeping it in a place that isn't deleted normally, while also ensuring
				99	that it is properly clobbered when appropriate.
				100
				101	This is a dirty hack to deal with the needs of clobbering while also handling
				102	incremental builds and the hardcoded relative paths used in some of the
				103	project files.
				104
				105	Args:
				106	buildpath: The path where the building happens. If this corresponds to the
				107	default output directory, no action is taken.
				108	"""
				109	if os.path.abspath(buildpath) == os.path.abspath(os.path.dirname(
				110	constants.GetOutDirectory())):
				111	return
				112	name = os.path.basename(buildpath)
				113	stashpath = os.path.join(constants.GetOutDirectory(), name)
				114	if not os.path.exists(buildpath):
				115	return
				116	if os.path.exists(stashpath):
				117	shutil.rmtree(stashpath, ignore_errors=True)
				118	shutil.move(buildpath, stashpath)
				119
				120
				121	def _UnstashOutputDirectory(buildpath):
				122	"""Inverse of _StashOutputDirectory.
				123
				124	Moves the output directory stashed within the default output directory
				125	(out/Release) to the position where the builds can actually happen.
				126
				127	This is a dirty hack to deal with the needs of clobbering while also handling
				128	incremental builds and the hardcoded relative paths used in some of the
				129	project files.
				130
				131	Args:
				132	buildpath: The path where the building happens. If this corresponds to the
				133	default output directory, no action is taken.
				134	"""
				135	if os.path.abspath(buildpath) == os.path.abspath(os.path.dirname(
				136	constants.GetOutDirectory())):
				137	return
				138	name = os.path.basename(buildpath)
				139	stashpath = os.path.join(constants.GetOutDirectory(), name)
				140	if not os.path.exists(stashpath):
				141	return
				142	if os.path.exists(buildpath):
				143	shutil.rmtree(buildpath, ignore_errors=True)
				144	shutil.move(stashpath, buildpath)
				145
				146
				147	class StepRecorder(object):
				148	"""Records steps and timings."""
				149
				150	def __init__(self, buildbot):
				151	self.timings = []
				152	self._previous_step = ('', 0.0)
				153	self._buildbot = buildbot
				154	self._error_recorded = False
				155
				156	def BeginStep(self, name):
				157	"""Marks a beginning of the next step in the script.
				158
				159	On buildbot, this prints a specially formatted name that will show up
				160	in the waterfall. Otherwise, just prints the step name.
				161
				162	Args:
				163	name: The name of the step.
				164	"""
				165	self.EndStep()
				166	self._previous_step = (name, time.time())
				167	print 'Running step: ', name
				168
				169	def EndStep(self):
				170	"""Records successful completion of the current step.
				171
				172	This is optional if the step is immediately followed by another BeginStep.
				173	"""
				174	if self._previous_step[0]:
				175	elapsed = time.time() - self._previous_step[1]
				176	print 'Step %s took %f seconds' % (self._previous_step[0], elapsed)
				177	self.timings.append((self._previous_step[0], elapsed))
				178
				179	self._previous_step = ('', 0.0)
				180
				181	def FailStep(self, message=None):
				182	"""Marks that a particular step has failed.
				183
				184	On buildbot, this will mark the current step as failed on the waterfall.
				185	Otherwise we will just print an optional failure message.
				186
				187	Args:
				188	message: An optional explanation as to why the step failed.
				189	"""
				190	print 'STEP FAILED!!'
				191	if message:
				192	print message
				193	self._error_recorded = True
				194	self.EndStep()
				195
				196	def ErrorRecorded(self):
				197	"""True if FailStep has been called."""
				198	return self._error_recorded
				199
				200	def RunCommand(self, cmd, cwd=constants.DIR_SOURCE_ROOT, raise_on_error=True,
				201	stdout=None):
				202	"""Execute a shell command.
				203
				204	Args:
				205	cmd: A list of command strings.
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	206	cwd: Directory in which the command should be executed, defaults to build
				207	root of script's location if not specified.
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	208	raise_on_error: If true will raise a CommandError if the call doesn't
				209	succeed and mark the step as failed.
				210	stdout: A file to redirect stdout for the command to.
				211
				212	Returns:
				213	The process's return code.
				214
				215	Raises:
				216	CommandError: An error executing the specified command.
				217	"""
				218	print 'Executing %s in %s' % (' '.join(cmd), cwd)
				219	process = subprocess.Popen(cmd, stdout=stdout, cwd=cwd, env=os.environ)
				220	process.wait()
				221	if raise_on_error and process.returncode != 0:
				222	self.FailStep()
				223	raise CommandError('Exception executing command %s' % ' '.join(cmd))
				224	return process.returncode
				225
				226
				227	class ClankCompiler(object):
				228	"""Handles compilation of clank."""
				229
				230	def __init__(self, out_dir, step_recorder, arch, jobs, max_load, use_goma,
Matthew Cary	d6bfcb7	2018-09-14 11:27:46	[diff] [blame]	231	goma_dir, system_health_profiling, monochrome):
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	232	self._out_dir = out_dir
				233	self._step_recorder = step_recorder
Benoit Lize	a87e5bc	2017-11-07 15:12:57	[diff] [blame]	234	self._arch = arch
				235	self._jobs = jobs
				236	self._max_load = max_load
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	237	self._use_goma = use_goma
Benoit Lize	a87e5bc	2017-11-07 15:12:57	[diff] [blame]	238	self._goma_dir = goma_dir
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	239	self._system_health_profiling = system_health_profiling
Matthew Cary	d6bfcb7	2018-09-14 11:27:46	[diff] [blame]	240	if monochrome:
				241	self._apk = 'Monochrome.apk'
Matthew Cary	e1b0006	2018-09-19 14:27:44	[diff] [blame]	242	self._apk_target = 'monochrome_apk'
Matthew Cary	d6bfcb7	2018-09-14 11:27:46	[diff] [blame]	243	self._libname = 'libmonochrome'
				244	self._libchrome_target = 'monochrome'
				245	else:
				246	self._apk = 'Chrome.apk'
Matthew Cary	e1b0006	2018-09-19 14:27:44	[diff] [blame]	247	self._apk_target = 'chrome_apk'
Matthew Cary	d6bfcb7	2018-09-14 11:27:46	[diff] [blame]	248	self._libname = 'libchrome'
				249	self._libchrome_target = 'libchrome'
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	250
				251	self.obj_dir = os.path.join(self._out_dir, 'Release', 'obj')
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	252	self.lib_chrome_so = os.path.join(
Matthew Cary	d6bfcb7	2018-09-14 11:27:46	[diff] [blame]	253	self._out_dir, 'Release', 'lib.unstripped',
				254	'{}.so'.format(self._libname))
				255	self.chrome_apk = os.path.join(self._out_dir, 'Release', 'apks', self._apk)
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	256
				257	def Build(self, instrumented, target):
				258	"""Builds the provided ninja target with or without order_profiling on.
				259
				260	Args:
Benoit Lize	a87e5bc	2017-11-07 15:12:57	[diff] [blame]	261	instrumented: (bool) Whether we want to build an instrumented binary.
				262	target: (str) The name of the ninja target to build.
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	263	"""
				264	self._step_recorder.BeginStep('Compile %s' % target)
				265
				266	# Set the "Release Official" flavor, the parts affecting performance.
				267	args = [
Peter Collingbourne	1c85d5d2	2018-08-22 18:06:35	[diff] [blame]	268	'enable_resource_whitelist_generation=false',
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	269	'is_chrome_branded=true',
				270	'is_debug=false',
				271	'is_official_build=true',
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	272	'target_cpu="' + self._arch + '"',
				273	'target_os="android"',
				274	'use_goma=' + str(self._use_goma).lower(),
				275	'use_order_profiling=' + str(instrumented).lower(),
				276	]
				277	if self._goma_dir:
				278	args += ['goma_dir="%s"' % self._goma_dir]
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	279	if self._system_health_profiling:
				280	args += ['devtools_instrumentation_dumping = ' +
				281	str(instrumented).lower()]
Benoit Lize	a87e5bc	2017-11-07 15:12:57	[diff] [blame]	282
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	283	self._step_recorder.RunCommand(
				284	['gn', 'gen', os.path.join(self._out_dir, 'Release'),
				285	'--args=' + ' '.join(args)])
				286
				287	self._step_recorder.RunCommand(
				288	['ninja', '-C', os.path.join(self._out_dir, 'Release'),
				289	'-j' + str(self._jobs), '-l' + str(self._max_load), target])
				290
				291	def CompileChromeApk(self, instrumented, force_relink=False):
				292	"""Builds a Chrome.apk either with or without order_profiling on.
				293
				294	Args:
Benoit Lize	a87e5bc	2017-11-07 15:12:57	[diff] [blame]	295	instrumented: (bool) Whether to build an instrumented apk.
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	296	force_relink: Whether libchromeview.so should be re-created.
				297	"""
				298	if force_relink:
				299	self._step_recorder.RunCommand(['rm', '-rf', self.lib_chrome_so])
Matthew Cary	e1b0006	2018-09-19 14:27:44	[diff] [blame]	300	self.Build(instrumented, self._apk_target)
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	301
				302	def CompileLibchrome(self, instrumented, force_relink=False):
				303	"""Builds a libchrome.so either with or without order_profiling on.
				304
				305	Args:
Benoit Lize	a87e5bc	2017-11-07 15:12:57	[diff] [blame]	306	instrumented: (bool) Whether to build an instrumented apk.
				307	force_relink: (bool) Whether libchrome.so should be re-created.
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	308	"""
				309	if force_relink:
				310	self._step_recorder.RunCommand(['rm', '-rf', self.lib_chrome_so])
Matthew Cary	d6bfcb7	2018-09-14 11:27:46	[diff] [blame]	311	self.Build(instrumented, self._libchrome_target)
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	312
				313
				314	class OrderfileUpdater(object):
				315	"""Handles uploading and committing a new orderfile in the repository.
				316
				317	Only used for testing or on a bot.
				318	"""
				319
				320	_CLOUD_STORAGE_BUCKET_FOR_DEBUG = None
				321	_CLOUD_STORAGE_BUCKET = None
				322	_UPLOAD_TO_CLOUD_COMMAND = 'upload_to_google_storage.py'
				323
				324	def __init__(self, repository_root, step_recorder, branch, netrc):
				325	"""Constructor.
				326
				327	Args:
				328	repository_root: (str) Root of the target repository.
				329	step_recorder: (StepRecorder) Step recorder, for logging.
				330	branch: (str) Branch to commit to.
				331	netrc: (str) Path to the .netrc file to use.
				332	"""
				333	self._repository_root = repository_root
				334	self._step_recorder = step_recorder
				335	self._branch = branch
				336	self._netrc = netrc
				337
				338	def CommitFileHashes(self, unpatched_orderfile_filename, orderfile_filename):
				339	"""Commits unpatched and patched orderfiles hashes, if provided.
				340
				341	Files must have been successfilly uploaded to cloud storage first.
				342
				343	Args:
				344	unpatched_orderfile_filename: (str or None) Unpatched orderfile path.
				345	orderfile_filename: (str or None) Orderfile path.
				346
				347	Raises:
				348	NotImplementedError when the commit logic hasn't been overriden.
				349	"""
				350	files_to_commit = []
				351	commit_message_lines = ['Update Orderfile.']
				352	for filename in [unpatched_orderfile_filename, orderfile_filename]:
				353	if not filename:
				354	continue
				355	(relative_path, sha1) = self._GetHashFilePathAndContents(filename)
				356	commit_message_lines.append('Profile: %s: %s' % (
				357	os.path.basename(relative_path), sha1))
				358	files_to_commit.append(relative_path)
				359	if files_to_commit:
				360	self._CommitFiles(files_to_commit, commit_message_lines)
				361
				362	def UploadToCloudStorage(self, filename, use_debug_location):
				363	"""Uploads a file to cloud storage.
				364
				365	Args:
				366	filename: (str) File to upload.
				367	use_debug_location: (bool) Whether to use the debug location.
				368	"""
				369	bucket = (self._CLOUD_STORAGE_BUCKET_FOR_DEBUG if use_debug_location
				370	else self._CLOUD_STORAGE_BUCKET)
				371	extension = _GetFileExtension(filename)
				372	cmd = [self._UPLOAD_TO_CLOUD_COMMAND, '--bucket', bucket]
				373	if extension:
				374	cmd.extend(['-z', extension])
				375	cmd.append(filename)
				376	self._step_recorder.RunCommand(cmd)
				377	print 'Download: https://sandbox.google.com/storage/%s/%s' % (
				378	bucket, _GenerateHash(filename))
				379
				380	def _GetHashFilePathAndContents(self, filename):
				381	"""Gets the name and content of the hash file created from uploading the
				382	given file.
				383
				384	Args:
				385	filename: (str) The file that was uploaded to cloud storage.
				386
				387	Returns:
				388	A tuple of the hash file name, relative to the reository root, and the
				389	content, which should be the sha1 hash of the file
				390	('base_file.sha1', hash)
				391	"""
				392	abs_hash_filename = filename + '.sha1'
				393	rel_hash_filename = os.path.relpath(
				394	abs_hash_filename, self._repository_root)
				395	with open(abs_hash_filename, 'r') as f:
				396	return (rel_hash_filename, f.read())
				397
				398	def _CommitFiles(self, files_to_commit, commit_message_lines):
				399	"""Commits a list of files, with a given message."""
				400	raise NotImplementedError
				401
				402
				403	class OrderfileGenerator(object):
				404	"""A utility for generating a new orderfile for Clank.
				405
				406	Builds an instrumented binary, profiles a run of the application, and
				407	generates an updated orderfile.
				408	"""
				409	_CLANK_REPO = os.path.join(constants.DIR_SOURCE_ROOT, 'clank')
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	410	_CHECK_ORDERFILE_SCRIPT = os.path.join(
				411	constants.DIR_SOURCE_ROOT, 'tools', 'cygprofile', 'check_orderfile.py')
				412	_BUILD_ROOT = os.path.abspath(os.path.dirname(os.path.dirname(
				413	constants.GetOutDirectory()))) # Normally /path/to/src
				414
				415	_UNPATCHED_ORDERFILE_FILENAME = os.path.join(
				416	_CLANK_REPO, 'orderfiles', 'unpatched_orderfile.%s')
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	417
				418	_PATH_TO_ORDERFILE = os.path.join(_CLANK_REPO, 'orderfiles',
				419	'orderfile.%s.out')
				420
				421	# Previous orderfile_generator debug files would be overwritten.
				422	_DIRECTORY_FOR_DEBUG_FILES = '/tmp/orderfile_generator_debug_files'
				423
				424	def _GetPathToOrderfile(self):
				425	"""Gets the path to the architecture-specific orderfile."""
				426	return self._PATH_TO_ORDERFILE % self._options.arch
				427
				428	def _GetUnpatchedOrderfileFilename(self):
				429	"""Gets the path to the architecture-specific unpatched orderfile."""
				430	return self._UNPATCHED_ORDERFILE_FILENAME % self._options.arch
				431
				432	def __init__(self, options, orderfile_updater_class):
				433	self._options = options
				434
				435	self._instrumented_out_dir = os.path.join(
				436	self._BUILD_ROOT, self._options.arch + '_instrumented_out')
				437	self._uninstrumented_out_dir = os.path.join(
				438	self._BUILD_ROOT, self._options.arch + '_uninstrumented_out')
				439
				440	if options.profile:
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	441	output_directory = os.path.join(self._instrumented_out_dir, 'Release')
Matthew Cary	b8daed94	2018-06-11 10:58:08	[diff] [blame]	442	host_profile_dir = os.path.join(output_directory, 'profile_data')
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	443	urls = [profile_android_startup.AndroidProfileTool.TEST_URL]
				444	use_wpr = True
				445	simulate_user = False
Benoit L	9646681	2018-03-06 15:58:37	[diff] [blame]	446	urls = options.urls
				447	use_wpr = not options.no_wpr
				448	simulate_user = options.simulate_user
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	449	self._profiler = profile_android_startup.AndroidProfileTool(
Matthew Cary	453ff145	2018-07-18 12:19:35	[diff] [blame]	450	output_directory, host_profile_dir, use_wpr, urls, simulate_user,
				451	device=options.device)
Matthew Cary	69e9e42	2018-08-10 18:30:06	[diff] [blame]	452	if options.pregenerated_profiles:
				453	self._profiler.SetPregeneratedProfiles(
				454	glob.glob(options.pregenerated_profiles))
				455	else:
				456	assert not options.pregenerated_profiles, (
				457	'--pregenerated-profiles cannot be used with --skip-profile')
				458	assert not options.profile_save_dir, (
				459	'--profile-save-dir cannot be used with --skip-profile')
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	460
				461	self._output_data = {}
				462	self._step_recorder = StepRecorder(options.buildbot)
				463	self._compiler = None
				464	assert issubclass(orderfile_updater_class, OrderfileUpdater)
				465	self._orderfile_updater = orderfile_updater_class(self._CLANK_REPO,
				466	self._step_recorder,
				467	options.branch,
				468	options.netrc)
				469	assert os.path.isdir(constants.DIR_SOURCE_ROOT), 'No src directory found'
Benoit Lize	fefbb27c	2018-01-17 13:54:18	[diff] [blame]	470	symbol_extractor.SetArchitecture(options.arch)
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	471
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	472	@staticmethod
				473	def _RemoveBlanks(src_file, dest_file):
				474	"""A utility to remove blank lines from a file.
				475
				476	Args:
				477	src_file: The name of the file to remove the blanks from.
				478	dest_file: The name of the file to write the output without blanks.
				479	"""
				480	assert src_file != dest_file, 'Source and destination need to be distinct'
				481
				482	try:
				483	src = open(src_file, 'r')
				484	dest = open(dest_file, 'w')
				485	for line in src:
				486	if line and not line.isspace():
				487	dest.write(line)
				488	finally:
				489	src.close()
				490	dest.close()
				491
				492	def _GenerateAndProcessProfile(self):
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	493	"""Invokes a script to merge the per-thread traces into one file.
				494
				495	The produced list of offsets is saved in
				496	self._GetUnpatchedOrderfileFilename().
				497	"""
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	498	self._step_recorder.BeginStep('Generate Profile Data')
				499	files = []
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	500	logging.getLogger().setLevel(logging.DEBUG)
				501	if self._options.system_health_orderfile:
				502	files = self._profiler.CollectSystemHealthProfile(
				503	self._compiler.chrome_apk)
Matthew Cary	69e9e42	2018-08-10 18:30:06	[diff] [blame]	504	self._MaybeSaveProfile(files)
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	505	try:
				506	self._ProcessPhasedOrderfile(files)
				507	except Exception:
				508	for f in files:
				509	self._SaveForDebugging(f)
Matthew Cary	8b141623	2018-08-10 19:12:22	[diff] [blame]	510	self._SaveForDebugging(self._compiler.lib_chrome_so)
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	511	raise
				512	finally:
				513	self._profiler.Cleanup()
				514	else:
				515	self._CollectLegacyProfile()
				516	logging.getLogger().setLevel(logging.INFO)
				517
				518	def _ProcessPhasedOrderfile(self, files):
				519	"""Process the phased orderfiles produced by system health benchmarks.
				520
				521	The offsets will be placed in _GetUnpatchedOrderfileFilename().
				522
				523	Args:
				524	file: Profile files pulled locally.
				525	"""
				526	self._step_recorder.BeginStep('Process Phased Orderfile')
				527	profiles = process_profiles.ProfileManager(files)
				528	processor = process_profiles.SymbolOffsetProcessor(
				529	self._compiler.lib_chrome_so)
Matthew Cary	91df979	2018-11-30 14:35:15	[diff] [blame^]	530	ordered_symbols= cluster.ClusterOffsets(profiles, processor)
Matthew Cary	8b141623	2018-08-10 19:12:22	[diff] [blame]	531	if not ordered_symbols:
				532	raise Exception('Failed to get ordered symbols')
Matthew Cary	91df979	2018-11-30 14:35:15	[diff] [blame^]	533	self._output_data['offsets_kib'] = processor.SymbolsSize(
				534	ordered_symbols) / 1024
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	535	with open(self._GetUnpatchedOrderfileFilename(), 'w') as orderfile:
Matthew Cary	8b141623	2018-08-10 19:12:22	[diff] [blame]	536	orderfile.write('\n'.join(ordered_symbols))
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	537
				538	def _CollectLegacyProfile(self):
Matthew Cary	2df8d45	2018-09-19 07:50:20	[diff] [blame]	539	files = []
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	540	try:
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	541	files = self._profiler.CollectProfile(
				542	self._compiler.chrome_apk,
				543	constants.PACKAGE_INFO['chrome'])
Matthew Cary	69e9e42	2018-08-10 18:30:06	[diff] [blame]	544	self._MaybeSaveProfile(files)
Matthew Cary	b8daed94	2018-06-11 10:58:08	[diff] [blame]	545	self._step_recorder.BeginStep('Process profile')
Benoit L	9646681	2018-03-06 15:58:37	[diff] [blame]	546	assert os.path.exists(self._compiler.lib_chrome_so)
				547	offsets = process_profiles.GetReachedOffsetsFromDumpFiles(
				548	files, self._compiler.lib_chrome_so)
				549	if not offsets:
				550	raise Exception('No profiler offsets found in {}'.format(
				551	'\n'.join(files)))
Matthew Cary	8b141623	2018-08-10 19:12:22	[diff] [blame]	552	processor = process_profiles.SymbolOffsetProcessor(
				553	self._compiler.lib_chrome_so)
				554	ordered_symbols = processor.GetOrderedSymbols(offsets)
				555	if not ordered_symbols:
				556	raise Exception('No symbol names from offsets found in {}'.format(
				557	'\n'.join(files)))
				558	with open(self._GetUnpatchedOrderfileFilename(), 'w') as orderfile:
				559	orderfile.write('\n'.join(ordered_symbols))
Matthew Cary	0f1f681a	2018-01-22 10:40:51	[diff] [blame]	560	except Exception:
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	561	for f in files:
				562	self._SaveForDebugging(f)
				563	raise
				564	finally:
				565	self._profiler.Cleanup()
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	566
Matthew Cary	69e9e42	2018-08-10 18:30:06	[diff] [blame]	567	def _MaybeSaveProfile(self, files):
				568	if self._options.profile_save_dir:
				569	logging.info('Saving profiles to %s', self._options.profile_save_dir)
				570	for f in files:
				571	shutil.copy(f, self._options.profile_save_dir)
				572	logging.info('Saved profile %s', f)
				573
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	574	def _PatchOrderfile(self):
				575	"""Patches the orderfile using clean version of libchrome.so."""
				576	self._step_recorder.BeginStep('Patch Orderfile')
Benoit Lize	fefbb27c	2018-01-17 13:54:18	[diff] [blame]	577	patch_orderfile.GeneratePatchedOrderfile(
				578	self._GetUnpatchedOrderfileFilename(), self._compiler.lib_chrome_so,
				579	self._GetPathToOrderfile())
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	580
				581	def _VerifySymbolOrder(self):
				582	self._step_recorder.BeginStep('Verify Symbol Order')
				583	return_code = self._step_recorder.RunCommand(
				584	[self._CHECK_ORDERFILE_SCRIPT, self._compiler.lib_chrome_so,
				585	self._GetPathToOrderfile(),
				586	'--target-arch=' + self._options.arch],
				587	constants.DIR_SOURCE_ROOT,
				588	raise_on_error=False)
				589	if return_code:
				590	self._step_recorder.FailStep('Orderfile check returned %d.' % return_code)
				591
				592	def _RecordHash(self, file_name):
				593	"""Records the hash of the file into the output_data dictionary."""
				594	self._output_data[os.path.basename(file_name) + '.sha1'] = _GenerateHash(
				595	file_name)
				596
				597	def _SaveFileLocally(self, file_name, file_sha1):
				598	"""Saves the file to a temporary location and prints the sha1sum."""
				599	if not os.path.exists(self._DIRECTORY_FOR_DEBUG_FILES):
				600	os.makedirs(self._DIRECTORY_FOR_DEBUG_FILES)
				601	shutil.copy(file_name, self._DIRECTORY_FOR_DEBUG_FILES)
				602	print 'File: %s, saved in: %s, sha1sum: %s' % (
				603	file_name, self._DIRECTORY_FOR_DEBUG_FILES, file_sha1)
				604
				605	def _SaveForDebugging(self, filename):
				606	"""Uploads the file to cloud storage or saves to a temporary location."""
				607	file_sha1 = _GenerateHash(filename)
				608	if not self._options.buildbot:
				609	self._SaveFileLocally(filename, file_sha1)
				610	else:
				611	print 'Uploading file for debugging: ' + filename
				612	self._orderfile_updater.UploadToCloudStorage(
				613	filename, use_debug_location=True)
				614
				615	def _SaveForDebuggingWithOverwrite(self, file_name):
				616	"""Uploads and overwrites the file in cloud storage or copies locally.
				617
				618	Should be used for large binaries like lib_chrome_so.
				619
				620	Args:
				621	file_name: (str) File to upload.
				622	"""
				623	file_sha1 = _GenerateHash(file_name)
				624	if not self._options.buildbot:
				625	self._SaveFileLocally(file_name, file_sha1)
				626	else:
				627	print 'Uploading file for debugging: %s, sha1sum: %s' % (
				628	file_name, file_sha1)
				629	upload_location = '%s/%s' % (
				630	self._CLOUD_STORAGE_BUCKET_FOR_DEBUG, os.path.basename(file_name))
				631	self._step_recorder.RunCommand([
				632	'gsutil.py', 'cp', file_name, 'gs://' + upload_location])
				633	print ('Uploaded to: https://sandbox.google.com/storage/' +
				634	upload_location)
				635
				636	def _MaybeArchiveOrderfile(self, filename):
				637	"""In buildbot configuration, uploads the generated orderfile to
				638	Google Cloud Storage.
				639
				640	Args:
				641	filename: (str) Orderfile to upload.
				642	"""
Matthew Cary	91df979	2018-11-30 14:35:15	[diff] [blame^]	643	# First compute hashes so that we can download them later if we need to.
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	644	self._step_recorder.BeginStep('Compute hash for ' + filename)
				645	self._RecordHash(filename)
				646	if self._options.buildbot:
				647	self._step_recorder.BeginStep('Archive ' + filename)
				648	self._orderfile_updater.UploadToCloudStorage(
				649	filename, use_debug_location=False)
				650
Egor Pasko	bce64d01	2018-11-20 12:02:37	[diff] [blame]	651	def UploadReadyOrderfiles(self):
				652	self._step_recorder.BeginStep('Upload Ready Orderfiles')
				653	for file_name in [self._GetUnpatchedOrderfileFilename(),
				654	self._GetPathToOrderfile()]:
				655	self._orderfile_updater.UploadToCloudStorage(
				656	file_name, use_debug_location=False)
				657
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	658	def _GetHashFilePathAndContents(self, base_file):
				659	"""Gets the name and content of the hash file created from uploading the
				660	given file.
				661
				662	Args:
				663	base_file: The file that was uploaded to cloud storage.
				664
				665	Returns:
				666	A tuple of the hash file name, relative to the clank repo path, and the
				667	content, which should be the sha1 hash of the file
				668	('base_file.sha1', hash)
				669	"""
				670	abs_file_name = base_file + '.sha1'
				671	rel_file_name = os.path.relpath(abs_file_name, self._CLANK_REPO)
				672	with open(abs_file_name, 'r') as f:
				673	return (rel_file_name, f.read())
				674
				675	def Generate(self):
				676	"""Generates and maybe upload an order."""
				677	profile_uploaded = False
				678	orderfile_uploaded = False
				679
Matthew Cary	e840064	2018-06-14 15:43:02	[diff] [blame]	680	assert (bool(self._options.profile) ^
				681	bool(self._options.manual_symbol_offsets))
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	682	if self._options.system_health_orderfile and not self._options.profile:
				683	raise AssertionError('--system_health_orderfile must be not be used '
				684	'with --skip-profile')
				685	if (self._options.manual_symbol_offsets and
				686	not self._options.system_health_orderfile):
				687	raise AssertionError('--manual-symbol-offsets must be used with '
				688	'--system_health_orderfile.')
Matthew Cary	e840064	2018-06-14 15:43:02	[diff] [blame]	689
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	690	if self._options.profile:
				691	try:
				692	_UnstashOutputDirectory(self._instrumented_out_dir)
				693	self._compiler = ClankCompiler(
				694	self._instrumented_out_dir,
				695	self._step_recorder, self._options.arch, self._options.jobs,
				696	self._options.max_load, self._options.use_goma,
Matthew Cary	d6bfcb7	2018-09-14 11:27:46	[diff] [blame]	697	self._options.goma_dir, self._options.system_health_orderfile,
				698	self._options.monochrome)
Matthew Cary	a2bea45	2018-11-13 10:21:07	[diff] [blame]	699	if not self._options.pregenerated_profiles:
				700	# If there are pregenerated profiles, the instrumented build should
				701	# not be changed to avoid invalidating the pregenerated profile
				702	# offsets.
				703	self._compiler.CompileChromeApk(True)
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	704	self._GenerateAndProcessProfile()
				705	self._MaybeArchiveOrderfile(self._GetUnpatchedOrderfileFilename())
				706	profile_uploaded = True
				707	finally:
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	708	_StashOutputDirectory(self._instrumented_out_dir)
Matthew Cary	e840064	2018-06-14 15:43:02	[diff] [blame]	709	elif self._options.manual_symbol_offsets:
				710	assert self._options.manual_libname
				711	assert self._options.manual_objdir
				712	with file(self._options.manual_symbol_offsets) as f:
				713	symbol_offsets = [int(x) for x in f.xreadlines()]
				714	processor = process_profiles.SymbolOffsetProcessor(
Matthew Cary	b46ad28	2018-11-23 14:43:57	[diff] [blame]	715	self._compiler.manual_libname)
Matthew Cary	e840064	2018-06-14 15:43:02	[diff] [blame]	716	generator = cyglog_to_orderfile.OffsetOrderfileGenerator(
				717	processor, cyglog_to_orderfile.ObjectFileProcessor(
				718	self._options.manual_objdir))
				719	ordered_sections = generator.GetOrderedSections(symbol_offsets)
				720	if not ordered_sections: # Either None or empty is a problem.
				721	raise Exception('Failed to get ordered sections')
				722	with open(self._GetUnpatchedOrderfileFilename(), 'w') as orderfile:
				723	orderfile.write('\n'.join(ordered_sections))
				724
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	725	if self._options.patch:
				726	if self._options.profile:
				727	self._RemoveBlanks(self._GetUnpatchedOrderfileFilename(),
				728	self._GetPathToOrderfile())
				729	try:
				730	_UnstashOutputDirectory(self._uninstrumented_out_dir)
				731	self._compiler = ClankCompiler(
				732	self._uninstrumented_out_dir, self._step_recorder,
				733	self._options.arch, self._options.jobs, self._options.max_load,
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	734	self._options.use_goma, self._options.goma_dir,
Matthew Cary	d6bfcb7	2018-09-14 11:27:46	[diff] [blame]	735	self._options.system_health_orderfile, self._options.monochrome)
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	736	self._compiler.CompileLibchrome(False)
				737	self._PatchOrderfile()
				738	# Because identical code folding is a bit different with and without
				739	# the orderfile build, we need to re-patch the orderfile with code
				740	# folding as close to the final version as possible.
				741	self._compiler.CompileLibchrome(False, force_relink=True)
				742	self._PatchOrderfile()
				743	self._compiler.CompileLibchrome(False, force_relink=True)
				744	self._VerifySymbolOrder()
				745	self._MaybeArchiveOrderfile(self._GetPathToOrderfile())
				746	finally:
				747	_StashOutputDirectory(self._uninstrumented_out_dir)
				748	orderfile_uploaded = True
				749
				750	if (self._options.buildbot and self._options.netrc
				751	and not self._step_recorder.ErrorRecorded()):
				752	unpatched_orderfile_filename = (
				753	self._GetUnpatchedOrderfileFilename() if profile_uploaded else None)
				754	orderfile_filename = (
Benoit Lize	d913be8	2017-10-24 13:38:27	[diff] [blame]	755	self._GetPathToOrderfile() if orderfile_uploaded else None)
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	756	self._orderfile_updater.CommitFileHashes(
				757	unpatched_orderfile_filename, orderfile_filename)
				758
				759	self._step_recorder.EndStep()
				760	return not self._step_recorder.ErrorRecorded()
				761
				762	def GetReportingData(self):
				763	"""Get a dictionary of reporting data (timings, output hashes)"""
				764	self._output_data['timings'] = self._step_recorder.timings
				765	return self._output_data
				766
				767
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	768	def CreateArgumentParser():
				769	"""Creates and returns the argument parser."""
				770	parser = argparse.ArgumentParser()
				771	parser.add_argument(
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	772	'--buildbot', action='store_true',
				773	help='If true, the script expects to be run on a buildbot')
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	774	parser.add_argument(
Matthew Cary	453ff145	2018-07-18 12:19:35	[diff] [blame]	775	'--device', default=None, type=str,
				776	help='Device serial number on which to run profiling.')
				777	parser.add_argument(
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	778	'--verify', action='store_true',
				779	help='If true, the script only verifies the current orderfile')
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	780	parser.add_argument('--target-arch', action='store', dest='arch',
				781	default=cygprofile_utils.DetectArchitecture(),
				782	choices=['arm', 'arm64', 'x86', 'x86_64', 'x64', 'mips'],
				783	help='The target architecture for which to build')
				784	parser.add_argument('--output-json', action='store', dest='json_file',
				785	help='Location to save stats in json format')
				786	parser.add_argument(
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	787	'--skip-profile', action='store_false', dest='profile', default=True,
				788	help='Don\'t generate a profile on the device. Only patch from the '
				789	'existing profile.')
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	790	parser.add_argument(
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	791	'--skip-patch', action='store_false', dest='patch', default=True,
				792	help='Only generate the raw (unpatched) orderfile, don\'t patch it.')
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	793	parser.add_argument(
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	794	'--netrc', action='store',
				795	help='A custom .netrc file to use for git checkin. Only used on bots.')
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	796	parser.add_argument(
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	797	'--branch', action='store', default='master',
				798	help='When running on buildbot with a netrc, the branch orderfile '
				799	'hashes get checked into.')
				800	# Note: -j50 was causing issues on the bot.
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	801	parser.add_argument(
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	802	'-j', '--jobs', action='store', default=20,
				803	help='Number of jobs to use for compilation.')
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	804	parser.add_argument(
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	805	'-l', '--max-load', action='store', default=4, help='Max cpu load.')
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	806	parser.add_argument('--goma-dir', help='GOMA directory.')
				807	parser.add_argument(
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	808	'--use-goma', action='store_true', help='Enable GOMA.', default=False)
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	809	parser.add_argument('--adb-path', help='Path to the adb binary.')
Matthew Cary	e840064	2018-06-14 15:43:02	[diff] [blame]	810
Matthew Cary	03642a2a	2018-10-15 09:08:08	[diff] [blame]	811	parser.add_argument('--system-health-orderfile', action='store_true',
				812	dest='system_health_orderfile', default=False,
Matthew Cary	c262f5d	2018-09-19 14:36:28	[diff] [blame]	813	help=('Create an orderfile based on an about:blank '
				814	'startup benchmark instead of system health '
				815	'benchmarks.'))
Matthew Cary	d6bfcb7	2018-09-14 11:27:46	[diff] [blame]	816	parser.add_argument('--monochrome', action='store_true',
				817	help=('Compile and instrument monochrome (for post-N '
				818	'devices).'))
Matthew Cary	78aae16	2018-08-10 17:16:30	[diff] [blame]	819
Matthew Cary	e840064	2018-06-14 15:43:02	[diff] [blame]	820	parser.add_argument('--manual-symbol-offsets', default=None, type=str,
				821	help=('File of list of ordered symbol offsets generated '
				822	'by manual profiling. Must set other --manual* '
				823	'flags if this is used, and must --skip-profile.'))
				824	parser.add_argument('--manual-libname', default=None, type=str,
				825	help=('Library filename corresponding to '
				826	'--manual-symbol-offsets.'))
				827	parser.add_argument('--manual-objdir', default=None, type=str,
				828	help=('Root of object file directory corresponding to '
				829	'--manual-symbol-offsets.'))
Matthew Cary	69e9e42	2018-08-10 18:30:06	[diff] [blame]	830	parser.add_argument('--pregenerated-profiles', default=None, type=str,
				831	help=('Pregenerated profiles to use instead of running '
				832	'profile step. Cannot be used with '
				833	'--skip-profiles.'))
				834	parser.add_argument('--profile-save-dir', default=None, type=str,
				835	help=('Directory to save any profiles created. These can '
				836	'be used with --pregenerated-profiles. Cannot be '
				837	'used with --skip-profiles.'))
Egor Pasko	bce64d01	2018-11-20 12:02:37	[diff] [blame]	838	parser.add_argument('--upload-ready-orderfiles', action='store_true',
				839	help=('Skip orderfile generation and manually upload '
				840	'orderfiles (both patched and unpatched) from '
				841	'their normal location in the tree to the cloud '
				842	'storage. DANGEROUS! USE WITH CARE!'))
Matthew Cary	e840064	2018-06-14 15:43:02	[diff] [blame]	843
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	844	profile_android_startup.AddProfileCollectionArguments(parser)
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	845	return parser
				846
				847
				848	def CreateOrderfile(options, orderfile_updater_class):
				849	"""Creates an oderfile.
				850
				851	Args:
				852	options: As returned from optparse.OptionParser.parse_args()
				853	orderfile_updater_class: (OrderfileUpdater) subclass of OrderfileUpdater.
				854
				855	Returns:
				856	True iff success.
				857	"""
				858	logging.basicConfig(level=logging.INFO)
				859	devil_chromium.Initialize(adb_path=options.adb_path)
				860
Egor Pasko	93e514e	2017-10-31 13:32:36	[diff] [blame]	861	generator = OrderfileGenerator(options, orderfile_updater_class)
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	862	try:
				863	if options.verify:
Egor Pasko	93e514e	2017-10-31 13:32:36	[diff] [blame]	864	generator._VerifySymbolOrder()
Egor Pasko	bce64d01	2018-11-20 12:02:37	[diff] [blame]	865	elif options.upload_ready_orderfiles:
				866	return generator.UploadReadyOrderfiles()
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	867	else:
Egor Pasko	93e514e	2017-10-31 13:32:36	[diff] [blame]	868	return generator.Generate()
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	869	finally:
Egor Pasko	93e514e	2017-10-31 13:32:36	[diff] [blame]	870	json_output = json.dumps(generator.GetReportingData(),
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	871	indent=2) + '\n'
				872	if options.json_file:
				873	with open(options.json_file, 'w') as f:
				874	f.write(json_output)
				875	print json_output
				876	return False
				877
				878
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	879	def main():
				880	parser = CreateArgumentParser()
				881	options = parser.parse_args()
Benoit Lize	a3fe293	2017-10-20 10:24:52	[diff] [blame]	882	return 0 if CreateOrderfile(options, OrderfileUpdater) else 1
				883
				884
				885	if __name__ == '__main__':
Benoit Lize	a1b64f8	2017-12-07 10:12:50	[diff] [blame]	886	sys.exit(main())