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 _arch_bsp_dir_make(self, arch, bsp):
if not path.exists(self._path(arch, bsp)):
path.mkdir(self._path(arch, bsp))
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)
