def InitializeBeamRepo(benchmark_spec):
"""Ensures environment is prepared for running Beam benchmarks.
In the absence of FLAGS.beam_location, initializes the beam source code base
by checking out the repository from github. Specific branch selection is
supported.
Args:
benchmark_spec: The PKB spec for the benchmark to run.
"""
if benchmark_spec.dpb_service.SERVICE_TYPE not in SUPPORTED_RUNNERS:
raise NotImplementedError('Unsupported Runner')
vm_util.GenTempDir()
if FLAGS.beam_location is None:
git_clone_command = [FLAGS.git_binary, 'clone', BEAM_REPO_LOCATION]
if FLAGS.beam_version:
git_clone_command.append('--branch={}'.format(FLAGS.beam_version))
git_clone_command.append('--single-branch')
vm_util.IssueCommand(git_clone_command, cwd=vm_util.GetTempDir())
elif not os.path.exists(FLAGS.beam_location):
raise errors.Config.InvalidValue(
'Directory indicated by beam_location does not exist: {}.'.format(
FLAGS.beam_location))
_PrebuildBeam()
def InitializeBeamRepo(benchmark_spec):
"""Ensures environment is prepared for running Beam benchmarks.
In the absence of FLAGS.beam_location, initializes the beam source code base
by checking out the repository from github. Specific branch selection is
supported.
Args:
benchmark_spec: The PKB spec for the benchmark to run.
"""
if benchmark_spec.dpb_service.SERVICE_TYPE not in SUPPORTED_RUNNERS:
raise NotImplementedError('Unsupported Runner')
vm_util.GenTempDir()
if FLAGS.beam_location is None:
clone_command = [
FLAGS.git_binary,
'clone',
BEAM_REPO_LOCATION,
]
if FLAGS.beam_version:
clone_command.append('--branch={}'.format(FLAGS.beam_version))
clone_command.append('--single-branch')
vm_util.IssueCommand(clone_command, cwd=vm_util.GetTempDir())
elif not os.path.exists(FLAGS.beam_location):
raise errors.Config.InvalidValue(
'Directory indicated by beam_location does not exist: '
'{}.'.format(FLAGS.beam_location))
if not FLAGS.beam_prebuilt:
mvn_command = [FLAGS.maven_binary]
mvn_command.extend(INSTALL_COMMAND_ARGS)
AddRunnerProfileMvnArgument(benchmark_spec.dpb_service.SERVICE_TYPE,
mvn_command, FLAGS.beam_runner_profile)
vm_util.IssueCommand(mvn_command, timeout=1500, cwd=_GetBeamDir())
def SetUpPKB():
"""Set globals and environment variables for PKB.
After SetUpPKB() returns, it should be possible to call PKB
functions, like benchmark_spec.Prepare() or benchmark_spec.Run().
SetUpPKB() also modifies the local file system by creating a temp
directory and storing new SSH keys.
"""
try:
_InitializeRunUri()
except errors.Error as e:
logging.error(e)
sys.exit(1)
# Initialize logging.
vm_util.GenTempDir()
if FLAGS.use_pkb_logging:
log_util.ConfigureLogging(
stderr_log_level=log_util.LOG_LEVELS[FLAGS.log_level],
log_path=vm_util.PrependTempDir(LOG_FILE_NAME),
run_uri=FLAGS.run_uri,
file_log_level=log_util.LOG_LEVELS[FLAGS.file_log_level])
logging.info('PerfKitBenchmarker version: %s', version.VERSION)
# Translate deprecated flags and log all provided flag values.
disk.WarnAndTranslateDiskFlags()
_LogCommandLineFlags()
# Register skip pending runs functionality.
RegisterSkipPendingRunsCheck(_SkipPendingRunsFile)
# Check environment.
if not FLAGS.ignore_package_requirements:
requirements.CheckBasicRequirements()
for executable in REQUIRED_EXECUTABLES:
if not vm_util.ExecutableOnPath(executable):
raise errors.Setup.MissingExecutableError(
'Could not find required executable "%s"', executable)
# Check mutually exclusive flags
if FLAGS.run_stage_iterations > 1 and FLAGS.run_stage_time > 0:
raise errors.Setup.InvalidFlagConfigurationError(
'Flags run_stage_iterations and run_stage_time are mutually exclusive'
)
vm_util.SSHKeyGen()
if FLAGS.static_vm_file:
with open(FLAGS.static_vm_file) as fp:
static_virtual_machine.StaticVirtualMachine.ReadStaticVirtualMachineFile(
fp)
events.initialization_complete.send(parsed_flags=FLAGS)
benchmark_lookup.SetBenchmarkModuleFunction(benchmark_sets.BenchmarkModule)
package_lookup.SetPackageModuleFunction(benchmark_sets.PackageModule)
def SetUpPKB():
"""Set globals and environment variables for PKB.
After SetUpPKB() returns, it should be possible to call PKB
functions, like benchmark_spec.Prepare() or benchmark_spec.Run().
SetUpPKB() also modifies the local file system by creating a temp
directory and storing new SSH keys.
"""
if not FLAGS.ignore_package_requirements:
requirements.CheckBasicRequirements()
for executable in REQUIRED_EXECUTABLES:
if not vm_util.ExecutableOnPath(executable):
raise errors.Setup.MissingExecutableError(
'Could not find required executable "%s"', executable)
if FLAGS.run_uri is None:
if stages.PROVISION in FLAGS.run_stage:
FLAGS.run_uri = str(uuid.uuid4())[-8:]
else:
# Attempt to get the last modified run directory.
run_uri = vm_util.GetLastRunUri()
if run_uri:
FLAGS.run_uri = run_uri
logging.warning(
'No run_uri specified. Attempting to run the following stages with '
'--run_uri=%s: %s', FLAGS.run_uri,
', '.join(FLAGS.run_stage))
else:
raise errors.Setup.NoRunURIError(
'No run_uri specified. Could not run the following stages: %s'
% ', '.join(FLAGS.run_stage))
elif not FLAGS.run_uri.isalnum() or len(
FLAGS.run_uri) > MAX_RUN_URI_LENGTH:
raise errors.Setup.BadRunURIError(
'run_uri must be alphanumeric and less '
'than or equal to 8 characters in '
'length.')
vm_util.GenTempDir()
log_util.ConfigureLogging(
stderr_log_level=log_util.LOG_LEVELS[FLAGS.log_level],
log_path=vm_util.PrependTempDir(LOG_FILE_NAME),
run_uri=FLAGS.run_uri,
file_log_level=log_util.LOG_LEVELS[FLAGS.file_log_level])
logging.info('PerfKitBenchmarker version: %s', version.VERSION)
vm_util.SSHKeyGen()
events.initialization_complete.send(parsed_flags=FLAGS)
def SetUpPKB():
"""Set globals and environment variables for PKB.
After SetUpPKB() returns, it should be possible to call PKB
functions, like benchmark_spec.Prepare() or benchmark_spec.Run().
SetUpPKB() also modifies the local file system by creating a temp
directory and storing new SSH keys.
"""
try:
_InitializeRunUri()
except errors.Error as e:
logging.error(e)
sys.exit(1)
# Initialize logging.
vm_util.GenTempDir()
log_util.ConfigureLogging(
stderr_log_level=log_util.LOG_LEVELS[FLAGS.log_level],
log_path=vm_util.PrependTempDir(LOG_FILE_NAME),
run_uri=FLAGS.run_uri,
file_log_level=log_util.LOG_LEVELS[FLAGS.file_log_level])
logging.info('PerfKitBenchmarker version: %s', version.VERSION)
# Translate deprecated flags and log all provided flag values.
disk.WarnAndTranslateDiskFlags()
_LogCommandLineFlags()
# Check environment.
if not FLAGS.ignore_package_requirements:
requirements.CheckBasicRequirements()
if FLAGS.os_type == os_types.WINDOWS and not vm_util.RunningOnWindows():
logging.error('In order to run benchmarks on Windows VMs, you must be '
'running on Windows.')
sys.exit(1)
for executable in REQUIRED_EXECUTABLES:
if not vm_util.ExecutableOnPath(executable):
raise errors.Setup.MissingExecutableError(
'Could not find required executable "%s"', executable)
vm_util.SSHKeyGen()
if FLAGS.static_vm_file:
with open(FLAGS.static_vm_file) as fp:
static_virtual_machine.StaticVirtualMachine.ReadStaticVirtualMachineFile(
fp)
events.initialization_complete.send(parsed_flags=FLAGS)
def RunBenchmarks(publish=True):
"""Runs all benchmarks in PerfKitBenchmarker.
Args:
publish: A boolean indicating whether results should be published.
Returns:
Exit status for the process.
"""
if FLAGS.version:
print version.VERSION
return
for executable in REQUIRED_EXECUTABLES:
if not vm_util.ExecutableOnPath(executable):
logging.error('Could not find required executable "%s".' %
executable)
return 1
if FLAGS.run_uri is None:
if FLAGS.run_stage not in [STAGE_ALL, STAGE_PREPARE]:
# Attempt to get the last modified run directory.
run_uri = vm_util.GetLastRunUri()
if run_uri:
FLAGS.run_uri = run_uri
logging.warning(
'No run_uri specified. Attempting to run "%s" with --run_uri=%s.',
FLAGS.run_stage, FLAGS.run_uri)
else:
logging.error('No run_uri specified. Could not run "%s".',
FLAGS.run_stage)
return 1
else:
FLAGS.run_uri = str(uuid.uuid4())[-8:]
elif not FLAGS.run_uri.isalnum() or len(
FLAGS.run_uri) > MAX_RUN_URI_LENGTH:
logging.error('run_uri must be alphanumeric and less than or equal '
'to 10 characters in length.')
return 1
vm_util.GenTempDir()
log_util.ConfigureLogging(
stderr_log_level=log_util.LOG_LEVELS[FLAGS.log_level],
log_path=vm_util.PrependTempDir(LOG_FILE_NAME),
run_uri=FLAGS.run_uri)
_LogCommandLineFlags()
if FLAGS.os_type == benchmark_spec.WINDOWS and not vm_util.RunningOnWindows(
):
logging.error('In order to run benchmarks on Windows VMs, you must be '
'running on Windows.')
return 1
vm_util.SSHKeyGen()
collector = SampleCollector()
events.initialization_complete.send(parsed_flags=FLAGS)
if FLAGS.static_vm_file:
with open(FLAGS.static_vm_file) as fp:
static_virtual_machine.StaticVirtualMachine.ReadStaticVirtualMachineFile(
fp)
if FLAGS.benchmark_config_pair:
# Convert benchmark_config_pair into a {benchmark_name: file_name}
# dictionary.
tmp_dict = {}
for config_pair in FLAGS.benchmark_config_pair:
pair = config_pair.split(':')
tmp_dict[pair[0]] = pair[1]
FLAGS.benchmark_config_pair = tmp_dict
try:
benchmark_list = benchmark_sets.GetBenchmarksFromFlags()
total_benchmarks = len(benchmark_list)
if FLAGS.parallelism > 1:
sequence_range = range(total_benchmarks, 0, -1)
args = [((benchmark, collector, sequence_counter,
total_benchmarks), {})
for benchmark, sequence_counter in zip(
benchmark_list, sequence_range)]
vm_util.RunThreaded(RunBenchmark,
args,
max_concurrent_threads=FLAGS.parallelism)
else:
sequence_range = range(1, total_benchmarks + 1)
for benchmark, sequence_counter in zip(benchmark_list,
sequence_range):
RunBenchmark(benchmark, collector, sequence_counter,
total_benchmarks)
finally:
if collector.samples:
collector.PublishSamples()
logging.info('Complete logs can be found at: %s',
vm_util.PrependTempDir(LOG_FILE_NAME))
if FLAGS.run_stage not in [STAGE_ALL, STAGE_CLEANUP]:
logging.info('To run again with this setup, please use --run_uri=%s',
FLAGS.run_uri)
def RunBenchmarks(publish=True):
"""Runs all benchmarks in PerfKitBenchmarker.
Args:
publish: A boolean indicating whether results should be published.
Returns:
Exit status for the process.
"""
if FLAGS.version:
print version.VERSION
return
if FLAGS.run_uri is None:
if FLAGS.run_stage not in [STAGE_ALL, STAGE_PREPARE]:
logging.error('Cannot run "%s" with unspecified run_uri.',
FLAGS.run_stage)
return 1
else:
FLAGS.run_uri = str(uuid.uuid4())[-8:]
elif not FLAGS.run_uri.isalnum() or len(
FLAGS.run_uri) > MAX_RUN_URI_LENGTH:
logging.error('run_uri must be alphanumeric and less than or equal '
'to 10 characters in length.')
return 1
vm_util.GenTempDir()
log_util.ConfigureLogging(
stderr_log_level=log_util.LOG_LEVELS[FLAGS.log_level],
log_path=vm_util.PrependTempDir('pkb.log'),
run_uri=FLAGS.run_uri)
unknown_benchmarks = ListUnknownBenchmarks()
if unknown_benchmarks:
logging.error('Unknown benchmark(s) provided: %s',
', '.join(unknown_benchmarks))
return 1
vm_util.SSHKeyGen()
collector = SampleCollector()
if FLAGS.static_vm_file:
with open(FLAGS.static_vm_file) as fp:
static_virtual_machine.StaticVirtualMachine.ReadStaticVirtualMachineFile(
fp)
if FLAGS.benchmark_config_pair:
# Convert benchmark_config_pair into a {benchmark_name: file_name}
# dictionary.
tmp_dict = {}
for config_pair in FLAGS.benchmark_config_pair:
pair = config_pair.split(':')
tmp_dict[pair[0]] = pair[1]
FLAGS.benchmark_config_pair = tmp_dict
try:
benchmark_list = benchmark_sets.GetBenchmarksFromFlags()
total_benchmarks = len(benchmark_list)
if FLAGS.parallelism > 1:
sequence_range = range(total_benchmarks, 0, -1)
args = [((benchmark, collector, sequence_counter,
total_benchmarks), {})
for benchmark, sequence_counter in zip(
benchmark_list, sequence_range)]
vm_util.RunThreaded(RunBenchmark,
args,
max_concurrent_threads=FLAGS.parallelism)
else:
sequence_range = range(1, total_benchmarks + 1)
for benchmark, sequence_counter in zip(benchmark_list,
sequence_range):
RunBenchmark(benchmark, collector, sequence_counter,
total_benchmarks)
finally:
if collector.samples:
collector.PublishSamples()
if FLAGS.run_stage not in [STAGE_ALL, STAGE_CLEANUP]:
logging.info('To run again with this setup, please use --run_uri=%s',
FLAGS.run_uri)
