def _ArgumentParser():
"""Build a command line argument's parser."""
task_parser = task_manager.CommandLineParser()
# Command parser when dealing with SandwichRunner.
sandwich_runner_parser = argparse.ArgumentParser(add_help=False)
sandwich_runner_parser.add_argument('--android', default=None, type=str,
dest='android_device_serial',
help='Android device\'s serial to use.')
# Plumbing parser to configure OPTIONS.
plumbing_parser = OPTIONS.GetParentParser('plumbing options')
# Main parser
parser = argparse.ArgumentParser(parents=[plumbing_parser])
subparsers = parser.add_subparsers(dest='subcommand', help='subcommand line')
# Record test trace subcommand.
record_trace_parser = subparsers.add_parser('record-test-trace',
parents=[sandwich_runner_parser],
help='Record a test trace using the trace_test.webserver_test.')
record_trace_parser.add_argument('--source-dir', type=str, required=True,
help='Base path where the files are opened '
'by the web server.')
record_trace_parser.add_argument('--page', type=str, required=True,
help='Source page in source-dir to navigate '
'to.')
record_trace_parser.add_argument('-o', '--output', type=str, required=True,
help='Output path of the generated trace.')
# Run subcommand.
run_parser = subparsers.add_parser('run',
parents=[sandwich_runner_parser, task_parser],
help='Run all steps using the task manager infrastructure.')
run_parser.add_argument('-g', '--gen-full', action='store_true',
help='Generate the full graph with all possible '
'benchmarks.')
run_parser.add_argument('--job', required=True,
help='JSON file with job description such as in sandwich_jobs/.')
run_parser.add_argument('-m', '--measure', default=[], nargs='+',
choices=[_SPEED_INDEX_MEASUREMENT, _MEMORY_MEASUREMENT],
dest='optional_measures', help='Enable optional measurements.')
run_parser.add_argument('--wpr-archive', default=None, type=str,
dest='wpr_archive_path',
help='WebPageReplay archive to use, instead of '
'generating one.')
run_parser.add_argument('--url-repeat', default=1, type=int,
help='How many times to repeat the urls.')
return parser
def Execute(self, *command_line_args):
builder = task_manager.Builder(self.output_directory)
@builder.RegisterTask('a')
def TaskA():
pass
@builder.RegisterTask('b')
def TaskB():
pass
@builder.RegisterTask('c', dependencies=[TaskA, TaskB])
def TaskC():
pass
@builder.RegisterTask('d', dependencies=[TaskA])
def TaskD():
pass
@builder.RegisterTask('e', dependencies=[TaskC])
def TaskE():
pass
@builder.RegisterTask('raise_exception', dependencies=[TaskB])
def TaskF():
raise TestException('Expected error.')
default_final_tasks = [TaskD, TaskE]
parser = task_manager.CommandLineParser()
cmd = ['-o', self.output_directory]
cmd.extend([i for i in command_line_args])
args = parser.parse_args(cmd)
with EatStdoutAndStderr():
return task_manager.ExecuteWithCommandLine(
args, [TaskA, TaskB, TaskC, TaskD, TaskE, TaskF],
default_final_tasks)
def _ArgumentParser():
"""Build a command line argument's parser."""
# Command line parser when dealing with _SetupBenchmarkMain.
sandwich_setup_parser = argparse.ArgumentParser(add_help=False)
sandwich_setup_parser.add_argument('--android',
default=None,
type=str,
dest='android_device_serial',
help='Android device\'s serial to use.')
sandwich_setup_parser.add_argument(
'-c',
'--corpus',
required=True,
help='Path to a JSON file with a corpus such as in %s/.' % _CORPUS_DIR)
sandwich_setup_parser.add_argument('-m',
'--measure',
default=[],
nargs='+',
choices=[
_SPEED_INDEX_MEASUREMENT,
_MEMORY_MEASUREMENT,
_TTFMP_MEASUREMENT
],
dest='optional_measures',
help='Enable optional measurements.')
sandwich_setup_parser.add_argument(
'-o',
'--output',
type=str,
required=True,
help='Path of the output directory to setup.')
sandwich_setup_parser.add_argument(
'-r',
'--url-repeat',
default=1,
type=int,
help='How many times to repeat the urls.')
# Plumbing parser to configure OPTIONS.
plumbing_parser = OPTIONS.GetParentParser('plumbing options')
# Main parser
parser = argparse.ArgumentParser(
parents=[plumbing_parser],
fromfile_prefix_chars=task_manager.FROMFILE_PREFIX_CHARS)
subparsers = parser.add_subparsers(dest='subcommand',
help='subcommand line')
# Setup NoState-Prefetch benchmarks subcommand.
subparsers.add_parser('setup-prefetch',
parents=[sandwich_setup_parser],
help='Setup all NoState-Prefetch benchmarks.')
# Setup Stale-While-Revalidate benchmarks subcommand.
swr_setup_parser = subparsers.add_parser(
'setup-swr',
parents=[sandwich_setup_parser],
help='Setup all Stale-While-Revalidate benchmarks.')
swr_setup_parser.add_argument(
'-d',
'--domains-csv',
type=argparse.FileType('r'),
required=True,
help='Path of the CSV containing the pattern of domains in a '
'`domain-patterns` column and a `usage` column in percent in how '
'likely they are in a page load.')
# Run benchmarks subcommand (used in _RunBenchmarkMain).
subparsers.add_parser(
'run',
parents=[task_manager.CommandLineParser()],
help='Run benchmarks steps using the task manager infrastructure.')
# Collect subcommand.
collect_csv_parser = subparsers.add_parser(
'collect-csv',
help='Collects all CSVs from Sandwich output directory into a single '
'CSV.')
collect_csv_parser.add_argument('output_dir',
type=str,
help='Path to the run output directory.')
collect_csv_parser.add_argument('output_csv',
type=argparse.FileType('w'),
help='Path to the output CSV.')
return parser
def Execute(self, command_line_args):
self.task_execution_history = []
builder = task_manager.Builder(self.output_directory, None)
@builder.RegisterTask('a')
def TaskA():
self.task_execution_history.append(TaskA.name)
@builder.RegisterTask('b')
def TaskB():
self.task_execution_history.append(TaskB.name)
@builder.RegisterTask('c', dependencies=[TaskA, TaskB])
def TaskC():
self.task_execution_history.append(TaskC.name)
@builder.RegisterTask('d', dependencies=[TaskA])
def TaskD():
self.task_execution_history.append(TaskD.name)
@builder.RegisterTask('e', dependencies=[TaskC])
def TaskE():
self.task_execution_history.append(TaskE.name)
@builder.RegisterTask('raise_exception', dependencies=[TaskD])
def RaiseExceptionTask():
self.task_execution_history.append(RaiseExceptionTask.name)
raise TestException('Expected error.')
@builder.RegisterTask('raise_keyboard_interrupt', dependencies=[TaskD])
def RaiseKeyboardInterruptTask():
self.task_execution_history.append(RaiseKeyboardInterruptTask.name)
raise KeyboardInterrupt
@builder.RegisterTask('sudden_death', dependencies=[TaskD])
def SimulateKillTask():
self.task_execution_history.append(SimulateKillTask.name)
raise MemoryError
@builder.RegisterTask('timeout_error', dependencies=[TaskD])
def SimulateTimeoutError():
self.task_execution_history.append(SimulateTimeoutError.name)
raise common_util.TimeoutError
@builder.RegisterTask('errno_ENOSPC', dependencies=[TaskD])
def SimulateENOSPC():
self.task_execution_history.append(SimulateENOSPC.name)
raise IOError(errno.ENOSPC, os.strerror(errno.ENOSPC))
@builder.RegisterTask('errno_EPERM', dependencies=[TaskD])
def SimulateEPERM():
self.task_execution_history.append(SimulateEPERM.name)
raise IOError(errno.EPERM, os.strerror(errno.EPERM))
default_final_tasks = [TaskD, TaskE]
if self.with_raise_exception_tasks:
default_final_tasks.extend([
RaiseExceptionTask, RaiseKeyboardInterruptTask,
SimulateKillTask, SimulateTimeoutError, SimulateENOSPC,
SimulateEPERM
])
task_parser = task_manager.CommandLineParser()
parser = argparse.ArgumentParser(
parents=[task_parser],
fromfile_prefix_chars=task_manager.FROMFILE_PREFIX_CHARS)
cmd = ['-o', self.output_directory]
cmd.extend([i for i in command_line_args])
args = parser.parse_args(cmd)
with EatStdoutAndStderr():
return task_manager.ExecuteWithCommandLine(args,
default_final_tasks)