def generate_reports(reports, experiments=None): if not reports: print("No reports found. Sorry.") for rcls in reports: if experiments: for exp in experiments: report = rcls(exp, self._experiment_ids, self._outfile, schema.Session()) else: report = rcls(None, self._experiment_ids, self._outfile, schema.Session()) report.generate()
def create_run(cmd, project, exp, grp): """ Create a new 'run' in the database. This creates a new transaction in the database and creates a new run in this transaction. Afterwards we return both the transaction as well as the run itself. The user is responsible for committing it when the time comes. Args: cmd: The command that has been executed. prj: The project this run belongs to. exp: The experiment this run belongs to. grp: The run_group (uuid) we blong to. Returns: The inserted tuple representing the run and the session opened with the new run. Don't forget to commit it at some point. """ from benchbuild.utils import schema as s session = s.Session() run = s.Run(command=str(cmd), project_name=project.name, experiment_name=exp, run_group=str(grp), experiment_group=str(CFG["experiment_id"])) session.add(run) session.flush() return (run, session)
def create_run_group(prj): """ Create a new 'run_group' in the database. This creates a new transaction in the database and creates a new run_group within this transaction. Afterwards we return both the transaction as well as the run_group itself. The user is responsible for committing it when the time comes. Args: prj - The project for which we open the run_group. Returns: A tuple (group, session) containing both the newly created run_group and the transaction object. """ from benchbuild.utils import schema session = schema.Session() group = schema.RunGroup(id=prj.run_uuid, project=prj.name, experiment=str(CFG["experiment_id"])) session.add(group) session.flush() return (group, session)
def __call__(self, cc, *args, project=None, **kwargs): if project: self.project = project original_command = cc[args] clang = cc["-Qunused-arguments"] clang = clang[args] clang = clang[project.cflags] clang = clang[project.ldflags] clang = clang["-mllvm", "-stats"] run_config = self.config session = schema.Session() with u_run.track_execution(clang, self.project, self.experiment) as _run: run_info = _run() if run_config is not None: db.persist_config(run_info.db_run, session, run_config) if not run_info.has_failed: stats = [] cls = ExtractCompileStats for stat in cls.get_compilestats(run_info.stderr): compile_s = CompileStat() compile_s.name = stat["desc"].rstrip() compile_s.component = stat["component"].rstrip() compile_s.value = stat["value"] stats.append(compile_s) components = settings.CFG["cs"]["components"].value names = settings.CFG["cs"]["names"].value stats = [s for s in stats if str(s.component) in components] \ if components is not None else stats stats = [s for s in stats if str(s.name) in names] \ if names is not None else stats if stats: for stat in stats: LOG.info(" [%s] %s = %s", stat.component, stat.name, stat.value) db.persist_compilestats(run_info.db_run, run_info.session, stats) else: LOG.info("No compilestats left, after filtering.") LOG.warning(" Components: %s", components) LOG.warning(" Names: %s", names) else: with u_run.track_execution(original_command, self.project, self.experiment, **kwargs) as _run: LOG.warning("Fallback to: %s", str(original_command)) run_info = _run() ret = self.call_next(cc, *args, **kwargs) ret.append(run_info) session.commit() return ret
def render_experiment(experiment): template = get_template() sess = schema.Session() return template.render(name=experiment.name, description=experiment.description, start_date=experiment.begin, end_date=experiment.end, id=experiment.id, num_completed_runs=get_completed_runs( sess, experiment), num_failed_runs=get_failed_runs(sess, experiment))
def __init__(self, exp_name, exp_ids, out_path): import benchbuild.utils.schema as schema import uuid self.out_path = out_path self.session = schema.Session() if not exp_ids: exp_ids = load_experiment_ids_from_names( self.session, [exp for exp in self.SUPPORTED_EXPERIMENTS if exp == exp_name]) exp_ids = [v[0] for v in exp_ids] else: exp_ids = [uuid.UUID(v) for v in exp_ids] self.experiment_ids = exp_ids
def refresh_root_window(root): session = schema.Session() all_db_exps = experiments_from_db(session) menu_top = SubMenu('Experiments in database', [ SubMenu("{name} - {desc}".format( name=elem.name, desc=elem.description), [ urwid.Text(render_experiment(elem)), urwid.Divider(), Choice("Delete", top=root, payload=elem) ], top=root) for elem in all_db_exps ], top=root) return menu_top.menu
def handle_timing(run_infos): """Takes care of the formating for the timing statistics.""" from benchbuild.utils import schema as s session = s.Session() for run_info in run_infos: if may_wrap: timings = fetch_time_output(time_tag, time_tag + "{:g}-{:g}-{:g}", run_info.stderr.split("\n")) if timings: persist_time(run_info.db_run, session, timings) else: LOG.warning("No timing information found.") session.commit() return run_infos
def handle_timing(run_infos): """Takes care of the formating for the timing statistics.""" session = schema.Session() for run_info in run_infos: LOG.debug("Persisting time for '%s'", run_info) if may_wrap: timings = time.fetch_time_output( time_tag, time_tag + "{:g}-{:g}-{:g}-{:g}", run_info.stderr.split("\n")) if timings: mse_persist_time_and_memory(run_info.db_run, session, timings) else: LOG.warning("No timing information found.") session.commit() return run_infos
def item_chosen(self, _): session = schema.Session() session.delete(self.payload) def confirm(_): session.commit() self.top.clear() self.top.open_box(refresh_root_window(self.top)) def cancel(_): session.rollback() self.top.clear() self.top.open_box(refresh_root_window(self.top)) response = urwid.Text([ 'Really delete: {name} {desc}?'.format( name=self.payload.name, desc=self.payload.description), '\n' ]) done = MenuButton('Ok', confirm) cancel = MenuButton('Cancel', cancel) response_box = urwid.Filler(urwid.Pile([response, done, cancel])) self.top.open_box(urwid.AttrMap(response_box, 'options'))
def handle_profileScopDetection(run_infos): """ Takes care of writing the information of profileScopDetection into the database. """ from benchbuild.utils import schema as s import parse instrumentedScopPattern \ = parse.compile("{} [info] Instrumented SCoPs: {:d}") nonInstrumentedScopPattern \ = parse.compile("{} [info] Not instrumented SCoPs: {:d}") invalidReasonPattern \ = parse.compile("{} [info] {} is invalid because of: {}") instrumentedParentPattern \ = parse.compile("{} [info] Instrumented parents: {:d}") nonInstrumentedParentPattern \ = parse.compile("{} [info] Not instrumented parents: {:d}") instrumentedScopCounter = 0 nonInstrumentedScopCounter = 0 invalidReasons = {} instrumentedParentCounter = 0 nonInstrumentedParentCounter = 0 paths = glob.glob( os.path.join(os.path.realpath(os.path.curdir), "profileScops.log")) def handle_data(line): nonlocal instrumentedScopCounter nonlocal nonInstrumentedScopCounter nonlocal invalidReasons nonlocal instrumentedParentCounter nonlocal nonInstrumentedParentCounter data = instrumentedScopPattern.parse(line) if data is not None: instrumentedScopCounter += data[1] return data = nonInstrumentedScopPattern.parse(line) if data is not None: nonInstrumentedScopCounter += data[1] return data = invalidReasonPattern.parse(line) if data is not None: reason = data[2] if reason not in invalidReasons: invalidReasons[reason] = 0 invalidReasons[reason] += 1 return data = instrumentedParentPattern.parse(line) if data is not None: instrumentedParentCounter += data[1] return data = nonInstrumentedParentPattern.parse(line) if data is not None: nonInstrumentedParentCounter += data[1] return for path in paths: with open(path, 'r') as file_hdl: for line in file_hdl: handle_data(line) session = s.Session() for reason in invalidReasons: persist_scopinfos(run_infos[0], reason, invalidReasons[reason]) session.commit() return run_infos
def evaluate(self, run_info: run.RunInfo): payload = run_info.payload run_id = run_info.db_run.id config = payload['config'] merged = self.merge_results(payload) def yield_in_region(regions, merged_metrics): for value in merged_metrics.values(): if value['region'] in regions: yield value['event'] def yield_not_in_region(regions, merged_metrics): for value in merged_metrics.values(): if value['region'] not in regions: yield value['event'] def yield_not_in_region_rw(regions, merged_metrics): for value in merged_metrics.values(): if value['region'] not in regions: yield (value['region'], value['event']) def create_results(session, merged_metrics, name, *regions, subset_fn=yield_in_region, aggr_fn=sum): cfg = config.get('name', None) value = aggr_fn(subset_fn(regions, merged_metrics)) session.add( PJ_Result(config=cfg, name=name, run_id=run_id, value=value)) def create_rw_results(session, merged_metrics, name, *regions, subset_fn=yield_not_in_region_rw): cfg = config.get('name', None) for region, value in subset_fn(regions, merged_metrics): session.add( PJ_Result_Region(config=cfg, name=name, run_id=run_id, value=value, region_name=region)) meta_regions = [ 'START', 'CODEGEN', 'CACHE_HIT', 'VARIANTS', 'BLOCKED', 'REQUESTS' ] session = schema.Session() create_results(session, merged, 't_all', 'START') create_results(session, merged, 't_codegen', 'CODEGEN') create_results(session, merged, 'n_cachehits', 'CACHE_HIT') create_results(session, merged, 'n_variants', 'VARIANTS') create_results(session, merged, 'n_blocked', 'BLOCKED') create_results(session, merged, 'n_requests', 'REQUESTS') create_results(session, merged, 't_scops', *meta_regions, subset_fn=yield_not_in_region) create_rw_results(session, merged, 't_region', *meta_regions, subset_fn=yield_not_in_region_rw) session.commit()