def run(self, set_name, covoar_config_file, symbol_file, gcnos_file): covoar_result_dir = path.join(self.base_result_dir, set_name) if (not path.exists(covoar_result_dir)): path.mkdir(covoar_result_dir) if (not path.exists(symbol_file)): log.stderr("Symbol set file: " + symbol_file + " doesn't exists! Covoar can not be run!") log.stderr("Skipping " + set_name) return command = "covoar -v -C" + covoar_config_file + " -S " + symbol_file + " -O " + covoar_result_dir + " " + path.join( self.traces_dir, "*.exe") if (path.exists(gcnos_file)): command = command + " -g " + gcnos_file log.notice("Running covoar for " + set_name, stdout_only=True) log.notice(command, stdout_only=True) executor = execute.execute(verbose=True, output=output_handler) exit_code = executor.shell(command, cwd=os.getcwd()) shutil.copy2(path.join(self.covoar_src_dir, 'table.js'), path.join(covoar_result_dir, 'table.js')) shutil.copy2(path.join(self.covoar_src_dir, 'covoar.css'), path.join(covoar_result_dir, 'covoar.css')) log.notice("Coverage run for " + set_name + " finished ") status = "success" if (exit_code[0] != 0): status = "failure. Error code: " + str(exit_code[0]) log.notice("Coverage run for " + set_name + " finished " + status) log.notice("-----------------------------------------------")
def __init__(self, macros_, executables, prefix, symbol_set=None, trace=False): ''' Constructor ''' self.trace = trace self.macros = macros_ self.build_dir = self.macros['_cwd'] self.explanations_txt = self.macros.expand( self.macros['cov_explanations']) self.test_dir = path.join(self.build_dir, self.macros['bsp'] + '-coverage') if not path.exists(self.test_dir): path.mkdir(self.test_dir) self.rtdir = path.abspath(self.macros['_rtdir']) self.rtscripts = self.macros.expand(self.macros['_rtscripts']) self.coverage_config_path = path.join(self.rtscripts, 'coverage') self.symbol_config_path = path.join(self.coverage_config_path, 'symbol-sets.ini') self.symbol_select_path = path.join( self.coverage_config_path, self.macros['bsp'] + '-symbols.ini') self.executables = executables self.symbol_sets = [] self.no_clean = int(self.macros['_no_clean']) self.report_format = self.macros['cov_report_format'] self.symbol_set = symbol_set self.target = self.macros['target'] self.bsp_name = self.macros['bsp'].split('-')[0] self.prefix = prefix
def run(self, set_name, symbol_file): covoar_result_dir = path.join(self.base_result_dir, set_name) if not path.exists(covoar_result_dir): path.mkdir(covoar_result_dir) if not path.exists(symbol_file): raise error.general('coverage: no symbol set file: %s' % (symbol_file)) exe = self._find_covoar() command = exe + ' -O ' + covoar_result_dir + \ ' -p ' + self.project_name + \ ' ' + self.executables + ' ' command += self.covoar_cmd log.notice() log.notice('Running coverage analysis: %s (%s)' % (set_name, covoar_result_dir)) start_time = datetime.datetime.now() executor = execute.execute(verbose=self.trace, output=self.output_handler) exit_code = executor.shell(command, cwd=os.getcwd()) if exit_code[0] != 0: raise error.general('coverage: covoar failure:: %d' % (exit_code[0])) end_time = datetime.datetime.now() log.notice('Coverage time: %s' % (str(end_time - start_time)))
def run(self, setName, covoarConfigFile, symbolFile): covoarResultDir = path.join(self.baseResultDir, setName) if (not path.exists(covoarResultDir)): path.mkdir(covoarResultDir) if (not path.exists(symbolFile)): log.stderr("Symbol set file: " + symbolFile + " doesn't exists! Covoar can not be run!") log.stderr("Skipping " + setName) return command = "covoar -C" + covoarConfigFile + " -S " + symbolFile + " -O " + covoarResultDir + " " + path.join(self.tracesDir, "*.exe") log.notice("Running covoar for " + setName, stdout_only=True) log.notice(command, stdout_only=True) executor = execute.execute(verbose=True, output=output_handler) exit_code = executor.shell(command, cwd=os.getcwd()) shutil.copy2(path.join(self.covoarSrcDir, 'table.js'), path.join(covoarResultDir, 'table.js')) shutil.copy2(path.join(self.covoarSrcDir, 'covoar.css'), path.join(covoarResultDir, 'covoar.css')) log.notice("Coverage run for " + setName + " finished ") status = "success" if (exit_code[0] != 0): status = "failure. Error code: " + str(exit_code[0]) log.notice("Coverage run for " + setName + " finished " + status) log.notice("-----------------------------------------------")
def create_path(self, where, recreate=True, cleanup=True): if path.exists(where): log.output('remove: %s' % (where)) path.removeall(where) try: log.output('make: %s' % (where)) path.mkdir(where) except: raise error.general('cannot create build path: %s' % (where)) if not path.isreadable(where): raise error.general('build path is not readable: %s' % (where)) if not path.iswritable(where): raise error.general('build path is not writeable: %s' % (where)) if cleanup: self.remove_paths += [where]
def prepare_environment(self): symbol_set_files = [] if (path.exists(self.traces_dir)): path.removeall(self.traces_dir) path.mkdir(self.traces_dir) if self.config_map is None: raise error.general( 'no coverage configuration map specified in %s config file' % {bsp}) self.symbol_config.load(self.symbol_config_path, self.path_to_builddir) for sset in self.symbol_config.symbol_sets: if sset.is_valid(): symbol_set_file = (path.join(self.traces_dir, sset.name + '.symcfg')) sset.write_set_file(symbol_set_file) self.symbol_sets.append(sset.name) else: log.notice( 'Invalid symbol set %s in symbol_sets.cfg. skipping covoar run.' % (sset.name)) log.notice('Coverage environment prepared')
def run(self, set_name, symbol_file): covoar_result_dir = path.join(self.base_result_dir, set_name) if (not path.exists(covoar_result_dir)): path.mkdir(covoar_result_dir) if (not path.exists(symbol_file)): raise error.general( 'symbol set file: coverage/%s.symcfg was not created for covoar, skipping %s' % (symbol_file, set_name)) command = ('covoar -S ' + symbol_file + ' -O ' + covoar_result_dir + ' -f' + self.simulator_format + ' -T' + self.target_arch + ' -E' + self.explanations_txt + ' -c' + self.coverage_extension + ' -e' + self.executable_extension + ' -p' + self.project_name + ' ' + self.executables) log.notice('Running covoar for %s' % (set_name)) executor = execute.execute(verbose=True, output=self.output_handler) exit_code = executor.shell(command, cwd=os.getcwd()) if (exit_code[0] != 0): raise error.general('covoar failure exit code: %d' % (exit_code[0])) log.notice('Coverage run for %s finished successfully.' % (set_name)) log.notice('-----------------------------------------------')
def build_arch_bsp(self, arch, bsp): if not self.config.bsp_present(arch, bsp): raise error.general('BSP not found: %s/%s' % (arch, bsp)) log.output('-' * 70) log.notice('] BSP: %s/%s' % (arch, bsp)) log.notice('. Creating: %s' % (self._path(arch, bsp))) self._arch_bsp_dir_clean(arch, bsp) self._arch_bsp_dir_make(arch, bsp) variations = self._variations(arch, bsp) build_set = self._build_set(variations) bsp_start = datetime.datetime.now() bsp_warnings = warnings_counter(self.rtems) env_path = os.environ['PATH'] os.environ['PATH'] = path.host(path.join(self.tools, 'bin')) + \ os.pathsep + os.environ['PATH'] for bs in sorted(build_set.keys()): warnings = warnings_counter(self.rtems) start = datetime.datetime.now() log.output('- ' * 35) log.notice('. Configuring: %s' % (bs)) try: result = '+ Pass' bpath = self._build_dir(arch, bsp, bs) path.mkdir(bpath) config_cmd = self._config_command(build_set[bs], arch, bsp) cmd = config_cmd e = execute.capture_execution(log = warnings) log.output('run: ' + cmd) if self.options['dry-run']: exit_code = 0 else: exit_code, proc, output = e.shell(cmd, cwd = path.host(bpath)) if exit_code != 0: result = '- FAIL' self.errors['configure'] += 1 log.notice('- Configure failed: %s' % (bs)) log.output('cmd failed: %s' % (cmd)) if self.options['stop-on-error']: raise error.general('Configuring %s failed' % (bs)) else: log.notice('. Building: %s' % (bs)) cmd = 'make' if 'jobs' in self.options: cmd += ' -j %s' % (self.options['jobs']) log.output('run: ' + cmd) if self.options['dry-run']: exit_code = 0 else: exit_code, proc, output = e.shell(cmd, cwd = path.host(bpath)) if exit_code != 0: result = '- FAIL' self.errors['build'] += 1 log.notice('- FAIL: %s: %s' % (bs, self._error_str())) log.output('cmd failed: %s' % (cmd)) if self.options['stop-on-error']: raise error.general('Building %s failed' % (bs)) files = self._count_files(arch, bsp, bs) log.notice('%s: %s: warnings:%d exes:%d objs:%s libs:%d' % \ (result, bs, warnings.get(), files['exes'], files['objs'], files['libs'])) log.notice(' %s' % (self._error_str())) self.results.add(result[0] == '+', arch, bsp, config_cmd, warnings.get()) finally: end = datetime.datetime.now() if not self.options['no-clean']: log.notice('. Cleaning: %s' % (self._build_dir(arch, bsp, bs))) path.removeall(self._build_dir(arch, bsp, bs)) log.notice('^ Time %s' % (str(end - start))) log.output('Warnings Report:') log.output(warnings.report()) warnings.accumulate(bsp_warnings) warnings.accumulate(self.warnings) bsp_end = datetime.datetime.now() log.notice('^ BSP Time %s' % (str(bsp_end - bsp_start))) log.output('BSP Warnings Report:') log.output(bsp_warnings.report()) os.environ['PATH'] = env_path
def _arch_bsp_dir_make(self, arch, bsp): if not path.exists(self._path(arch, bsp)): path.mkdir(self._path(arch, bsp))
def _make_build_dir(self): if not path.exists(self._build_dir()): path.mkdir(self._build_dir())
def build_arch_bsp(self, arch, bsp): if not self.config.bsp_present(arch, bsp): raise error.general('BSP not found: %s/%s' % (arch, bsp)) log.output('-' * 70) log.notice('] BSP: %s/%s' % (arch, bsp)) log.notice('. Creating: %s' % (self._path(arch, bsp))) self._arch_bsp_dir_clean(arch, bsp) self._arch_bsp_dir_make(arch, bsp) variations = self._variations(arch, bsp) build_set = self._build_set(variations) bsp_start = datetime.datetime.now() bsp_warnings = warnings_counter(self.rtems) env_path = os.environ['PATH'] os.environ['PATH'] = path.host(path.join(self.tools, 'bin')) + \ os.pathsep + os.environ['PATH'] for bs in sorted(build_set.keys()): warnings = warnings_counter(self.rtems) start = datetime.datetime.now() log.output('- ' * 35) log.notice('. Configuring: %s' % (bs)) try: result = '+ Pass' bpath = self._build_dir(arch, bsp, bs) path.mkdir(bpath) config_cmd = self._config_command(build_set[bs], arch, bsp) cmd = config_cmd e = execute.capture_execution(log=warnings) log.output('run: ' + cmd) if self.options['dry-run']: exit_code = 0 else: exit_code, proc, output = e.shell(cmd, cwd=path.host(bpath)) if exit_code != 0: result = '- FAIL' self.errors['configure'] += 1 log.notice('- Configure failed: %s' % (bs)) log.output('cmd failed: %s' % (cmd)) if self.options['stop-on-error']: raise error.general('Configuring %s failed' % (bs)) else: log.notice('. Building: %s' % (bs)) cmd = 'make' if 'jobs' in self.options: cmd += ' -j %s' % (self.options['jobs']) log.output('run: ' + cmd) if self.options['dry-run']: exit_code = 0 else: exit_code, proc, output = e.shell(cmd, cwd=path.host(bpath)) if exit_code != 0: result = '- FAIL' self.errors['build'] += 1 log.notice('- FAIL: %s: %s' % (bs, self._error_str())) log.output('cmd failed: %s' % (cmd)) if self.options['stop-on-error']: raise error.general('Building %s failed' % (bs)) files = self._count_files(arch, bsp, bs) log.notice('%s: %s: warnings:%d exes:%d objs:%s libs:%d' % \ (result, bs, warnings.get(), files['exes'], files['objs'], files['libs'])) log.notice(' %s' % (self._error_str())) self.results.add(result[0] == '+', arch, bsp, config_cmd, warnings.get()) finally: end = datetime.datetime.now() if not self.options['no-clean']: log.notice('. Cleaning: %s' % (self._build_dir(arch, bsp, bs))) path.removeall(self._build_dir(arch, bsp, bs)) log.notice('^ Time %s' % (str(end - start))) log.output('Warnings Report:') log.output(warnings.report()) warnings.accumulate(bsp_warnings) warnings.accumulate(self.warnings) bsp_end = datetime.datetime.now() log.notice('^ BSP Time %s' % (str(bsp_end - bsp_start))) log.output('BSP Warnings Report:') log.output(bsp_warnings.report()) os.environ['PATH'] = env_path
def prepare_environment(self): if (path.exists(self.traces_dir)): path.removeall(self.traces_dir) path.mkdir(self.traces_dir) log.notice("Coverage environment prepared", stdout_only=True)
def prepareEnvironment(self): if(path.exists(self.tracesDir)): path.removeall(self.tracesDir) path.mkdir(self.tracesDir) log.notice("Coverage environment prepared", stdout_only = True)