def tear_down(self, old_dir, exp_dir): isdirectory_good = U.check_provided_directory(exp_dir) if isdirectory_good: try: U.change_cwd(old_dir) except Exception as e: L.get_logger().log(str(e), level='error')
def set_up(self) -> None: L.get_logger().log('Builder::set_up for ' + self.directory) directory_good = U.check_provided_directory(self.directory) if directory_good: self.old_cwd = U.get_cwd() U.change_cwd(self.directory) else: self.error = True raise Exception('Builder::set_up: Could not change to directory')
def run(self, target_config: TargetConfiguration, instrument_config: InstrumentConfig, compile_time_filtering: bool) -> float: """ Implements the actual invocation """ functor_manager = fm.FunctorManager() run_functor = functor_manager.get_or_load_functor( target_config.get_build(), target_config.get_target(), target_config.get_flavor(), 'run') default_provider = defaults.BackendDefaults() kwargs = default_provider.get_default_kwargs() kwargs['util'] = util kwargs['LD_PRELOAD'] = default_provider.get_MPI_wrap_LD_PRELOAD() runtime = .0 if run_functor.get_method()['active']: run_functor.active(target_config.get_target(), **kwargs) log.get_logger().log( 'For the active functor we can barely measure runtime', level='warn') runtime = 1.0 try: util.change_cwd(target_config.get_place()) invoke_arguments = target_config.get_args_for_invocation() kwargs['args'] = invoke_arguments if invoke_arguments is not None: log.get_logger().log('LocalBaseRunner::run: (args) ' + str(invoke_arguments)) command = run_functor.passive(target_config.get_target(), **kwargs) _, runtime = util.shell(command, time_invoc=True) log.get_logger().log( 'LocalBaseRunner::run::passive_invocation -> Returned runtime: ' + str(runtime), level='debug') except Exception as e: log.get_logger().log('LocalBaseRunner::run Exception\n' + str(e), level='error') raise RuntimeError('LocalBaseRunner::run caught exception. ' + str(e)) # TODO: Insert the data into the database return runtime
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 tear_down(self) -> None: U.change_cwd(self.old_cwd)
def analyze_local(self, flavor: str, build: str, benchmark: str, kwargs: dict, iterationNumber: int) -> str: fm = F.FunctorManager() analyze_functor = fm.get_or_load_functor(build, benchmark, flavor, 'analyze') analyzer_dir = self.config.get_analyzer_dir(build, benchmark) kwargs['analyzer_dir'] = analyzer_dir # The invoke args can be retrieved from the configuration object. # Since the invoke args are iterable, we can create all necessary argument tuples here. # We construct a json file that contains the necesary information to be parsed vy the # PGIS tool. That way, we can make it easily traceable and debug from manual inspection. # This will be the new standard way of pusing information to PGIS. pgis_cfg_file = None if self._profile_sink.has_config_output(): pgis_cfg_file = self._profile_sink.output_config( benchmark, analyzer_dir) if analyze_functor.get_method()['active']: analyze_functor.active(benchmark, **kwargs) else: L.get_logger().log('Analyzer::analyze_local: Using passive mode') try: exp_dir = self.config.get_analyzer_exp_dir(build, benchmark) isdirectory_good = U.check_provided_directory(analyzer_dir) command = analyze_functor.passive(benchmark, **kwargs) L.get_logger().log('Analyzer::analyze_local: Command = ' + command) benchmark_name = self.config.get_benchmark_name(benchmark) if isdirectory_good: U.change_cwd(analyzer_dir) L.get_logger().log('Analyzer::analyzer_local: Flavor = ' + flavor + ' | benchmark_name = ' + benchmark_name) instr_files = U.build_instr_file_path( analyzer_dir, flavor, benchmark_name) L.get_logger().log( 'Analyzer::analyzer_local: instrumentation file = ' + instr_files) prev_instr_file = U.build_previous_instr_file_path( analyzer_dir, flavor, benchmark_name) tracker = T.TimeTracker() # TODO: Alternate between expansion and pure filtering. if iterationNumber > 0 and U.is_file(instr_files): L.get_logger().log( 'Analyzer::analyze_local: instr_file available') U.rename(instr_files, prev_instr_file) tracker.m_track('Analysis', U, 'run_analyzer_command', command, analyzer_dir, flavor, benchmark_name, exp_dir, iterationNumber, pgis_cfg_file) L.get_logger().log( 'Analyzer::analyze_local: command finished', level='debug') else: tracker.m_track('Initial analysis', U, 'run_analyzer_command_noInstr', command, analyzer_dir, flavor, benchmark_name) self.tear_down(build, exp_dir) return instr_files except Exception as e: L.get_logger().log(str(e), level='error') raise Exception('Problem in Analyzer')