def prep_db_for_build_item_in_flavor(self, config, build, item, flavor):
"""Generates all the necessary build work to write to the db.
:config: PIRA configuration
:build: the build
:item: current item
:flavor: current flavor
:returns: unique ID for current item
"""
build_tuple = (u.generate_random_string(), build, '', flavor, build)
self.insert_data_builds(build_tuple)
# XXX My implementation returns the full path, including the file extension.
# In case something in the database goes wild, this could be it.
func_manager = fm.FunctorManager()
analyse_functor = func_manager.get_analyzer_file(build, item, flavor)
build_functor = func_manager.get_builder_file(build, item, flavor)
run_functor = func_manager.get_runner_file(build, item, flavor)
# TODO implement the get_submitter_file(build, item, flavor) method!
benchmark_name = config.get_benchmark_name(item)
submitter_functor = config.get_runner_func(build, item) + '/slurm_submitter_' + benchmark_name + flavor
exp_dir = config.get_analyser_exp_dir(build, item)
db_item_id = u.generate_random_string()
db_item_data = (db_item_id, benchmark_name, analyse_functor, build_functor, '', run_functor, submitter_functor,
exp_dir, build)
self.insert_data_items(db_item_data)
return db_item_id
def check_and_prepare(self, experiment_dir: str,
target_config: TargetConfiguration,
instr_config: InstrumentConfig) -> str:
cur_ep_dir = self.get_extrap_dir_name(
target_config, instr_config.get_instrumentation_iteration())
if not u.is_valid_file_name(cur_ep_dir):
log.get_logger().log(
'ExtrapProfileSink::check_and_prepare: Generated directory name no good. Abort\n'
+ cur_ep_dir,
level='error')
else:
if u.check_provided_directory(cur_ep_dir):
new_dir_name = cur_ep_dir + '_' + u.generate_random_string()
log.get_logger().log(
'ExtrapProfileSink::check_and_prepare: Moving old experiment directory to: '
+ new_dir_name,
level='info')
u.rename(cur_ep_dir, new_dir_name)
u.create_directory(cur_ep_dir)
cubex_name = experiment_dir + '/' + target_config.get_flavor(
) + '-' + target_config.get_target() + '.cubex'
log.get_logger().log(cubex_name)
if not u.is_file(cubex_name):
log.get_logger().log(
'ExtrapProfileSink::check_and_prepare: Returned experiment cube name is no file: '
+ cubex_name)
else:
return cubex_name
raise ProfileSinkException(
'ExtrapProfileSink: Could not create target directory or Cube dir bad.'
)
def main(arguments) -> None:
""" Main function for pira framework. Used to invoke the various components. """
show_pira_invoc_info(arguments)
invoc_cfg = process_args_for_invoc(arguments)
use_extra_p, extrap_config = process_args_for_extrap(arguments)
home_dir = U.get_cwd()
U.set_home_dir(home_dir)
U.make_dir(invoc_cfg.get_pira_dir())
BackendDefaults(invoc_cfg)
csv_config = process_args_for_csv(arguments)
try:
if arguments.config_version is 1:
config_loader = CLoader()
else:
config_loader = SCLoader()
configuration = config_loader.load_conf(invoc_cfg.get_path_to_cfg())
checker.check_configfile(configuration, arguments.config_version)
if B.check_queued_job():
# FIXME: Implement
L.get_logger().log(
'In this version of PIRA it is not yet implemented',
level='error')
assert (False)
else:
'''
This branch is running PIRA actively on the local machine.
It is blocking, and the user can track the progress in the terminal.
'''
L.get_logger().log('Running the local case')
# The FunctorManager manages loaded functors and generates the respective names
F.FunctorManager(configuration)
dbm = D.DBManager(D.DBManager.db_name + '.' + D.DBManager.db_ext)
dbm.create_cursor()
analyzer = A(configuration)
runner_factory = PiraRunnerFactory(invoc_cfg, configuration)
runner = runner_factory.get_simple_local_runner()
if use_extra_p:
L.get_logger().log('Running with Extra-P runner')
runner = runner_factory.get_scalability_runner(extrap_config)
if runner.has_sink():
analyzer.set_profile_sink(runner.get_sink())
# A build/place is a top-level directory
for build in configuration.get_builds():
L.get_logger().log('Build: ' + str(build))
app_tuple = (U.generate_random_string(), build, '', '')
dbm.insert_data_application(app_tuple)
# An item is a target/software in that directory
for item in configuration.get_items(build):
L.get_logger().log('Running for item ' + str(item))
# A flavor is a specific version to build
if configuration.has_local_flavors(build, item):
for flavor in configuration.get_flavors(build, item):
L.get_logger().log('Running for local flavor ' +
flavor,
level='debug')
# prepare database, and get a unique handle for current item.
db_item_id = dbm.prep_db_for_build_item_in_flavor(
configuration, build, item, flavor)
# Create configuration object for the item currently processed.
place = configuration.get_place(build)
t_config = TargetConfiguration(
place, build, item, flavor, db_item_id,
invoc_cfg.is_compile_time_filtering(),
invoc_cfg.get_hybrid_filter_iters())
# Execute using a local runner, given the generated target description
execute_with_config(runner, analyzer,
invoc_cfg.get_pira_iters(),
t_config, csv_config)
# If global flavor
else:
# TODO: Implement
L.get_logger().log(
'In this version of PIRA it is not yet implemented',
level='error')
assert (False)
U.change_cwd(home_dir)
except RuntimeError as rt_err:
U.change_cwd(home_dir)
L.get_logger().log('Runner.run caught exception. Message: ' +
str(rt_err),
level='error')
L.get_logger().dump_tape()
sys.exit(-1)
def __init__(self) -> None:
self.currentStr = U.generate_random_string()
