def commit_generate(self):
self.force_result = SysUtils.ifthen(
SysUtils.success(self.force_retcode), "PASS", "FAIL"
)
self.force_level = SummaryLevel.Any
if SysUtils.failed(self.force_retcode):
self.force_level = SummaryLevel.Fail
Msg.lout(self, "user", "Performance Summary Item Commit Generate")
if SysUtils.success(self.force_retcode):
Msg.info(
"Instructions: %d, Default: %d, Secondary: %d, "
"Elapsed Time: %0.5f Seconds\n\n"
% (
self.total,
self.default,
self.secondary,
self.force_end - self.force_start,
)
)
return 1
return 0
def execute(self):
# super().execute()
# Msg.dbg("ExecuteController::exec_gen(%s)" % (arg_task_file))
# NOTE: Do not change force_cmd may need to reuse!!
my_log = "gen.log" # arg_testname.replace(".py", ".gen.log")
my_elog = "gen.err" # arg_testname.replace(".py", ".gen.log")
my_cmd = self.force_cmd % (self.task_file) # , my_log)
# Msg.info("ForceCommand = " + str({ GenerateKeys.gen_cmd: my_cmd, GenerateKeys.gen_log: my_log, GenerateKeys.gen_elog: my_elog }), True)
Msg.info(
"GenCmd = " + str({
GenerateKeys.gen_app: "force",
GenerateKeys.gen_cmd: my_cmd,
GenerateKeys.gen_log: my_log,
GenerateKeys.gen_elog: my_elog,
"max-instr": self.ctrl_item.max_instr,
"min-instr": self.ctrl_item.min_instr
}), True)
my_return = SysUtils.exec_process(my_cmd, my_log, my_elog,
self.ctrl_item.timeout, True)
# the return from exec_process is a tuple, see generate_executor.py, retcode, stdout, stderr, start-time, end-time
my_results = self.extract_results(my_return, "./" + my_log,
"./" + my_elog)
Msg.info("GenResult = " + str(my_results))
Msg.flush()
return SysUtils.success(int(my_return[GenerateResult.process_retcode]))
def prepare(self):
if self.root.startswith("$(") and self.root.endswith(")"):
self.root = PathUtils.exclude_trailing_path_delimiter(
SysUtils.envar(self.root[2:-1], None))
self.default_fsdb_do = PathUtils.append_path(self.root,
self.default_fsdb_do)
if self.regr.startswith("$(") and self.regr.endswith(")"):
self.regr = PathUtils.exclude_trailing_path_delimiter(
SysUtils.envar(self.regr[2:-1], "logs"))
else:
self.regr = "logs"
if self.cfg.startswith("$(") and self.cfg.endswith(")"):
self.cfg = PathUtils.exclude_trailing_path_delimiter(
SysUtils.envar(self.cfg[2:-1], "target_config"))
else:
self.cfg = "config_name"
if self.name.startswith("$(") and self.name.endswith(")"):
self.name = PathUtils.exclude_trailing_path_delimiter(
SysUtils.envar(self.name[2:-1], "uvm_simv_opt"))
else:
self.cfg = "uvm_simv_opt"
self.path = PathUtils.exclude_trailing_path_delimiter(self.path)
self.tgt = PathUtils.exclude_trailing_path_delimiter(self.tgt)
self._debug_command = self.cmd % (self.root, self.path, self.regr,
self.tgt, self.debug_cfg,
self.debug_name)
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 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 run(self):
# Msg.user( "Worker Thread Instance Id: %s, (1)" % ( str( id( self ))) , "WORK-THREAD" )
my_sum_qitem = None
try:
self.setupWorkDir()
my_launcher = self.create_launcher()
Msg.user("Launcher Id 1: %s" % (str(id(my_launcher))),
"WORK-THREAD")
# Msg.user( "Worker Thread Instance Id: %s, (2)" % ( str( id( self ))) , "WORK-THREAD" )
my_launcher.launch()
Msg.user("Launcher Id 2: %s" % (str(id(my_launcher))),
"WORK-THREAD")
# Msg.user( "Worker Thread Instance Id: %s, (3)" % ( str( id( self ))) , "WORK-THREAD" )
my_process_result = my_launcher.extract_results()
Msg.user("Process Result: %s" % (my_process_result), "WORK-THREAD")
Msg.user("Launcher Id 3: %s" % (str(id(my_launcher))),
"WORK-THREAD")
#
self.launcher = my_launcher
Msg.user("Process Result: %s" % (my_process_result), "WORK-THREAD")
my_sum_qitem = SummaryQueueItem(my_process_result)
Msg.user("Created Summary Queue Item", "WORK-THREAD")
except Exception as arg_ex:
Msg.error_trace(str(arg_ex))
Msg.err("Message: %s, Control File Path: %s" %
(str(arg_ex), self.queue_item.work_dir))
my_sum_qitem = SummaryErrorQueueItem({
"error":
arg_ex,
"message":
"Error Processing Task ...",
"path":
self.queue_item.ctrl_item.file_path(),
"type":
str(type(arg_ex))
})
finally:
# my_launcher = None
my_attempt = 0
while (self.summary.queue.enqueue(my_sum_qitem) == False):
SysUtils.sleep(100)
#heartbeat
my_attempt += 1
if (my_attempt % 10) == 0:
Msg.dbg("Attempt %d to insert into summary queue" %
(my_attempt))
self.thread_count.delta(-1)
Msg.user("Thread Count Decremented", "WORK-THREAD")
self.done_semaphore.release()
Msg.user("Semaphore Released", "WORK-THREAD")
Msg.user("Launcher Id 5: %s" % (str(id(self.launcher))),
"WORK-THREAD")
def waitForLfs(self, aModTime):
if self.launcher_type == LauncherType.Lsf:
time_diff = int ( DateTime.Time() - aModTime )
if time_diff < MasterRun.cLsfWaitTime:
sec_delay = MasterRun.cLsfWaitTime - time_diff
Msg.info ("Using LSF, delaying %d seconds so that stale output/regression file handle will expire..." % sec_delay)
SysUtils.sleep_seconds_with_progress(sec_delay)
Msg.info ("Waiting done, resumed master run")
def process_summary_totals( self, arg_ofile, arg_instr_count, arg_cycle_count ):
Msg.blank("info")
# generator totals
my_gfails = self.gen_total - self.gen_passed
my_lines = "\nGenerate : %3d\n" % ( self.gen_total )
my_lines += "Generate Fails: %3d\n" % ( my_gfails )
my_lines += "Generate Success Rate : %5.2f%%\n" % ( SysUtils.percent( self.gen_passed, self.gen_total ))
my_lines += "\n"
my_sfails = 0
if self.iss_total >0:
# ISS sim totals
my_sfails = self.iss_total - self.iss_passed
my_lines += "ISS Sim : %3d\n" % ( self.iss_total )
my_lines += "ISS Sim Fails: %3d\n" % ( my_sfails )
my_lines += "ISS Sim Success Rate : %5.2f%%\n" % ( SysUtils.percent( self.iss_passed, self.iss_total ))
my_lines += "\n"
my_lines += "Total Instructions Emulated: %3d\n" % ( arg_instr_count )
my_lines += "\n"
my_rfails = 0
if self.rtl_total >0:
# RTL sim totals
my_rfails = self.rtl_total - self.rtl_passed
my_lines += "RTL Sim : %3d\n" % ( self.rtl_total )
my_lines += "RTL Sim Fails: %3d\n" % ( my_rfails )
my_lines += "RTL Sim Success Rate : %5.2f%%\n" % ( SysUtils.percent( self.rtl_passed, self.rtl_total ))
my_lines += "\n"
my_lines += "Total Cycle Count: %3d\n" % ( arg_cycle_count )
my_lines += "\n"
my_cfails = 0
if self.trace_cmp_total > 0:
# simulation totals
my_cfails = self.trace_cmp_total - self.trace_cmp_passed
my_lines += "Compared : %3d\n" % ( self.trace_cmp_total )
my_lines += "Compare Fails: %3d\n" % ( my_cfails )
my_lines += "Compare Success Rate : %5.2f%%\n" % ( SysUtils.percent( self.trace_cmp_passed, self.trace_cmp_total ))
my_lines += "\n"
# task totals
my_task_total = ( self.task_total)
my_total_fails = my_gfails + my_sfails + my_cfails + my_rfails
my_lines += "Total Tasks : %3d\n" % ( my_task_total )
my_lines += "Task Fails : %3d\n" % ( my_total_fails )
my_lines += "Task Success Rate: %5.2f%%\n" % ( SysUtils.percent( my_task_total - my_total_fails, ( my_task_total )))
my_lines += "\n"
my_lines += "Total Run Time: %0.5f Seconds" % ( DateTime.Time() - self.start_time )
Msg.blank("info")
Msg.info( my_lines )
Msg.blank("info")
arg_ofile.write( my_lines )
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 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 commit_trace_cmp( self ):
# Msg.dbg( "RegressionSummaryItem::commit_generate" )
self.trace_cmp_result = SysUtils.ifthen( SysUtils.success( self.trace_cmp_retcode ), "PASS", SysUtils.ifthen( self.signal_id is None, "FAIL", "INCOMPLETE" ) )
self.trace_cmp_level = SummaryLevel.Any
if SysUtils.failed( self.trace_cmp_retcode ):
self.trace_cmp_level = SummaryLevel.Fail
Msg.user( "self.trace_cmp_retcode = %s" % ( str( self.trace_cmp_retcode )) )
Msg.user( "self.trace_cmp_level = %s" % ( str( SummaryLevel.Fail)) )
return SysUtils.ifthen( SysUtils.success( self.trace_cmp_retcode ), 1 , 0 )
def run(self):
try:
while (not self.process_queue.fully_loaded) or (
self.process_queue.fully_loaded and
(self.thread_count.value() > 0
or self.process_queue.size() > 0)):
try:
# if something tiggered a shutdown then exit the
# processing loop and stop processing more items.
if self.process_queue.summary.is_terminated():
Msg.user("Terminated", "PROCESS-THREAD")
break
# Pop off the top of the process queue (should block if
# the queue is empty)
my_queue_item = self.process_queue.dequeue(1)
# Launch a thread with the item. Sempahore will block if
# we've reached max workers
Msg.user("Waiting for Semaphore ....", "PROCESS-THREAD")
if my_queue_item.mAppsInfo.mMode == "count":
Msg.user(
"Counting %s" % my_queue_item.work_dir,
"PROCESS-THREAD",
)
my_queue_item.mAppsInfo.incrementTestCount()
else:
my_work_thread = ProcessWorkerThread(
self.summary,
self.semaphore,
self.thread_count,
my_queue_item,
self.process_queue.processor_name,
self.process_queue.process_cmd,
self.process_queue.use_lsf(),
)
except TimeoutError:
pass
finally:
pass
# need to wait until all worker threads are done before continuing
while self.thread_count.value() > 0:
Msg.user(
"Thread Count: %d" % (self.thread_count.value()),
"PROCESS-THREAD",
)
SysUtils.sleep(100)
finally:
self.done_event.Signal()
def execute(self):
try:
cmd = 'make compile -C %s %s' % (self.mMakefilePath, self.mOptions)
Msg.user('Compile command = ' + str({'compile-cmd':cmd}))
result = SysUtils.exec_process(cmd, self.log, self.elog, self.ctrl_item.timeout, True)
Msg.user('Compile result = ' + str(result))
except:
print('[CompileExecutor] problem in execute method: ', sys.exc_info()[0])
raise
return SysUtils.success(int(result[0]))
def heartbeat(self):
# increment the heartbeat and when debug messages are enabled then a heartbeat message will be
# posted every self.heartbeat-interval ticks. Whenever the heartbeat method is called the current_tick
# is updated
self.current_tick += 1
if not bool(self.current_tick % self.heartbeat_rate):
Msg.dbg("HiThread[%s] Still Working" % (self.name))
# the sleep in SysUtils uses milliseconds as does the rest of the computing world instead of
# fractions of a second. Thus this will pause this thread for 10 seconds allowing the process
# thread some processor time
SysUtils.sleep(self.sleep_period)
return False
def get_plus_args(self):
rtl_root = self.rtl.get("root")
meta_args = self.rtl.get(
"meta_args",
"tc_mode=force railhouse=on rvbar=80000000 prefetch_drop_int=10 no_commit_cycles=6000"
) # by default set railhouse on
# look for additional meta args if any
add_meta_args = self.rtl.get("add_meta_args", "")
if len(add_meta_args) > 0:
meta_args = ' '.join([meta_args, add_meta_args])
meta_converter = self.rtl.get("meta_converter")
convert_cmd = meta_converter + " -r %s -m \"%s\"" % (rtl_root,
meta_args)
plus_args, is_valid = SysUtils.get_command_output(convert_cmd)
Msg.user("Meta args converting command: %s" % convert_cmd, "META-CONV")
if not is_valid:
Msg.user("Conversion failed.", "META-CONV")
raise Exception("Meta conversion failed: %s" % meta_args)
else:
Msg.user("Converted to plus args: %s" % plus_args, "META-CONV")
if self.rtl.get("filter"):
plus_args = self.filterPlusArgs(plus_args)
Msg.user("Filtered plus args: %s" % plus_args, "META-CONV")
return plus_args
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 load_config(self, arg_cfg_file):
# ok there is a config file to load, there are two possibilities,
# neither require path manipulation
# 1. the config file is specified as a relative path from the launch
# directory
# 2. the config file is specified as a fully qualified path
try:
# load the config file if it exists
my_content = open(arg_cfg_file).read()
except Exception as arg_ex:
Msg.err("Unable to open Config File: %s" % (str(arg_cfg_file)))
raise
try:
my_glb, my_loc = SysUtils.exec_content(my_content)
self.load_config_data(my_loc)
except Exception as arg_ex:
Msg.err("Unable to Process Config File, Message: %s" %
(str(arg_ex)))
raise
return True
def get_scm_data(cls, scm_type, a_path, a_cmd, a_cwd=None):
"""Returns an initialized data structure to hold SCM version data.
:param str scm_type: 'svn' or 'git'
:param str a_path: Project base folder
:param str a_cmd: Command to return scm status detail
:param str a_cwd:
:return: dict containing SCM data
:rtype: dict
"""
version_info = {
"scm_type": scm_type,
"status": False,
"error_msg": None,
"folder": a_path,
"url": "",
}
cmd_output, valid = SysUtils.get_command_output(a_cmd, arg_cwd=a_path)
if not valid:
version_info["error_msg"] = "Command error: %s" % cmd_output
elif not cmd_output:
version_info["error_msg"] = "Revision info not found"
return version_info, cmd_output
def post(self):
if self.ctrl_item.compile.get('mp'):
lsu_folder = PathUtils.real_path('%s/../../../rtl/lsu' % self.mMakefilePath)
cmd = 'svn revert %s/lsu_scb_retire_ctrl.vp %s/lsu_scb_sca_array.vp %s/lsu_scb_scd_array.vp' % (lsu_folder, lsu_folder, lsu_folder)
Msg.user('MP post-compile command = %s' % cmd)
result = SysUtils.exec_process(cmd, self.log, self.elog, self.ctrl_item.timeout, True)
Msg.user('MP post-compile command = %s' % str(result))
def rename_elfs(self, arg_suffix):
# before proceeding it is necessary to remove any existing renamed files to eliminate the possibility of causing
# a chain and messing up the results
for my_mask in ["*.ELF", "*.S", "*.img"]:
my_match_files = PathUtils.list_files(my_mask)
Msg.lout(my_match_files, "user", "Simulate File List")
for my_src_file in my_match_files:
Msg.user(
"Match File: %s, Suffix: %s" %
(str(my_src_file), str(arg_suffix)), "MATCH")
if SysUtils.found(
my_src_file.find("_%s_force" % (str(arg_suffix)))):
PathUtils.remove(my_src_file)
continue
# Now rename all the files that are found
for my_mask in ["*.ELF", "*.S", "*.img"]:
my_match_files = PathUtils.list_files(my_mask)
for my_src_file in my_match_files:
my_tgt_file = my_src_file.replace(
"_force", "_%s_force" % (str(arg_suffix)))
PathUtils.rename(my_src_file, my_tgt_file)
# raise Exception("Type %s test case for base test: %s not found." % (arg_extension, arg_test_name))
return True
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 load_process_line(self, arg_line):
Msg.user("Process Result Line: %s" % (str(arg_line)), "SUM-TUPLE")
if arg_line[0] == "[":
return
my_val = None
try:
my_glb, my_loc = SysUtils.exec_content(arg_line, True)
except (SyntaxError, TypeError) as arg_ex:
return
except BaseException:
raise
# summary tuples are initialized in the __init__ as are the element
# indexes the idea is to the tuple list for a match on the key. When
# one is found the callback proc that is referenced is executed with
# the line dictionary retrieved and the flags are updated as to what
# this summary item contains
for (my_key, my_proc, my_mask) in self.sum_tups:
my_result = my_loc.get(my_key, None)
if my_result is None:
# nothing was returned continue causes the next element to be
# checked if there is a next element
continue
my_proc(my_result)
self.detail_flags |= int(my_mask)
break
return True
def load(self, arg_ctrl_item):
super().load(arg_ctrl_item)
# Msg.dbg("ForceProcessor::load()")
my_cmd = self.ctrl_item.generator['path']
my_cmd += " -t %s" + " --max-instr %d" % self.ctrl_item.max_instr
my_cmd += " --num-chips %d --num-cores %d --num-threads %d" % (self.ctrl_item.num_chips, self.ctrl_item.num_cores, self.ctrl_item.num_threads)
my_cmd += SysUtils.ifthen(self.ctrl_item.seed is None , "", (" -s %s" % (self.ctrl_item.seed)))
# Msg.dbg("my_cmd: %s" % (str(my_cmd)))
if isinstance(self.ctrl_item.generator, dict):
for my_key in self.ctrl_item.generator.keys():
if my_key not in ['path']:
my_cmd += " %s %s " % (str(my_key), SysUtils.ifthen(self.ctrl_item.generator[ my_key ] is None, "", str(self.ctrl_item.generator[ my_key ])))
self.force_cmd = my_cmd.strip()
def execute( self ):
my_result = None
test_passed = True
try:
self.build_cmd()
self.copyWavesFsdbDoFile()
self.outputRerunScript()
# report the command line
Msg.info( "RTLCommand = " + str( { "rtl-command": self.rtl_cmd } ))
# execute the simulation
my_result = SysUtils.exec_process( self.rtl_cmd, self.rtl_log, self.rtl_log, self.ctrl_item.timeout, True )
Msg.user( "Results: %s" % ( str( my_result )), "RTLEX-RESULT" "")
my_extract_results = self.extract_results( my_result, "./" + self.rtl_log, None )
# report the results
Msg.info( "RTLResult = " + str( my_extract_results ))
except Exception as arg_ex:
Msg.error_trace( "RTL Process Failure" )
Msg.err( "RTL did not properly execute, Reason: %s" % ( str( arg_ex )))
return False
finally:
pass
#return SysUtils.success( int(my_result[ RtlResult.process_retcode ]) )
return test_passed
def load_process_line(self, arg_line):
Msg.user("Process Result Line: %s" % (str(arg_line)), "SUM-TUPLE")
my_val = None
try:
my_glb, my_loc = SysUtils.exec_content(arg_line, True)
except SyntaxError as arg_ex:
return
except:
raise
# summary tuples are initialized in the __init__ as are the element indexes
# the idea is to the tuple list for a match on the key. When one is found
# the callback proc that is referenced is executed with the line dictionary
# retrieved and the flags are updated as to what this summary item contains
for (my_key, my_proc, my_mask) in self.sum_tups:
# Msg.user( "Key: %s, Proc: %s, Mask: %s" % (str( my_key ), str( my_proc is not None ) , (str( my_mask ))), "SUM-TUPLE" )
my_result = my_loc.get(my_key, None)
# Msg.user( "Key: %s, Result: %s" % ( str( my_key ), str( my_result )), "SUM-TUPLE" )
if my_result is None:
# nothing was returned continue causes the next element to be checked
# if there is a next element
continue
my_proc(my_result)
self.detail_flags |= int(my_mask)
break
return True
def load(self):
# Msg.dbg( "ForrestRun::load" )
my_frun_path = self.option_def(CmdLine.Switches[CmdLine.control_name],
None)
if my_frun_path is None:
raise Exception(
"F-Run Control File Not Found on the Forrest Run Command Line: Given Path: %s",
str((my_frun_path)))
# good to here
self.locate_frun(my_frun_path)
Msg.user("File Path: %s" % (my_frun_path))
my_content = open(self.frun_name).read()
my_glb, my_loc = SysUtils.exec_content(my_content)
Msg.dbg(str(my_loc))
self.fcontrol = my_loc["control_items"]
my_ctrl_dict = self.fcontrol[0]
my_ctrl_item = ControlItem()
my_ctrl_item.load(self._mAppsInfo, my_ctrl_dict)
# Msg.lout( my_ctrl_dict, "user", "Forrest Parent Data ...." )
self.check_simulator()
self.fctrl = ExecuteController(self._mAppsInfo)
self.fctrl.set_frun(self.frun_name)
self.fctrl.load(my_ctrl_item)
def iss_success(self):
if SysUtils.success(self.iss_retcode):
# Check to see for instruction overrun
if int(self.instr_count) < self.max_instr:
if int(self.instr_count) >= self.min_instr:
return True
return False
def execute(self):
try:
cmd = "make compile -C %s %s" % (self.mMakefilePath, self.mOptions)
Msg.user("Compile command = " + str({"compile-cmd": cmd}))
result = SysUtils.exec_process(cmd, self.log, self.elog,
self.ctrl_item.timeout, True)
Msg.user("Compile result = " + str(result))
except BaseException:
print(
"[CompileExecutor] problem in execute method: ",
sys.exc_info()[0],
)
raise
return SysUtils.success(int(result[0]))
def HMS(cls, arg_utcdt=None):
my_utcdt = SysUtils.ifthen(arg_utcdt is None, datetime.utcnow(),
arg_utcdt)
return "%0.2d%0.2d%0.2d" % (
my_utcdt.hour,
my_utcdt.minute,
my_utcdt.second,
)
def YMD(cls, arg_utcdt=None):
my_utcdt = SysUtils.ifthen(arg_utcdt is None, datetime.utcnow(),
arg_utcdt)
return "%0.4d%0.2d%0.2d" % (
my_utcdt.year,
my_utcdt.month,
my_utcdt.day,
)
