def locate_control_file(self):
# populate the initial control file, if none is specified then use
# the default
my_fctrl_path = self.option_def(CmdLine.Switches[CmdLine.control_name],
CtrlItmDefs.fctrl_name)
Msg.user("Control Path: %s (1)" % (str(my_fctrl_path)), "INITIAL_DIRS")
# if the control file contains a path then split that into the
# directory and the file
my_fctrl_dir, my_fctrl_file = PathUtils.split_path(my_fctrl_path)
Msg.user(
"Control File Split, Directory: %s, FileName: %s" %
(str(my_fctrl_dir), str(my_fctrl_file)),
"INITIAL_DIRS",
)
# important to realize that if the default control file is used, it is
# necessary to find the right file
if my_fctrl_dir is None:
# if the control file does not contain a path then need to assume
# the default path of
my_fctrl_dir = self.locate_directory(
CmdLine.Switches[CmdLine.control_dir],
EnVars.test_base,
Defaults.test_base,
)
else:
my_fctrl_dir = PathUtils.include_trailing_path_delimiter(
PathUtils.real_path(my_fctrl_dir))
return my_fctrl_dir, my_fctrl_file
def test_summary(aParameters):
forrest_log = aParameters.forrest_log
msg_level = aParameters.msg_lev
if msg_level is not None:
Msg.set_level(Msg.translate_levelstr(msg_level))
print("Forrest log file is: %s" % forrest_log)
work_dir, my_tmp = PathUtils.split_path(forrest_log)
frun_path = PathUtils.append_path(
PathUtils.include_trailing_path_delimiter(work_dir), "_def_frun.py")
# test - timeout
summary_queue_args = {
"frun-path":
frun_path,
"process-log":
forrest_log,
"process-result": (
0,
None,
"Process Timeout Occurred",
1555792446.313606,
1555792446.313606,
SysUtils.PROCESS_TIMEOUT,
),
}
summary_queue_item = SummaryQueueItem(summary_queue_args)
summary_item = SummaryItem({})
summary_item.load(summary_queue_item)
def resolveFileLocation(aClass, aInputString, aPrefixDirectoryList):
# validate the input
if not isinstance(aPrefixDirectoryList, list):
raise Exception(
"Parameter aPrefixDirectoryList needs to be a list of strings"
)
# is the input string itself a usable absolute path?
if aInputString.startswith("/") and PathUtils.check_found(
aInputString
):
return aInputString, True
# is the input string a relative path meaningful with one of the
# prefix directories prepended?
intermed_dir, file_name = PathUtils.split_path(aInputString)
for directory in aPrefixDirectoryList:
joined_path, outcome = (
FileLocator.checkNestedPath(
[directory, intermed_dir, file_name]
)
if intermed_dir is not None
else FileLocator.checkNestedPath([directory, file_name])
)
if outcome:
return joined_path, True
# the input string does not form an existing filepath
return aInputString, False
def locate_directory( self, arg_cmd_switch, arg_envar, arg_default ):
Msg.dbg( "arg_cmd_switch[%s], arg_envar[%s], arg_default[%s]" % (str(arg_cmd_switch), str(arg_envar), arg_default))
my_tmp = self.option_def( arg_cmd_switch, None)
# Msg.user( "Result Path: %s" % ( str( my_tmp )))
if my_tmp is None:
if arg_envar is not None:
# Not passed on the command line check for envar and the default
my_tmp = SysUtils.envar( arg_envar, arg_default, False )
else:
my_tmp = arg_default
# If a relative path has been provided either in the environmental var or as the default that path needs
# to be appended to the module path. Since all full paths begin with a path delimiter this is a valid test
if my_tmp[0] != "/":
my_tmp = PathUtils.include_trailing_path_delimiter( self.module_dir ) + my_tmp
# OK here is where it gets a bit tricky, when passed on the command line the path is calculated from the
# current directory, in all other cases from the module path. Since the app should be in the initial directory
# calculating the real path should resolve to a fully qualified path. To remove all indirection use real path
my_tmp = PathUtils.real_path( my_tmp )
# At this point the path should be a fully qualified path
# Msg.user( "Result Path: %s" % ( str( my_tmp )))
#
Msg.user( "Result Path: %s" % ( str( my_tmp )))
if not PathUtils.valid_path( my_tmp ):
raise FileNotFoundError( "Initial Directory for %s Resolution Failed[%s] could not be located" % ( arg_cmd_switch, my_tmp ))
if not PathUtils.check_exe( my_tmp ):
my_tmp = PathUtils.include_trailing_path_delimiter( my_tmp )
return my_tmp
def clean_up(self):
clean_up_rules = self.summary.cleanUpRules
if self.passed and not clean_up_rules.shouldKeepAll():
# list all the files and delete them except for _def_frun.py and
# the processor log (forrest.log)
my_dir = PathUtils.include_trailing_path_delimiter(self.work_dir)
Msg.user("Dir: %s" % (str(my_dir)), "FILES-TO-REMOVE")
my_file_path = str(my_dir) + "*"
Msg.user("Path: %s" % (my_file_path), "FILES-TO-REMOVE")
my_file_list = PathUtils.list_files(my_file_path)
Msg.user("Files: %s" % (str(my_file_list)), "FILES-TO-REMOVE")
process_log_base = PathUtils.base_name(self.process_log)
clean_up_rules.setBaseNamesToKeep(
["_def_frun.py", "PASS", process_log_base])
for my_file in my_file_list:
if clean_up_rules.shouldKeepFile(my_file):
Msg.user("File: %s KEPT" % clean_up_rules.lastBaseName())
else:
Msg.user("File: %s REMOVED" %
clean_up_rules.lastBaseName())
PathUtils.remove(my_file)
def __init__(self, arg_CommandLineParameters, aSysArgv):
self.mProgramPath, self.mProgramName = PathUtils.split_path(
PathUtils.real_path(aSysArgv[0])
)
self.CommandLineParameters = arg_CommandLineParameters
self.cmd_line_parser = None
self.ap_args = None
self.ap_unknown = None
self.ap_opts = AttributeContainer()
self.cmd_line_parser = CmdLineParser(
self.CommandLineParameters,
self.CommandLineParameters.group_names,
self.CommandLineParameters.group_descriptions,
self.CommandLineParameters.group_parameters,
add_help=True,
)
self.ap_args, self.ap_unknown = self.cmd_line_parser.parse_known_args(aSysArgv[1:])
self.cmd_line_parser.set_parameters(self.ap_opts)
try:
if len(self.ap_unknown) > 0:
raise Exception(
"Only Command Options are allowed: ["
+ os.path.realpath(aSysArgv[0])
+ "]\n Found Argument(s): "
+ str(self.get_unknown_arguments())
)
except Exception as e:
print(str(e))
sys.exit(40) # 40 was the code originally used for getopt errors
def process_task(self, arg_task_file, aTaskDir):
try:
# get the subdirectory index
my_ndx = self.mAppsInfo.getNextIndex(aTaskDir)
# form sub task directory
sub_task_dir = PathUtils.append_path(
PathUtils.include_trailing_path_delimiter(aTaskDir),
"%05d" % my_ndx)
# save the task template file name with path to the control item
self.ctrl_item.fname = arg_task_file
# prepare control item content, TODO don't really need it.
my_content = self.ctrl_item.prepare(self.mAppsInfo, arg_task_file)
my_queue_item = ProcessQueueItem(sub_task_dir, self.ctrl_item,
self.mAppsInfo, my_content)
self.mProcessQueue.enqueue(my_queue_item)
except Exception as arg_ex:
Msg.error_trace()
Msg.err(str(arg_ex))
# reraise to prevent adding to summary instance
raise
finally:
pass
def process_task_file(self, arg_task_file, aParentDir):
try:
# NOTE: a task file can be but is not limited to being an test template file
# set base task directory and extract the task id and update directory
my_task_name = PathUtils.base_name(arg_task_file)
my_task_dir = my_task_name.replace(".py", "")
# Msg.info("suffix: %s" % ( str( self.ctrl_item.suffix )))
if self.ctrl_item.suffix is not None:
my_task_dir = my_task_dir.replace(
"_force", "_%s_force" % (str(self.ctrl_item.suffix)))
full_task_dir = PathUtils.append_path(
PathUtils.include_trailing_path_delimiter(aParentDir),
my_task_dir)
# Msg.dbg( "Changed to Base Dir, my_task_name(%s), my_task_dir(%s)" % (my_task_name, my_task_dir))
# check for exiting sub-directories, and extract the task iteration count to prevent
# unintended modifications to the original passed on the commafrom common.path_utils import PathUtilsnd line for this task or
# acquired from a control file item
self.process_task(arg_task_file, full_task_dir)
finally:
pass
def resolve_file_location(self, aAppsInfo, aParentPath):
control_file_name = self.fctrl_name
control_dir = self.fctrl_dir
if control_file_name.startswith("$/"):
control_file_name = control_file_name.replace("$/", aAppsInfo.mTestBaseDir)
the_dir, the_filename = PathUtils.split_path(control_file_name)
if the_dir is None:
control_file_name = control_dir + "/" + the_filename
prefix_list = [
aParentPath,
aAppsInfo.mTestBaseDir,
aAppsInfo.mToolPath,
aAppsInfo.mMainAppPath,
]
control_file_path, path_valid = FileLocator.resolveFileLocation(
control_file_name, prefix_list
)
control_dir, control_file_name = PathUtils.split_path(control_file_path)
control_dir = PathUtils.include_trailing_path_delimiter(control_dir)
if not path_valid:
raise Exception(
"File [%s] Not Found at Locations Specified %s"
% (control_file_name, str(prefix_list))
)
self.fctrl_name = control_file_name
self.fctrl_dir = control_dir
self.item_path = control_file_path
def __init__(self, arg_msg_lev, arg_def_lev):
self.m_app_setup = None
self.m_app_info = None
self.module_dir, self.module_name = PathUtils.split_path(
PathUtils.real_path(sys.argv[0]))
self.init_app_setup()
self.load_message_levels(arg_msg_lev, arg_def_lev)
def load(self, arg_ctrl_item):
super().load(arg_ctrl_item)
# Msg.dbg( "TaskController::load()")
self.task_list = PathUtils.list_files(
PathUtils.append_path(self.ctrl_item.fctrl_dir,
self.ctrl_item.fctrl_name))
return True
def __init__(self):
try:
self.mCmdLineParms = CommandLineParameters
self.mConfigArgs = retrieveConfigArgument(sys.argv[1:])
self.mAppsSetup = ApplicationsSetup(self.mCmdLineParms, sys.argv, self.mConfigArgs, True, True)
self._mAppsInfo = self.mAppsSetup.getApplicationsInfo()
except SystemExit as aSysExit:
sys.exit(int(str(aSysExit)))
except:
print("[ERROR] - An Unhandled Error has Occurred during applications setup of " + str(sys.argv[0]))
traceback.print_exc(file=sys.stdout)
sys.exit(44)
self.module_dir, self.module_name = PathUtils.split_path(PathUtils.real_path(sys.argv[0]))
# self._mAppsInfo = apps_info
self.load_message_levels(CmdLine.Switches[CmdLine.msg_lev], Defaults.msg_level)
#print( "Got here (2.1)" )
# persistent values
self._mAppsInfo.mMainAppPath = PathUtils.include_trailing_path_delimiter(self.module_dir) + "../.." # TODO still keep main app path for now.
self._mAppsInfo.mProcessMax = self.option_def( CmdLine.Switches[CmdLine.process_max], None, self.to_int )
self._mAppsInfo.mTestBaseDir = None
self._mAppsInfo.mToolPath = self.module_dir
self.fctrl_dir = None
self.mode = None
self.summary = None
self.process_queue = None
self.client_lev = False
self.default_root = ""
self.ctrl_item = ControlItem()
# no propogate values
self.num_runs = None
self.sum_level = None
self.item_data = {}
self.options = {}
self.max_fails = 0
self.limit_fails = False
self.crit_sec = HiCriticalSection()
self.processor_name = None
self.fctrl = None
self.terminated = False
# this is a proc that will decrement the fails counter until it is 0
# if the proc is None then this will not occur
self.on_fail_proc = None
self.is_term_proc = None
# if an external terminate event is captured then this call back will shutdown
# master run and all associated threads gracefully
global shutdown_proc
shutdown_proc = self.trigger_shutdown
def main():
signal.signal(signal.SIGINT, sig_interrupt_handler)
my_pwd = None
print(
"\n=======================================\n\tInitializing ....\n=======================================\n"
)
try:
my_module = MasterRun()
# save current working directory
my_pwd = PathUtils.current_dir()
Msg.dbg("Original Directory: " + my_pwd)
Msg.dbg("Processing Command Line and Loading Control File")
my_module.load()
if not PathUtils.chdir(my_module.output_dir, True):
Msg.dbg("Unable to change into: " + my_module.output_dir +
", using the current directory for output")
Msg.info("\nConcurrent Operations: %s" %
(str(my_module.m_app_info.mProcessMax)))
my_module.run()
Msg.info("Test Completed ....\n")
except FileNotFoundError as arg_ex:
# Msg.error_trace("[ERROR] - " + str(arg_ex) )
Msg.err(str(arg_ex))
Msg.blank()
except LoadError as arg_ex:
# Msg.error_trace("[ERROR] - " + str(arg_ex) )
Msg.err(str(arg_ex))
Msg.blank()
except Exception as arg_ex:
from force_init import force_usage
Msg.err("[ERROR] - An Unhandled Error has Occurred during run of " +
str(sys.argv[0]))
traceback.print_exc(file=sys.stdout)
except:
# traceback.print_exc( file=sys.stdout )
# print( "An Unhandled Exception Occurred ..." )
pass
finally:
# TODO
# change back to original directory
if my_pwd is not None:
# Msg.dbg( "Restoring Original Directory: " + my_pwd )
PathUtils.chdir(my_pwd)
def execute(self):
if not PathUtils.check_file("sim.log"):
Msg.info(
"[TracediffRiscVExecutor::skip] skipping since no sim.log found"
)
return True
if not PathUtils.check_file("fpix_sim.log"):
Msg.info(
"[TracediffRiscVExecutor::skip] skipping since fpx_sim.log not found"
)
return True
my_cmd = "diff -y fpix_sim.log sim.log | grep -ve \"---\" | grep -vie \"exi\" | grep -vie \"exe\" | grep -ve \"_t\""
self.log = "tracediff_result.log" # arg_testname.replace( ".py", ".pgen.log" )
self.elog = "tracediff_result.err" # arg_testname.replace( ".py", ".gen.log" )
my_result = SysUtils.exec_process(my_cmd, self.log, self.elog,
self.ctrl_item.timeout, True)
my_use_result = None
vbar_symbol_count = 0
exception_count = 0
success = False
with open(self.log, 'r') as results_file:
for line in results_file:
vbar_symbol_count += line.count('|')
if "Excpt ID 0x2" in line:
exception_count = exception_count + 1
if vbar_symbol_count == 0 and exception_count == 0:
success = True
my_use_result = list(my_result)
my_use_result[0] = int(
not success
) #This inversion is necessary because int 0 means success to the Summary class.
with open(self.log, 'a') as out_file:
if success == False:
out_file.write(
"tracediff_riscv.log fail, look for | symbols or 'Excpt ID 0x2'; "
+ str(vbar_symbol_count) + " mismatches, and up to " +
str(exception_count) + " suspicious exceptions.")
else:
out_file.write(
"tracediff_riscv.log success, only bootcode difference between standalone and interactive as expected."
)
Msg.info("CMPCommand = " + str({"trace-cmp-cmd": my_cmd}))
my_extract_results = self.extract_results(my_use_result,
"./" + self.log, None)
Msg.info("CMPResult = " + str(my_extract_results))
Msg.flush()
#return SysUtils.success(0) #[0,1,2] #Doesn't seem to really matter what this is, the Summary system needs fixing.
return SysUtils.success(int(my_result[ToolResult.process_retcode]))
def load_task_info(self):
self.task_id = None
self.task_index = None
self.work_dir, my_tmp = PathUtils.split_path(self.frun_path)
my_tmp, my_index = PathUtils.split_dir(self.work_dir)
my_tmp, self.task_id = PathUtils.split_dir(my_tmp)
self.task_index = int(my_index)
self.task_path = PathUtils.include_trailing_path_delimiter(
str(self.work_dir))
def commit(self):
my_gen_cnt = 0
my_gen_ret = 0
my_sim_cnt = 0
my_sim_ret = 0
my_rtl_cnt = 0
my_rtl_ret = 0
my_trace_cmp_ret = 0
my_trace_cmp_cnt = 0
my_tgt_name = ""
self.passed = True
if self.has_generate():
#Msg.user( "if self.has_generate(): True" )
my_gen_cnt = 1
my_gen_ret = self.commit_generate()
self.passed = self.passed and bool(my_gen_ret)
if self.has_simulate():
#Msg.user( "if self.has_simulate(): True" )
my_sim_cnt = 1
my_sim_ret = self.commit_simulate()
self.passed = self.passed and bool(my_sim_ret)
if self.has_rtl():
#Msg.user( "if self.has_rtl(): True" )
my_rtl_cnt = 1
my_rtl_ret = self.commit_rtl()
self.passed = self.passed and bool(my_rtl_ret)
# Msg.user( "SummaryItem::commit - [20]", "GOT HERE" )
if self.has_trace_cmp():
# Msg.user( "SummaryItem::commit - [21]", "GOT HERE" )
my_trace_cmp_cnt = 1
# Msg.user( "SummaryItem::commit - [22]", "GOT HERE" )
my_trace_cmp_ret = self.commit_trace_cmp()
self.passed = self.passed and bool(my_trace_cmp_ret)
# Msg.user( "SummaryItem::commit - [24]", "GOT HERE" )
my_src_name = "%s%s" % (self.task_path, "STARTED")
my_tgt_name = "%s%s" % (self.task_path,
SysUtils.ifthen(
self.passed, "PASS",
SysUtils.ifthen(self.signal_id is None,
"FAIL", "INCOMPLETE")))
PathUtils.move(my_src_name, my_tgt_name)
if not self.passed:
self.summary.do_on_fail(self)
return (my_gen_cnt, my_gen_ret, my_sim_cnt, my_sim_ret, my_rtl_cnt,
my_rtl_ret, my_trace_cmp_cnt, my_trace_cmp_ret)
def __init__( self, aWorkDir, arg_ctrl_item, aAppsInfo, arg_content ):
super().__init__()
self.work_dir = aWorkDir
self.frun_path = PathUtils.append_path(PathUtils.include_trailing_path_delimiter(self.work_dir), "_def_frun.py")
self.ctrl_item = arg_ctrl_item
self.mAppsInfo = aAppsInfo
self.parent_fctrl = arg_ctrl_item.parent_fctrl
self.fctrl_item = arg_ctrl_item.fctrl_item
self.item_group = arg_ctrl_item.group
self.content = arg_content
def initialize_task(self):
# Msg.user( "ExecuteController::initialize_task(1)" )
my_task_file = PathUtils.append_path(self.ctrl_item.fctrl_dir,
self.ctrl_item.fctrl_name)
# Msg.user( "ExecuteController::initialize_task(2)" )
my_tmp, my_task_ndx = PathUtils.split_path(self.ctrl_item.fctrl_dir)
# Msg.user( "ExecuteController::initialize_task(3)" )
my_task_name = self.ctrl_item.fctrl_name.replace(".py", "")
# Msg.user( "ExecuteController::initialize_task(5)" )
Msg.user("Task File: %s, Task Name: %s, Task Index: %s" %
(my_task_file, my_task_name, my_task_ndx))
return (my_task_file, my_task_name, my_task_ndx)
def __init__(self, aAppsInfo):
self.module_dir, self.module_name = PathUtils.split_path(
PathUtils.real_path(sys.argv[0]))
self._mAppsInfo = aAppsInfo
self.load_message_levels(CmdLine.Switches[CmdLine.msg_lev],
Defaults.msg_level)
self.frun_name = None
self.frun_dir = None
self.item_data = {}
self.options = {}
def __init__(self, arg_msg_lev, arg_def_lev, aAppsInfo):
# print( "Message Level: %s" % (str(arg_msg_lev )))
# print( "Default Level: %s" % (str(arg_def_lev )))
# extract the module dir and name
self.module_dir, self.module_name = PathUtils.split_path(
PathUtils.real_path(sys.argv[0]))
self._mAppsInfo = aAppsInfo
# set the message level
self.load_message_levels(arg_msg_lev, arg_def_lev)
def _optPathChecks(self, aValue, aProgramPath):
opt_value = aValue
if (len(opt_value) > 0) and (opt_value[0] != "/"):
opt_value = PathUtils.include_trailing_path_delimiter(aProgramPath) + opt_value
opt_value = PathUtils.real_path(opt_value)
if not PathUtils.valid_path(opt_value):
raise FileNotFoundError("Path resolution for [%s] failed, [%s] could not be located" % (self._optionString(), opt_value))
if PathUtils.check_dir(opt_value):
opt_value = PathUtils.include_trailing_path_delimiter(opt_value)
return opt_value
def __init__(self, aCmdLineOptions):
super().__init__(FrunToCtrlCmdLineOptions.cOptions, aCmdLineOptions)
if self.mAppParameters.parameter('frun-to-ctrl'):
frun_to_ctrl_path = PathUtils.include_trailing_path_delimiter(
aCmdLineOptions.mProgramPath
) + "../frun_to_ctrl/frun_to_ctrl.py"
if not PathUtils.check_exe(frun_to_ctrl_path):
raise Exception(
frun_to_ctrl_path +
" does not exist or is not executable, confirm valid exe")
frun_to_ctrl_path = PathUtils.real_path(frun_to_ctrl_path)
self.mAppParameters.setParameter('path', frun_to_ctrl_path)
def build(self):
"""build the command line launcher with initial values"""
my_cmd = self.process_cmd % (self.frun_path)
Msg.user("Process Command: %s" % (str(my_cmd)), "LAUNCHER")
my_log = (PathUtils.include_trailing_path_delimiter(self.frun_dir) +
self.process_log)
return my_cmd, my_log
def process_summary(self, arg_sum_level=SummaryLevel.Fail):
# Msg.user( "process_summary()", "REG-SUMMARY" )
my_utcdt = DateTime.UTCNow()
my_file_name = "%sregression_summary.log" % (
PathUtils().include_trailing_path_delimiter(self.summary_dir)
)
# Msg.user( "Master Log File: %s" % ( my_file_name ))
my_ofile = None
myLines = []
# First try to open file
with open(my_file_name, "w") as my_ofile:
try:
my_ofile.write("Date: %s\n" % (DateTime.DateAsStr(my_utcdt)))
my_ofile.write("Time: %s\n" % (DateTime.TimeAsStr(my_utcdt)))
self.process_errors(my_ofile)
my_instr_count, my_cycle_count = self.process_summary_tasks(
my_ofile, arg_sum_level
)
self.process_summary_totals(my_ofile, my_instr_count, my_cycle_count)
except Exception as arg_ex:
Msg.error_trace()
Msg.err("Processing Summary, " + str(arg_ex))
finally:
my_ofile.close()
def execute(self):
if not PathUtils.check_file("./_def_frun.py"):
Msg.user(
"[FrunToCtrlExecutor::skip] skipping since no _def_frun.py found"
)
return True
my_cmd = self.mFrunToCtrlCmd
if my_cmd is None:
Msg.user(
"[FrunToCtrlExecutor::skip] skipping since no path was given")
return True
Msg.user("FrunToCtrlCommand = " + str({"frun-to-ctrl-cmd": my_cmd}))
Msg.flush()
self.log = "frun_to_ctrl_result.log"
self.elog = "frun_to_ctrl_result.err"
my_result = SysUtils.exec_process(my_cmd, self.log, self.elog,
self.ctrl_item.timeout, True)
Msg.user("FrunToCtrlResult = " + str(my_result))
Msg.flush()
return SysUtils.success(int(my_result[0]))
def process_summary(self, sum_level=SummaryLevel.Fail):
my_file_name = "%sperformance_summary.log" % (
PathUtils().include_trailing_path_delimiter(self.summary_dir))
Msg.dbg("Master Log File: %s" % (my_file_name))
my_utcdt = DateTime.UTCNow()
my_ofile = None
try:
# First try to open file
with open(my_file_name, "w") as my_ofile:
my_ofile.write("Date: %s\n" % (DateTime.DateAsStr(my_utcdt)))
my_ofile.write("Time: %s\n" % (DateTime.TimeAsStr(my_utcdt)))
self.process_errors(my_ofile)
my_total_count, my_total_elapsed = self.process_groups(
my_ofile)
Msg.blank("info")
my_line = "Total Instructions Generated: %3d\n" % (
my_total_count)
my_line += "Total Elapsed Time: %0.3f\n" % (my_total_elapsed)
my_line += "Overall Instructions per Second: %0.3f\n" % (
SysUtils.ifthen(bool(my_total_elapsed),
my_total_count / my_total_elapsed, 0))
Msg.info(my_line)
my_ofile.write(my_line)
except Exception as arg_ex:
Msg.error_trace()
Msg.err("Error Processing Summary, " + str(arg_ex))
finally:
my_ofile.close()
def copyWavesFsdbDoFile(self):
dofile_path = self.rtl.get("fsdb_do")
if dofile_path is not None and type(dofile_path) is str:
SysUtils.exec_cmd(
"cp %s %s/%s_waves_fsdb.do" %
(dofile_path, PathUtils.current_dir(), self.task_name))
def convertRawResult(self, aMetaArgs, aFilter=False):
current_dir = PathUtils.current_dir()
PathUtils.chdir(self._mTopSimPath)
result, is_valid = SysUtils.get_command_output(self._mMakeCommand + aMetaArgs)
PathUtils.chdir(current_dir)
if not is_valid:
print("Converting meta args: %s to raw result failed." % aMetaArgs)
sys.exit(1)
if aFilter:
args_list = result.split(" ")
args_list = self.filterList(args_list)
result = " ".join(args_list)
return result
def retrieve_config_argument(aArguments):
config_argument = CmdLineUtils.basic_command_line_argument_retrieval(
aArguments, "-c", "--config", str, 1)
# PathUtils.resolvePath() - retrieve the entire file path from a string
return (PathUtils.resolvePath(config_argument.config[0])
if config_argument.config is not None else None)
def __init__(self, aRtlRoot, aMakefile):
self._mRtlRoot = aRtlRoot
self._mMakefile = aMakefile
self._mBaseResultSet = None # Raw result produced with an empty meta args string
self._mMakeCommand = 'make -f %s output_run_opts ' % self._mMakefile
self._mTopSimPath = PathUtils.include_trailing_path_delimiter(
self._mRtlRoot) + "verif/top/sim"