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 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 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 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 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, )
def YMD_HMS(cls, arg_utcdt=None): my_utcdt = SysUtils.ifthen(arg_utcdt is None, datetime.utcnow(), arg_utcdt) return "%0.4d%0.2d%0.2d-%0.2d%0.2d%0.2d" % ( my_utcdt.year, my_utcdt.month, my_utcdt.day, my_utcdt.hour, my_utcdt.minute, my_utcdt.second, )
def commit_simulate( self ): try: # check the return code for error 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: self.iss_result = "PASS" self.iss_level = SummaryLevel.Any return 1 self.iss_result = SysUtils.ifthen( self.signal_id is None, "FAIL", "INCOMPLETE" ) self.iss_level = SummaryLevel.Fail return 0 finally: pass
def process_groups(self, arg_ofile): my_total_count = 0 my_total_elapsed = 0 my_groups = self.groups.task_groups() # Msg.trace("PerformanceSummaryItem::process_groups") for my_group, my_items in my_groups.items(): try: my_str = "\nBegin Group: %s\n" % (my_group) arg_ofile.write(my_str) Msg.blank("info") Msg.info(my_str) my_grp_count, my_grp_elapsed = self.process_group_items( arg_ofile, my_items ) my_total_count += my_grp_count my_total_elapsed += my_grp_elapsed my_line = "\nGroup Instructions: %3d\n" % (my_grp_count) my_line += "Group Elapsed Time: %0.3f\n" % (my_grp_elapsed) my_line += "Group Instructions per Second: %0.3f\n" % ( SysUtils.ifthen( bool(my_grp_elapsed), my_grp_count / my_grp_elapsed, 0 ) ) my_line += "End Group: %s\n" % (my_group) Msg.info(my_line) arg_ofile.write(my_line) except Exception as arg_ex: Msg.error_trace() Msg.err( "Unable to process, Group: %s, Reason: %s" % (my_group, type(arg_ex)) ) return my_total_count, my_total_elapsed
def __init__(self, arg_options): # the HiThread has two states state 1 has no thread loop thus there is # no need for control to be halted to allow other thread processes to # continue, State 2 executes a loop until the shutdown sequence is # invoked which determines whether or not the thread a) has more work # to do, or b) will wait for another process to finished. A Thread will # remain in the shutdown sequence until the terminate flag is set. When # the terminate flag is set then the thread will execute the terminate # sequence. my_target = SysUtils.ifthen(arg_options.get("noloop", False), self.run_once, self.run_loop) super().__init__(name=arg_options.get("name", None), target=my_target) Msg.dbg("Created Thread[%s] Processing...." % (self.name)) # useful Thread events self.on_start = arg_options.get("on-start", None) self.on_execute = arg_options.get("on-execute", None) self.on_done = arg_options.get("on-done", None) self.on_shutdown = arg_options.get("on-shutdown", None) self.on_finished = arg_options.get("on-finished", None) # thread flags self.shutdown = False # shutdown request has been received self.finished = False # thread has completed all work and has exited # the thread heartbeat is set to write a debug message every 30 seconds # if the thread is waiting. I do not like the term blocking because # waiting is a more controlled event. The waiting thread asks for # permission to procees rather than the thread that is busy having to # create a block. Blocks are notorious for causing deadlock requiring # less than a graceful shutdown self.heartbeat_rate = arg_options.get("heartbeat-rate", 30) self.sleep_period = arg_options.get("sleep-period", 1000) self.current_tick = 0 # not a good idea to use daemons as a blanket rule, makes bad designs # seem to function but there are always underlying issues with these. # The daemon attribute exists in the abstract as does the handler. # Setting it here will ensure the thread acts as we expect self.daemon = arg_options.get("daemon", False) if arg_options.get("active", False): self.start_thread()
def TimeAsStr(arg_class, arg_utcdt=None): my_utcdt = SysUtils.ifthen(arg_utcdt is None, datetime.utcnow(), arg_utcdt) return str(my_utcdt.time())
def DateAsStr(cls, arg_utcdt=None): my_utcdt = SysUtils.ifthen(arg_utcdt is None, datetime.utcnow(), arg_utcdt) return str(my_utcdt.date())