def output_before_run(self, run):
"""
The method output_before_run() prints the name of a file to terminal.
It returns the name of the logfile.
@param run: a Run object
"""
# output in terminal
runSet = run.runSet
try:
OutputHandler.print_lock.acquire()
try:
runSet.started_runs += 1
except AttributeError:
runSet.started_runs = 1
timeStr = time.strftime("%H:%M:%S", time.localtime()) + " "
progressIndicator = " ({0}/{1})".format(runSet.started_runs, len(runSet.runs))
terminalTitle = TERMINAL_TITLE.format(runSet.full_name + progressIndicator) if USE_COLORS and sys.stdout.isatty() else ""
if self.benchmark.num_of_threads == 1:
util.printOut(terminalTitle + timeStr + self.format_sourcefile_name(run.identifier, runSet), '')
else:
util.printOut(terminalTitle + timeStr + "starting " + self.format_sourcefile_name(run.identifier, runSet))
finally:
OutputHandler.print_lock.release()
def output_after_benchmark(self, isStoppedByInterrupt):
self.statistics.print_to_terminal()
if self.xml_file_names:
def _find_file_relative(name):
"""
Find a file with the given name in the same directory as this script.
Returns a path relative to the current directory, or None.
"""
path = os.path.join(os.path.dirname(sys.argv[0]), name)
if not os.path.isfile(path):
path = os.path.join(os.path.dirname(__file__), os.path.pardir, name)
if not os.path.isfile(path):
return None
if os.path.dirname(path) in os.environ['PATH'].split(os.pathsep):
# in PATH, just use command name
return os.path.basename(path)
path = os.path.relpath(path)
if path == name:
path = './' + path # for easier copy and paste into a shell
return path
tableGeneratorPath = _find_file_relative('table-generator.py') \
or _find_file_relative('table-generator')
if tableGeneratorPath:
xml_file_names = [file+".bz2" for file in self.xml_file_names] if self.compress_results else self.xml_file_names
util.printOut("In order to get HTML and CSV tables, run\n{0} '{1}'"
.format(tableGeneratorPath, "' '".join(xml_file_names)))
if isStoppedByInterrupt:
util.printOut("\nScript was interrupted by user, some runs may not be done.\n")
def output_before_run(self, run):
"""
The method output_before_run() prints the name of a file to terminal.
It returns the name of the logfile.
@param run: a Run object
"""
# output in terminal
runSet = run.runSet
try:
OutputHandler.print_lock.acquire()
try:
runSet.started_runs += 1
except AttributeError:
runSet.started_runs = 1
timeStr = time.strftime("%H:%M:%S", time.localtime()) + " "
progressIndicator = f" ({runSet.started_runs}/{len(runSet.runs)})"
terminalTitle = TERMINAL_TITLE.format(runSet.full_name +
progressIndicator)
if self.benchmark.num_of_threads == 1:
util.printOut(
terminalTitle + timeStr +
self.format_sourcefile_name(run.identifier, runSet),
"",
)
else:
util.printOut(
terminalTitle + timeStr + "starting " +
self.format_sourcefile_name(run.identifier, runSet))
finally:
OutputHandler.print_lock.release()
def print_to_terminal(self):
correct = self.dic[result.CATEGORY_CORRECT]
correct_true = self.dic[(result.CATEGORY_CORRECT,
result.RESULT_CLASS_TRUE)]
correct_false = correct - correct_true
incorrect = self.dic[result.CATEGORY_WRONG]
incorrect_true = self.dic[(result.CATEGORY_WRONG,
result.RESULT_CLASS_TRUE)]
incorrect_false = incorrect - incorrect_true
width = 6
output = [
'',
'Statistics:' + str(self.counter).rjust(width + 9) + ' Files',
' correct: ' + str(correct).rjust(width),
' correct true: ' + str(correct_true).rjust(width),
' correct false: ' + str(correct_false).rjust(width),
' incorrect: ' + str(incorrect).rjust(width),
' incorrect true: ' + str(incorrect_true).rjust(width),
' incorrect false:' + str(incorrect_false).rjust(width),
' unknown: ' +
str(self.dic[result.CATEGORY_UNKNOWN] +
self.dic[result.CATEGORY_ERROR]).rjust(width),
]
if self.max_score:
output.append(' Score: ' +
str(self.score).rjust(width) + ' (max: ' +
str(self.max_score) + ')')
util.printOut('\n'.join(output) + '\n')
def output_before_run(self, run):
"""
The method output_before_run() prints the name of a file to terminal.
It returns the name of the logfile.
@param run: a Run object
"""
# output in terminal
runSet = run.runSet
try:
OutputHandler.print_lock.acquire()
try:
runSet.started_runs += 1
except AttributeError:
runSet.started_runs = 1
timeStr = time.strftime("%H:%M:%S", time.localtime()) + " "
progressIndicator = " ({0}/{1})".format(runSet.started_runs,
len(runSet.runs))
terminalTitle = TERMINAL_TITLE.format(
runSet.full_name + progressIndicator
) if USE_COLORS and sys.stdout.isatty() else ""
if self.benchmark.num_of_threads == 1:
util.printOut(
terminalTitle + timeStr +
self.format_sourcefile_name(run.identifier, runSet), '')
else:
util.printOut(
terminalTitle + timeStr + "starting " +
self.format_sourcefile_name(run.identifier, runSet))
finally:
OutputHandler.print_lock.release()
# get name of file-specific log-file
self.all_created_files.append(run.log_file)
def output_after_run(self, run):
"""
The method output_after_run() prints filename, result, time and status
of a run to terminal and stores all data in XML
"""
# format times, type is changed from float to string!
cputime_str = util.format_number(run.cputime, TIME_PRECISION)
walltime_str = util.format_number(run.walltime, TIME_PRECISION)
# format numbers, number_of_digits is optional, so it can be None
for column in run.columns:
if column.number_of_digits is not None:
# if the number ends with "s" or another letter, remove it
if (not column.value.isdigit()) and column.value[-2:-1].isdigit():
column.value = column.value[:-1]
try:
floatValue = float(column.value)
column.value = util.format_number(floatValue, column.number_of_digits)
except ValueError: # if value is no float, don't format it
pass
# store information in run
run.resultline = self.create_output_line(run.runSet, run.identifier, run.status,
cputime_str, walltime_str, run.values.get('host'),
run.columns)
self.add_values_to_run_xml(run)
# output in terminal/console
if USE_COLORS and sys.stdout.isatty(): # is terminal, not file
statusStr = COLOR_DIC[run.category].format(run.status.ljust(LEN_OF_STATUS))
else:
statusStr = run.status.ljust(LEN_OF_STATUS)
try:
OutputHandler.print_lock.acquire()
valueStr = statusStr + cputime_str.rjust(8) + walltime_str.rjust(8)
if self.benchmark.num_of_threads == 1:
util.printOut(valueStr)
else:
timeStr = time.strftime("%H:%M:%S", time.localtime()) + " "*14
util.printOut(timeStr + self.format_sourcefile_name(run.identifier, run.runSet) + valueStr)
# write result in txt_file and XML
self.txt_file.append(self.run_set_to_text(run.runSet), False)
self.statistics.add_result(run)
# we don't want to write this file to often, it can slow down the whole script,
# so we wait at least 10 seconds between two write-actions
currentTime = util.read_monotonic_time()
if currentTime - run.runSet.xml_file.lastModifiedTime > 60:
run.runSet.xml_file.replace(self._result_xml_to_string(run.runSet.xml))
run.runSet.xml_file.lastModifiedTime = util.read_monotonic_time()
finally:
OutputHandler.print_lock.release()
def stop():
global STOPPED_BY_INTERRUPT
STOPPED_BY_INTERRUPT = True
# kill running jobs
util.printOut("killing subprocesses...")
for worker in WORKER_THREADS:
worker.stop()
def output_before_run_set(self, runSet):
"""
The method output_before_run_set() calculates the length of the
first column for the output in terminal and stores information
about the runSet in XML.
@param runSet: current run set
"""
sourcefiles = [run.identifier for run in runSet.runs]
# common prefix of file names
runSet.common_prefix = util.common_base_dir(sourcefiles) + os.path.sep
# length of the first column in terminal
runSet.max_length_of_filename = max(
len(file) for file in sourcefiles) if sourcefiles else 20
runSet.max_length_of_filename = max(
20, runSet.max_length_of_filename - len(runSet.common_prefix))
# write run set name to terminal
numberOfFiles = len(runSet.runs)
numberOfFilesStr = (" (1 file)" if numberOfFiles == 1 else
" ({0} files)".format(numberOfFiles))
util.printOut("\nexecuting run set" +
(" '" + runSet.name + "'" if runSet.name else "") +
numberOfFilesStr +
(TERMINAL_TITLE.format(runSet.full_name)
if USE_COLORS and sys.stdout.isatty() else ""))
# write information about the run set into txt_file
self.writeRunSetInfoToLog(runSet)
# prepare information for text output
for run in runSet.runs:
run.resultline = self.format_sourcefile_name(
run.identifier, runSet)
# prepare XML structure for each run and runSet
run.xml = ET.Element(
"run", {
"name": run.identifier,
"files": "[" + ", ".join(run.sourcefiles) + "]"
})
if run.specific_options:
run.xml.set("options", " ".join(run.specific_options))
if run.properties:
run.xml.set("properties", " ".join(sorted(run.properties)))
run.xml.extend(self.xml_dummy_elements)
runSet.xml = self.runs_to_xml(runSet, runSet.runs)
# write (empty) results to txt_file and XML
self.txt_file.append(self.run_set_to_text(runSet), False)
xml_file_name = self.get_filename(runSet.name, "xml")
runSet.xml_file = filewriter.FileWriter(
xml_file_name, self._result_xml_to_string(runSet.xml))
runSet.xml_file.lastModifiedTime = util.read_monotonic_time()
self.all_created_files.append(xml_file_name)
self.xml_file_names.append(xml_file_name)
def stop():
global STOPPED_BY_INTERRUPT
STOPPED_BY_INTERRUPT = True
util.printOut("Killing subprocesses. May take some seconds...")
if not APPENGINE_POLLER_THREAD == None:
APPENGINE_POLLER_THREAD.join()
if not APPENGINE_SUBMITTER_THREAD == None:
APPENGINE_SUBMITTER_THREAD.join()
def stop():
global STOPPED_BY_INTERRUPT
STOPPED_BY_INTERRUPT = True
util.printOut("Killing subprocesses. May take some seconds...")
if not APPENGINE_POLLER_THREAD == None:
APPENGINE_POLLER_THREAD.join()
if not APPENGINE_SUBMITTER_THREAD == None:
APPENGINE_SUBMITTER_THREAD.join()
def stop():
global STOPPED_BY_INTERRUPT
STOPPED_BY_INTERRUPT = True
# kill running jobs
util.printOut("killing subprocesses...")
for worker in WORKER_THREADS:
worker.stop()
# wait until all threads are stopped
for worker in WORKER_THREADS:
worker.join()
def output_before_run_set(self, runSet):
"""
The method output_before_run_set() calculates the length of the
first column for the output in terminal and stores information
about the runSet in XML.
@param runSet: current run set
"""
sourcefiles = [run.identifier for run in runSet.runs]
# common prefix of file names
runSet.common_prefix = util.common_base_dir(sourcefiles) + os.path.sep
# length of the first column in terminal
runSet.max_length_of_filename = max(len(file) for file in sourcefiles) if sourcefiles else 20
runSet.max_length_of_filename = max(20, runSet.max_length_of_filename - len(runSet.common_prefix))
# write run set name to terminal
numberOfFiles = len(runSet.runs)
numberOfFilesStr = (" (1 file)" if numberOfFiles == 1
else " ({0} files)".format(numberOfFiles))
util.printOut("\nexecuting run set"
+ (" '" + runSet.name + "'" if runSet.name else "")
+ numberOfFilesStr
+ (TERMINAL_TITLE.format(runSet.full_name) if USE_COLORS and sys.stdout.isatty() else ""))
# write information about the run set into txt_file
self.writeRunSetInfoToLog(runSet)
# prepare information for text output
for run in runSet.runs:
run.resultline = self.format_sourcefile_name(run.identifier, runSet)
# prepare XML structure for each run and runSet
run.xml = ET.Element("run",
{"name": run.identifier, "files": "[" + ", ".join(run.sourcefiles) + "]"})
if run.specific_options:
run.xml.set("options", " ".join(run.specific_options))
if run.properties:
run.xml.set("properties", " ".join(sorted(run.properties)))
run.xml.extend(self.xml_dummy_elements)
runSet.xml = self.runs_to_xml(runSet, runSet.runs)
# write (empty) results to txt_file and XML
self.txt_file.append(self.run_set_to_text(runSet), False)
xml_file_name = self.get_filename(runSet.name, "xml")
runSet.xml_file = filewriter.FileWriter(xml_file_name,
self._result_xml_to_string(runSet.xml))
runSet.xml_file.lastModifiedTime = util.read_monotonic_time()
self.all_created_files.append(xml_file_name)
self.xml_file_names.append(xml_file_name)
def output_for_skipping_run_set(self, runSet, reason=None):
'''
This function writes a simple message to terminal and logfile,
when a run set is skipped.
There is no message about skipping a run set in the xml-file.
'''
# print to terminal
util.printOut("\nSkipping run set" +
(" '" + runSet.name + "'" if runSet.name else "") +
(" " + reason if reason else ""))
# write into txt_file
runSetInfo = "\n\n"
if runSet.name:
runSetInfo += runSet.name + "\n"
runSetInfo += "Run set {0} of {1}: skipped {2}\n".format(
runSet.index, len(self.benchmark.run_sets), reason or "")
self.txt_file.append(runSetInfo)
def main(benchexec=None, argv=None):
"""
The main method of BenchExec for use in a command-line script.
In addition to calling benchexec.start(argv),
it also handles signals and keyboard interrupts.
It does not return but calls sys.exit().
@param benchexec: An instance of BenchExec for executing benchmarks.
@param argv: optionally the list of command-line options to use
"""
if sys.version_info < (3,):
sys.exit('benchexec needs Python 3 to run.')
# ignore SIGTERM
signal.signal(signal.SIGTERM, signal_handler_ignore)
try:
if not benchexec:
benchexec = BenchExec()
sys.exit(benchexec.start(argv or sys.argv))
except KeyboardInterrupt: # this block is reached, when interrupt is thrown before or after a run set execution
benchexec.stop()
util.printOut("\n\nScript was interrupted by user, some runs may not be done.")
def output_for_skipping_run_set(self, runSet, reason=None):
'''
This function writes a simple message to terminal and logfile,
when a run set is skipped.
There is no message about skipping a run set in the xml-file.
'''
# print to terminal
util.printOut("\nSkipping run set" +
(" '" + runSet.name + "'" if runSet.name else "") +
(" " + reason if reason else "")
)
# write into txt_file
runSetInfo = "\n\n"
if runSet.name:
runSetInfo += runSet.name + "\n"
runSetInfo += "Run set {0} of {1}: skipped {2}\n".format(
runSet.index, len(self.benchmark.run_sets), reason or "")
self.txt_file.append(runSetInfo)
def main(benchexec=None, argv=None):
"""
The main method of BenchExec for use in a command-line script.
In addition to calling benchexec.start(argv),
it also handles signals and keyboard interrupts.
It does not return but calls sys.exit().
@param benchexec: An instance of BenchExec for executing benchmarks.
@param argv: optionally the list of command-line options to use
"""
if sys.version_info < (3,):
sys.exit('benchexec needs Python 3 to run.')
# ignore SIGTERM
signal.signal(signal.SIGTERM, signal_handler_ignore)
try:
if not benchexec:
benchexec = BenchExec()
sys.exit(benchexec.start(argv or sys.argv))
except KeyboardInterrupt: # this block is reached, when interrupt is thrown before or after a run set execution
benchexec.stop()
util.printOut("\n\nScript was interrupted by user, some runs may not be done.")
def output_after_benchmark(self, isStoppedByInterrupt):
self.statistics.print_to_terminal()
if self.xml_file_names:
def _find_file_relative(name):
"""
Find a file with the given name in the same directory as this script.
Returns a path relative to the current directory, or None.
"""
path = os.path.join(os.path.dirname(sys.argv[0]), name)
if not os.path.isfile(path):
path = os.path.join(os.path.dirname(__file__),
os.path.pardir, name)
if not os.path.isfile(path):
return None
if os.path.dirname(path) in os.environ['PATH'].split(
os.pathsep):
# in PATH, just use command name
return os.path.basename(path)
path = os.path.relpath(path)
if path == name:
path = './' + path # for easier copy and paste into a shell
return path
tableGeneratorPath = _find_file_relative('table-generator.py') \
or _find_file_relative('table-generator')
if tableGeneratorPath:
xml_file_names = [
file + ".bz2" for file in self.xml_file_names
] if self.compress_results else self.xml_file_names
util.printOut(
"In order to get HTML and CSV tables, run\n{0} '{1}'".
format(tableGeneratorPath, "' '".join(xml_file_names)))
if isStoppedByInterrupt:
util.printOut(
"\nScript was interrupted by user, some runs may not be done.\n"
)
def output_for_skipping_run_set(self, runSet, reason=None):
"""
This function writes a simple message to terminal and logfile,
when a run set is skipped.
There is no message about skipping a run set in the xml-file.
"""
# print to terminal
util.printOut("\nSkipping run set" +
(" '" + runSet.name + "'" if runSet.name else "") +
(" " + reason if reason else ""))
# write into txt_file
runSetInfo = "\n\n"
if runSet.name:
runSetInfo += runSet.name + "\n"
runSetInfo += (
f"Run set {runSet.index} of {len(self.benchmark.run_sets)}: "
f"skipped {reason or ''}".rstrip())
runSetInfo += "\n"
self.txt_file.append(runSetInfo)
def print_to_terminal(self):
correct = self.dic[result.CATEGORY_CORRECT]
correct_true = self.dic[(result.CATEGORY_CORRECT, result.RESULT_CLASS_TRUE)]
correct_false = correct - correct_true
incorrect = self.dic[result.CATEGORY_WRONG]
incorrect_true = self.dic[(result.CATEGORY_WRONG, result.RESULT_CLASS_TRUE)]
incorrect_false = incorrect - incorrect_true
width = 6
output = ['',
'Statistics:' + str(self.counter).rjust(width + 9) + ' Files',
' correct: ' + str(correct).rjust(width),
' correct true: ' + str(correct_true).rjust(width),
' correct false: ' + str(correct_false).rjust(width),
' incorrect: ' + str(incorrect).rjust(width),
' incorrect true: ' + str(incorrect_true).rjust(width),
' incorrect false:' + str(incorrect_false).rjust(width),
' unknown: ' + str(self.dic[result.CATEGORY_UNKNOWN] + self.dic[result.CATEGORY_ERROR]).rjust(width),
]
if self.max_score:
output.append(
' Score: ' + str(self.score).rjust(width) + ' (max: ' + str(self.max_score) + ')'
)
util.printOut('\n'.join(output)+'\n')
def output_after_benchmark(self, isStoppedByInterrupt):
stats = str(self.statistics)
util.printOut(stats)
self.txt_file.append(stats)
if self.xml_file_names:
def _find_file_relative(name):
"""
Find a file with the given name in the same directory as this script.
Returns a path relative to the current directory, or None.
"""
main_dir = os.path.dirname(sys.argv[0])
search_dirs = [
main_dir,
os.path.join(main_dir, os.path.pardir, "bin"),
os.path.join(os.path.dirname(__file__), os.path.pardir),
]
path = util.find_executable2(name, search_dirs)
if not path:
return None
if os.path.dirname(path) in util.get_path():
# in PATH, just use command name
return os.path.basename(path)
path = os.path.relpath(path)
if path == name:
path = "./" + path # for easier copy and paste into a shell
return path
tableGeneratorPath = _find_file_relative(
"table-generator.py") or _find_file_relative("table-generator")
if tableGeneratorPath:
xml_file_names = ([
file + ".bz2" for file in self.xml_file_names
] if self.compress_results else self.xml_file_names)
cmdline = [tableGeneratorPath] + xml_file_names
util.printOut(
"In order to get HTML and CSV tables, run\n" +
" ".join(map(util.escape_string_shell, cmdline)), )
if isStoppedByInterrupt:
util.printOut(
"\nScript was interrupted by user, some runs may not be done.\n"
)
def output_after_run(self, run):
"""
The method output_after_run() prints filename, result, time and status
of a run to terminal and stores all data in XML
"""
# format times, type is changed from float to string!
cputime_str = util.format_number(run.values.get("cputime"),
TIME_PRECISION)
walltime_str = util.format_number(run.values.get("walltime"),
TIME_PRECISION)
# format numbers, number_of_digits is optional, so it can be None
for column in run.columns:
if column.number_of_digits is not None:
# if the number ends with "s" or another letter, remove it
if (not column.value.isdigit()
) and column.value[-2:-1].isdigit():
column.value = column.value[:-1]
try:
floatValue = float(column.value)
column.value = util.format_number(floatValue,
column.number_of_digits)
except ValueError: # if value is no float, don't format it
pass
# store information in run
run.resultline = self.create_output_line(
run.runSet,
run.identifier,
run.status,
cputime_str,
walltime_str,
run.values.get("host"),
run.columns,
)
self.add_values_to_run_xml(run)
# output in terminal/console
statusStr = COLOR_DIC[run.category].format(
run.status.ljust(LEN_OF_STATUS))
try:
OutputHandler.print_lock.acquire()
valueStr = statusStr + cputime_str.rjust(8) + walltime_str.rjust(8)
if self.benchmark.num_of_threads == 1:
util.printOut(valueStr)
else:
timeStr = time.strftime("%H:%M:%S",
time.localtime()) + " " * 14
util.printOut(
timeStr +
self.format_sourcefile_name(run.identifier, run.runSet) +
valueStr)
# write result in txt_file and XML
self.txt_file.append(run.resultline + "\n", keep=False)
self.statistics.add_result(run)
# we don't want to write this file to often, it can slow down the whole script,
# so we wait at least 10 seconds between two write-actions
currentTime = time.monotonic()
if currentTime - run.runSet.xml_file_last_modified_time > 60:
self._write_rough_result_xml_to_file(run.runSet.xml,
run.runSet.xml_file_name)
run.runSet.xml_file_last_modified_time = time.monotonic()
finally:
OutputHandler.print_lock.release()
if self.compress_results:
log_file_path = os.path.relpath(
run.log_file, os.path.join(self.benchmark.log_folder,
os.pardir))
with self.log_zip_lock:
self.log_zip.write(run.log_file, log_file_path)
os.remove(run.log_file)
else:
self.all_created_files.add(run.log_file)
if os.path.isdir(run.result_files_folder):
self.all_created_files.add(run.result_files_folder)
def output_after_run(self, run):
"""
The method output_after_run() prints filename, result, time and status
of a run to terminal and stores all data in XML
"""
# format times, type is changed from float to string!
cputime_str = util.format_number(run.cputime, TIME_PRECISION)
walltime_str = util.format_number(run.walltime, TIME_PRECISION)
# format numbers, number_of_digits is optional, so it can be None
for column in run.columns:
if column.number_of_digits is not None:
# if the number ends with "s" or another letter, remove it
if (not column.value.isdigit()
) and column.value[-2:-1].isdigit():
column.value = column.value[:-1]
try:
floatValue = float(column.value)
column.value = util.format_number(floatValue,
column.number_of_digits)
except ValueError: # if value is no float, don't format it
pass
# store information in run
run.resultline = self.create_output_line(run.runSet, run.identifier,
run.status, cputime_str,
walltime_str,
run.values.get('host'),
run.columns)
self.add_values_to_run_xml(run)
# output in terminal/console
if USE_COLORS and sys.stdout.isatty(): # is terminal, not file
statusStr = COLOR_DIC[run.category].format(
run.status.ljust(LEN_OF_STATUS))
else:
statusStr = run.status.ljust(LEN_OF_STATUS)
try:
OutputHandler.print_lock.acquire()
valueStr = statusStr + cputime_str.rjust(8) + walltime_str.rjust(8)
if self.benchmark.num_of_threads == 1:
util.printOut(valueStr)
else:
timeStr = time.strftime("%H:%M:%S",
time.localtime()) + " " * 14
util.printOut(
timeStr +
self.format_sourcefile_name(run.identifier, run.runSet) +
valueStr)
# write result in txt_file and XML
self.txt_file.append(self.run_set_to_text(run.runSet), False)
self.statistics.add_result(run)
# we don't want to write this file to often, it can slow down the whole script,
# so we wait at least 10 seconds between two write-actions
currentTime = util.read_monotonic_time()
if currentTime - run.runSet.xml_file.lastModifiedTime > 60:
run.runSet.xml_file.replace(
self._result_xml_to_string(run.runSet.xml))
run.runSet.xml_file.lastModifiedTime = util.read_monotonic_time(
)
finally:
OutputHandler.print_lock.release()
def output_before_run_set(self, runSet, start_time=None):
"""
The method output_before_run_set() calculates the length of the
first column for the output in terminal and stores information
about the runSet in XML.
@param runSet: current run set
"""
xml_file_name = self.get_filename(runSet.name, "xml")
identifier_names = [run.identifier for run in runSet.runs]
# common prefix of file names
runSet.common_prefix = util.common_base_dir(identifier_names)
if runSet.common_prefix:
runSet.common_prefix += os.path.sep
# length of the first column in terminal
runSet.max_length_of_filename = (max(
len(file)
for file in identifier_names) if identifier_names else 20)
runSet.max_length_of_filename = max(
20, runSet.max_length_of_filename - len(runSet.common_prefix))
# write run set name to terminal
numberOfFiles = len(runSet.runs)
numberOfFilesStr = (" (1 file)" if numberOfFiles == 1 else
f" ({numberOfFiles} files)")
util.printOut("\nexecuting run set" +
(" '" + runSet.name + "'" if runSet.name else "") +
numberOfFilesStr +
TERMINAL_TITLE.format(runSet.full_name))
# write information about the run set into txt_file
self.writeRunSetInfoToLog(runSet)
# prepare information for text output
for run in runSet.runs:
run.resultline = self.format_sourcefile_name(
run.identifier, runSet)
if run.sourcefiles:
adjusted_identifier = util.relative_path(
run.identifier, xml_file_name)
else:
# If no source files exist the task doesn't point to any file that could be downloaded.
# In this case, the name doesn't have to be adjusted because it's no path.
adjusted_identifier = run.identifier
# prepare XML structure for each run and runSet
run.xml = ElementTree.Element("run", name=adjusted_identifier)
if run.sourcefiles:
adjusted_sourcefiles = (util.relative_path(s, xml_file_name)
for s in run.sourcefiles)
run.xml.set("files",
"[" + ", ".join(adjusted_sourcefiles) + "]")
if run.specific_options:
run.xml.set("options", " ".join(run.specific_options))
if run.properties:
all_properties = (prop.name for prop in run.properties)
run.xml.set("properties", " ".join(sorted(all_properties)))
if len(run.properties) == 1:
prop = run.properties[0]
run.xml.set("propertyFile",
util.relative_path(prop.filename, xml_file_name))
expected_result = str(
run.expected_results.get(prop.filename, ""))
if expected_result:
run.xml.set("expectedVerdict", expected_result)
block_name = runSet.blocks[0].name if len(runSet.blocks) == 1 else None
runSet.xml = self.runs_to_xml(runSet, runSet.runs, block_name)
if start_time:
runSet.xml.set("starttime", start_time.isoformat())
elif not self.benchmark.config.start_time:
runSet.xml.set("starttime", util.read_local_time().isoformat())
# write (empty) results to XML
runSet.xml_file_name = xml_file_name
self._write_rough_result_xml_to_file(runSet.xml, runSet.xml_file_name)
runSet.xml_file_last_modified_time = time.monotonic()
self.all_created_files.add(runSet.xml_file_name)
self.xml_file_names.append(runSet.xml_file_name)
def output_before_run_set(self, runSet):
"""
The method output_before_run_set() calculates the length of the
first column for the output in terminal and stores information
about the runSet in XML.
@param runSet: current run set
"""
xml_file_name = self.get_filename(runSet.name, "xml")
identifier_names = [run.identifier for run in runSet.runs]
# common prefix of file names
runSet.common_prefix = util.common_base_dir(identifier_names)
if runSet.common_prefix:
runSet.common_prefix += os.path.sep
# length of the first column in terminal
runSet.max_length_of_filename = max(len(file) for file in identifier_names) if identifier_names else 20
runSet.max_length_of_filename = max(20, runSet.max_length_of_filename - len(runSet.common_prefix))
# write run set name to terminal
numberOfFiles = len(runSet.runs)
numberOfFilesStr = (" (1 file)" if numberOfFiles == 1
else " ({0} files)".format(numberOfFiles))
util.printOut("\nexecuting run set"
+ (" '" + runSet.name + "'" if runSet.name else "")
+ numberOfFilesStr
+ TERMINAL_TITLE.format(runSet.full_name))
# write information about the run set into txt_file
self.writeRunSetInfoToLog(runSet)
# prepare information for text output
for run in runSet.runs:
run.resultline = self.format_sourcefile_name(run.identifier, runSet)
if run.sourcefiles:
adjusted_identifier = util.relative_path(run.identifier, xml_file_name)
else:
# If no source files exist the task doesn't point to any file that could be downloaded.
# In this case, the name doesn't have to be adjusted because it's no path.
adjusted_identifier = run.identifier
# prepare XML structure for each run and runSet
run_attributes = {'name': adjusted_identifier}
if run.sourcefiles:
adjusted_sourcefiles = [util.relative_path(s, xml_file_name) for s in run.sourcefiles]
run_attributes['files'] = '[' + ', '.join(adjusted_sourcefiles) + ']'
run.xml = ET.Element("run", run_attributes)
if run.specific_options:
run.xml.set("options", " ".join(run.specific_options))
if run.properties:
all_properties = [prop_name for prop in run.properties for prop_name in prop.names]
run.xml.set("properties", " ".join(sorted(all_properties)))
run.xml.extend(self.xml_dummy_elements)
block_name = runSet.blocks[0].name if len(runSet.blocks) == 1 else None
runSet.xml = self.runs_to_xml(runSet, runSet.runs, block_name)
# write (empty) results to txt_file and XML
self.txt_file.append(self.run_set_to_text(runSet), False)
runSet.xml_file_name = xml_file_name
self._write_rough_result_xml_to_file(runSet.xml, runSet.xml_file_name)
runSet.xml_file_last_modified_time = util.read_monotonic_time()
self.all_created_files.add(runSet.xml_file_name)
self.xml_file_names.append(runSet.xml_file_name)
