def _get_hisi_log(self: any, info: any, err_i_folder: str) -> None: hisi_log_devid_path = os.path.join(self.collection.collect_bbox_path, Constant.DIR_BBOX, "device-" + info.dev_id) if not os.path.exists(hisi_log_devid_path): utils.print_warn_log( 'There is no hisi log for device_id(%s), the path=%s.' % (info.dev_id, hisi_log_devid_path)) return key_word = "device_id=%s, stream_id=%s, task_id=%s" % ( info.dev_id, info.stream_id, info.task_id) cmd = ['grep', key_word, '-nr', self.collection.collect_bbox_path] _, data = utils.execute_command(cmd) regexp = r"(%s.+?(\d+)-(\d+).+%s)" % ( self.collection.collect_bbox_path, 'ts.txt') ret = re.findall(regexp, data, re.M) if len(ret) == 0: utils.print_warn_log( "Failed to get hisi log for device_id(%s) stream_id(%s) " "task_id(%s), you may reboot and try again." % (info.dev_id, info.stream_id, info.task_id)) return # find the last time(max time) max_hisi_file_path = self._get_max_hisi_file_path(ret) utils.copy_file(max_hisi_file_path, os.path.join(err_i_folder, "ts.log"))
def _get_tiling_info(self, kernel_name) -> list: aic_info_cmd = [ 'grep', '-r', '-C', '7', "\[AIC_INFO\] dev_func:{}".format(kernel_name), self.collection.collect_applog_path ] _, aic_info = utils.execute_command(aic_info_cmd) aic_info_blockdim_regexp = r"\[AIC_INFO\]\sblock_dim:(\d+)" aic_info_blockdim_ret = re.findall(aic_info_blockdim_regexp, aic_info, re.M) if len(aic_info_blockdim_ret) == 0: utils.print_warn_log(f"Failed to get {aic_info_blockdim_regexp}") elif len(aic_info_blockdim_ret[0]) == 0: utils.print_info_log(f"get {aic_info_blockdim_regexp} is null") block_dim = "" else: block_dim = int(aic_info_blockdim_ret[0][0]) aic_info_tiling_data_regex = r"\[AIC_INFO\]\stiling_data:(.*?)" aic_info_tiling_data_ret = re.findall(aic_info_tiling_data_regex, aic_info, re.M) if len(aic_info_tiling_data_ret) == 0: utils.print_warn_log(f"Failed to get {aic_info_tiling_data_regex}") elif len(aic_info_tiling_data_ret[0]) == 0: utils.print_info_log(f"get {aic_info_tiling_data_regex} is null") tiling_data = "" else: tiling_data = bytes(aic_info_tiling_data_ret[0][0], encoding="utf-8") return (block_dim, tiling_data)
def collect_local_file(report_path: str, key: str, collect_path: str) -> str: """ collect local file: :param report_path: the local report path :param key: the key in slog_conf_path :param collect_path: the collect path :return: the local path """ collect_target_path = os.path.join(collect_path, os.path.basename(report_path)) utils.check_path_valid(collect_target_path, isdir=True, output=True) if key == Constant.DIR_SLOG: slog_report_path = os.path.join(report_path, key) if os.path.exists(slog_report_path) and \ os.path.isdir(slog_report_path): copy_file_to_dest(slog_report_path, key, collect_target_path, report_path) else: utils.print_error_log('There is no %s in %s.' % (key, report_path)) raise utils.AicErrException( Constant.MS_AICERR_INVALID_SLOG_DATA_ERROR) elif key == 'MNTN_PATH': collect_target_path = os.path.join(collect_path, os.path.basename(report_path)) utils.check_path_valid(collect_target_path, isdir=True, output=True) hisi_report_path = os.path.join(report_path, Constant.DIR_BBOX) if os.path.exists(hisi_report_path) and \ os.path.isdir(hisi_report_path): copy_file_to_dest(hisi_report_path, Constant.DIR_BBOX, collect_target_path, report_path) else: utils.print_warn_log('There is no hisi_logs in %s.' % report_path) return collect_target_path
def _save_tensor_to_file(self: any, tensor_list: list, tensor_type: str, dump_file: str) -> str: result_info = '' if len(tensor_list) == 0: utils.print_warn_log( 'There is no %s in "%s".' % (tensor_type, dump_file)) return result_info dump_file_path, _ = os.path.split(dump_file) for (index, tensor) in enumerate(tensor_list): try: array = np.frombuffer(tensor.data, dtype=self._get_dtype_by_data_type( tensor.data_type)) npy_file_name = ".".join([self.kernel_name, tensor_type, str(index), "npy"]) np.save(os.path.join(dump_file_path, npy_file_name), array) if (np.isinf(array).any() or np.isnan(array).any()) and tensor_type == "input": result_info += '%s[%d] NaN/INF\n' % (tensor_type, index) utils.print_error_log('%s[%d] NaN/INF\n' % (tensor_type, index)) raise utils.AicErrException( Constant.MS_AICERR_INVALID_DUMP_DATA_ERROR) except (ValueError, IOError, OSError, MemoryError) as error: utils.print_error_log('Failed to parse the data of %s:%d of "%s". %s' % ( tensor_type, index, dump_file, error)) raise utils.AicErrException( Constant.MS_AICERR_INVALID_DUMP_DATA_ERROR) finally: pass return result_info
def copy_kernel_meta(self, report_path: str, collect_compile_path: str, kernel_name: str) -> bool: """ collect local dump file: :param report_path: the local compile path :param collect_compile_path: the collect compile path :param kernel_name: the kernel name """ match = False kernel_meta_path = os.path.join(self.report_path, "extra-info", "ops") if os.path.exists(kernel_meta_path): for root, _, names in os.walk(kernel_meta_path): for name in names: if name.startswith(kernel_name): src = os.path.join(root, name) collect_kernel_meta_path = os.path.join( collect_compile_path, "kernel_meta") utils.check_path_valid(collect_kernel_meta_path, isdir=True, output=True) dest = os.path.join(collect_kernel_meta_path, name) utils.copy_file(src, dest) match = True if not match: utils.print_warn_log('There is no kernel_meta file for "%s" in %s.' % (kernel_name, report_path)) return match
def _get_occur_before_mark(decompile_file: str, diff_str: str, info: any) -> bool: # 504: 04c20000 ST.b64 X1, [X0], #0 with open(decompile_file, "r") as fo_file: text = fo_file.read() regexp = r'(^\s+(\S+):\s+\S+\s+\S.+$)' ret = re.findall(regexp, text, re.M) find_i = -1 for i, (_, line_diff) in enumerate(ret): if line_diff == diff_str: find_i = i break if find_i == -1: utils.print_warn_log( "Get fault instruction failed, file(%s) diff(%s)" % (decompile_file, diff_str)) return False begin_i = 0 if find_i < 9 else find_i - 9 instr_str_list = [] for i in range(begin_i, find_i + 1): instr_str_list.append(ret[i][0] + "\n") instr_str = "".join(instr_str_list).strip("\n") info.instr += "\nrelated instructions (error occured before the mark *):\n\n" info.instr += instr_str[:instr_str.rfind('\n') + 1] + '*' info.instr += instr_str[instr_str.rfind('\n') + 2:] info.instr += "\n\nFor complete instructions, please view %s" % decompile_file return True
def _get_aicerror_args(data): regexp = r"(\d+-\d+-\d+-\d+:\d+:\d+\.\d+\.\d+).+?device\((\d+)\),.*?core id is (\d+),\s+error code = (\S+)," \ r".*?pc start:\s(\S+),\scurrent:\s(\S+),\svec error info:\s(\S+),\smte error info:\s(\S+)," \ r"\sifu error info:\s(\S+),\sccu error info:\s(\S+),\scube error info:\s(\S+)," \ r"\sbiu error info:\s(\S+),\saic error mask:\s(\S+),\spara base:\s(\S+)." ret = re.findall(regexp, data, re.M | re.S) if len(ret) == 0: utils.print_warn_log( "aic error info does not match in plog \"aicore kernel execute failed\"") return None return ret
def _get_imas_log(self: any) -> None: imas_log_file = os.path.join(self.output_path, "imas.log") cmd = ['grep', 'IMAS', '-nr', self.collection.collect_applog_path] utils.print_info_log('Start to analyze IMAS log.') status, data = utils.execute_command(cmd) if status == 1: utils.print_warn_log("There is no IMAS log in %s" % self.output_path) return if status != 0: utils.print_error_log("Failed to execute command: %s. %s" % (" ".join(cmd), " ".join(data))) raise utils.AicErrException( Constant.MS_AICERR_EXECUTE_COMMAND_ERROR) utils.write_file(imas_log_file, data) utils.print_info_log('The IMAS log is saved in %s.' % imas_log_file)
def _get_cce_tbe_code_number(self: any, decompile_file: str, loc_json_file: str, err_pc: str, info: any) -> bool: # txt code to cce number if os.path.exists(decompile_file) is False: utils.print_error_log("The decompile file does not exist.") return False if err_pc != "": cce_code_num = self._read_decompile_file(decompile_file, err_pc, info) # cce to tbe code number if os.path.exists(loc_json_file) is False: utils.print_warn_log("file %s not exist" % loc_json_file) return False self._read_loc_json_file(loc_json_file, cce_code_num, info) return True
def _get_node_name_by_kernel_name(self: any, kernel_name: any) -> str: """ get node name by kernel name :param kernel_name: :return: node_name """ node_name = '' aic_info_cmd = ['grep', '-r', '-C', '7', "\[AIC_INFO\] dev_func:{}".format(kernel_name), self.collect_applog_path] _, aic_info = utils.execute_command(aic_info_cmd) aic_info_dev_func_regex = r"\[AIC_INFO\]\snode_name:(.*?)," aic_info_dev_func_ret = re.findall(aic_info_dev_func_regex, aic_info) if len(aic_info_dev_func_ret) == 0: utils.print_warn_log("Failed to get node name by kernel name.") return node_name node_name = aic_info_dev_func_ret[0] return node_name
def _decompile(self: any, kernel_info: list, dir_path: str, info: any) -> bool: kernel_name = kernel_info[0] kernel_meta_path = kernel_info[1] diff_str, err_pc = self._get_info_for_decompile(info) # decompile .o file cce_file = os.path.join(kernel_meta_path, kernel_name + ".cce") if os.path.exists(cce_file) is False: utils.print_warn_log(".cce file %s not exist" % cce_file) else: utils.copy_file(cce_file, os.path.join(dir_path, kernel_name + ".cce")) # decompile .o file o_file = os.path.join(kernel_meta_path, kernel_name + ".o") if os.path.exists(o_file) is False: utils.print_warn_log(".o file %s not exist" % o_file) return False utils.copy_file(o_file, os.path.join(dir_path, kernel_name + ".o")) utils.copy_file(o_file, os.path.join(dir_path, kernel_name + ".json")) decompile_file_name = kernel_name + ".o.txt" decompile_file = os.path.join(dir_path, decompile_file_name) status = self._get_decompile_status(o_file, decompile_file) if status != 0: utils.print_error_log( "Failed to decompile %s, you can fix problem according to the " "message above, or copy %s and %s to another host and execute : " "%s -d -mcpu=%s %s > %s" % (o_file, Constant.OBJ_DUMP_FILE, o_file, Constant.OBJ_DUMP_FILE, "dav-m100", kernel_name + ".o", decompile_file_name)) return False loc_json_file = os.path.join(kernel_meta_path, kernel_name + "_loc.json") self._get_cce_tbe_code_number(decompile_file, loc_json_file, err_pc, info) self._get_occur_before_mark(decompile_file, diff_str, info) return True
def _get_graph_file(self: any) -> any: match_list = [] for top, _, files in os.walk(self.collection.collect_compile_path): for name in files: file_name_pattern = re.compile( Constant.BUILD_PROTO_FILE_PATTERN) pattern_match = file_name_pattern.match(name) if pattern_match: match_list.append( (pattern_match.group(1), os.path.join(top, name))) if len(match_list) == 0: utils.print_warn_log('There is no graph file in %s.' % self.collection.collect_compile_path) return '' new_match_list = sorted(match_list, key=lambda s: s[0], reverse=True) choose_file = new_match_list[0][1] utils.print_info_log('Choose %s to read op info.' % choose_file) return choose_file
def _get_node_and_kernel_name(self: any, dev_id: any, task_id: any, stream_id: any, err_time: any) -> tuple: data = self._get_node_and_kernel_name_execute_command() regexp = r"(\d+-\d+-\d+-\d+:\d+:\d+\.\d+\.\d+).+?device_id=\d+\s*,\s*stream_id=" \ r"%s\s*.+?\s*task_id=%s\s*,\s*fault kernel_name=" \ r"[-\d_]{0,}(\S+?),\s*func_name=(\S+)__kernel\d+" % ( stream_id, task_id) ret = re.findall(regexp, data, re.M | re.S) if len(ret) == 0: utils.print_warn_log( "There is no node name and kernel name for dev id(%s) " "task id(%s) stream id(%s) in plog." % (dev_id, task_id, stream_id)) return '', '' if len(ret) > 1: max_i = self._get_the_latest_aicerr_form_ret(ret, err_time) return ret[max_i][1:] return ret[0][1:]
def copy_file_to_dest(log_path: str, target: str, collect_target_path: str, report_path: str) -> None: """ copy file to dest: :param log_path: the local log path :param target: the target in log :param collect_target_path: the collect path :param report_path: the local report path """ match = False for top, _, files in os.walk(log_path): for name in files: src = os.path.join(top, name) dest = os.path.join(collect_target_path, top[len(report_path) + 1:], name) utils.copy_file(src, dest) match = True if not match: utils.print_warn_log( 'There is no %s file in %s.' % (target, report_path))
def _analyse_op_graph(info: any, input_output_addrs: list) -> None: # 分析图op信息 if info.operator: regexp = r'input_desc\s+\{\s+dtype:\s+(\S+).+?\s+size:\s+(\d+)' input_ret = re.findall(regexp, info.operator, re.M | re.S) regexp = r'output_desc\s+\{\s+dtype:\s+(\S+).+?\s+size:\s+(\d+)' output_ret = re.findall(regexp, info.operator, re.M | re.S) if len(input_ret) + len(output_ret) != len(input_output_addrs): utils.print_warn_log( 'The number(%d) of input/output in logs does not match with' ' that(%d) in graph.' % (len(input_output_addrs), len(input_ret) + len(output_ret))) for i in input_output_addrs: ret = input_ret if i.is_input else output_ret if i.idx <= len(ret) - 1: rec = ret[i.idx] i.dtype = rec[0] # DT_FLOAT i.size = int(rec[1]) # bytes
def _get_op_by_graph(graph_file: str, info: any) -> None: if graph_file == '': return try: with open(graph_file, 'r') as graph: text = graph.read() regexp = r'(op\s+\{\s+name:\s+"%s".+?%s.+?\})\s+' \ r'op\s+\{' % (info.node_name, info.kernel_name) ret = re.findall(regexp, text, re.M | re.S) if len(ret) == 0: utils.print_warn_log( 'Failed to get op for node(%s) kernel(%s).' % (info.node_name, info.kernel_name)) return info.operator = ret[0] except IOError as io_error: utils.print_error_log('Failed to open file %s. %s' % (graph_file, io_error)) raise utils.AicErrException(Constant.MS_AICERR_OPEN_FILE_ERROR) finally: pass
def collect_remote_file(report_path: str, key: str, collect_path: str) -> str: """ collect local file: :param report_path: the local report path :param key: the key in slog_conf_path :param collect_path: the collect path :return: the local path """ collect_target_path = os.path.join(collect_path, os.path.basename(report_path)) utils.check_path_valid(collect_target_path, isdir=True, output=True) if key == Constant.DIR_SLOG: slog_report_path = os.path.join(report_path, "log", "device", "firmware") if os.path.exists(slog_report_path) and \ os.path.isdir(slog_report_path): copy_file_to_dest(slog_report_path, key, collect_target_path, report_path) else: utils.print_error_log( 'There is no %s in %s.' % (key, report_path)) elif key == 'MNTN_PATH': hisi_report_path = os.path.join(report_path, "log", "device", "system") if os.path.exists(hisi_report_path) and \ os.path.isdir(hisi_report_path): copy_file_to_dest(hisi_report_path, Constant.DIR_BBOX, collect_target_path, report_path) else: utils.print_warn_log( 'There is no hisi_logs in %s.' % report_path) elif key == Constant.DIR_PLOG: plog_path = os.path.join(report_path, "log", "host", "cann") if os.path.exists(plog_path) and \ os.path.isdir(plog_path): copy_file_to_dest(plog_path, Constant.DIR_PLOG, collect_target_path, report_path) else: utils.print_warn_log( 'There is no plog in %s.' % report_path) return collect_target_path
def copy_proto_file(self, report_path: str, collect_compile_path: str) -> bool: """ copy proto file: :param report_path: the local compile path :param collect_compile_path: the collect compile path """ match = False proto_path = os.path.join(self.report_path, "extra-info", "graph") for root, _, names in os.walk(report_path): for name in names: file_name_pattern = re.compile(Constant.BUILD_PROTO_FILE_PATTERN) pattern_match = file_name_pattern.match(name) if pattern_match: src = os.path.join(root, name) dest = os.path.join(collect_compile_path, name) utils.copy_file(src, dest) match = True if not match: utils.print_warn_log('There is no graph file in %s.' % report_path) return match
def parse(self: any) -> str: """ Function Description: dump data parse. """ # 1. check arguments valid self.check_arguments_valid() match_name = "".join(['.', self.op_name.replace('/', '_'), '.']) match_dump_list = [] for top, _, files in os.walk(self.input_path): for name in files: if match_name in name: match_dump_list.append(os.path.join(top, name)) result_info_list = [] for dump_file in match_dump_list: result_info_list.extend(['%s\n' % dump_file, self.parse_dump_data(dump_file)]) result_info = "".join(result_info_list) if len(match_dump_list) == 0: utils.print_warn_log('There is no dump file for "%s". Please ' 'check the dump path.' % self.op_name) utils.print_info_log(f"Parse dump file finished,result_info:{result_info}") return result_info
def _get_input_output_addrs(self: any, info: any, err_i_folder: str, alloc_addr: str, actual_addr: str) -> list: ret = self._get_input_output_addrs_cmd_process(info, err_i_folder) if len(ret) == 0: utils.print_warn_log('Failed to get input address and output ' 'address for %s.' % info.node_name) return [] # get the last value flags = {} for _, (time_str, flag, addr) in enumerate(ret): time_obj = utils.strplogtime(time_str) if flag in flags and time_obj <= flags.get(flag)[0]: continue flags[flag] = [time_obj, flag, addr] input_output_addrs = [] for _, (time_obj, flag, addr) in enumerate(flags.values()): op_io = OpInputOutput() op_io.name = flag # 'input[0]' op_io.addr = addr op_io.idx = int(flag[flag.find('[') + 1:flag.find(']')]) op_io.is_input = flag.lower().startswith("input") input_output_addrs.append(op_io) # 获取真实地址 if addr in actual_addr: op_io.actual_addr = actual_addr[addr] # 分析图op信息 self._analyse_op_graph(info, input_output_addrs) # 检查地址是否越界 if len(alloc_addr) > 0: self._analyse_alloc_addr_range(alloc_addr, input_output_addrs) return input_output_addrs
def parse(self: any) -> None: """ parse by collection info """ utils.print_info_log('******************Analysis******************') aicore_error_data_list = self._aicore_error_data() utils.print_info_log('Start to analyze each ai core error.') summary_info_list = [] # decompile if "aarch64" in platform.machine(): obj_dump_file = "cce-objdump_aarch64" else: obj_dump_file = "cce-objdump" obj_dump_file = os.path.join(os.getcwd(), "tools", obj_dump_file) if os.path.exists(obj_dump_file): os.system("chmod 755 " + obj_dump_file) os.environ["PATH"] = os.path.join( os.getcwd(), "tools") + ":" + os.environ["PATH"] else: cce_dump = shutil.which("cce-objdump") if not cce_dump: # guess where is cce-objdump parent_path = "aarch64-linux" if "aarch64" in platform.machine( ) else "x86_64-linux" cce_dump_guess = os.path.join("usr/local/Ascend/latest", parent_path, "ccec_compiler/bin/cce-objdump") if os.path.exists(cce_dump_guess): cce_dump = cce_dump_guess if not cce_dump: utils.print_error_log( 'Cannot find cce-objdump! please add cce-objdump path in env PATH.' ) raise utils.AicErrException( Constant.MS_AICERR_EXECUTE_COMMAND_ERROR) for i, current_pc in enumerate(self.collection.ai_core_error_list): # parser aic error by slog info = AicErrorInfo() info.err_time, info.dev_id, info.stream_id, info.task_id, \ info.core_id, info.aic_error, info.start_pc, info.extra_info, \ info.current_pc = current_pc utils.print_info_log( "******************No.%d %s******************" % (i, info.err_time)) info.err_time_obj = utils.strplogtime(info.err_time) err_i_folder_name = "aicerror_%d_%s" % ( i, time.strftime("%Y%m%d%H%M%S", info.err_time_obj.timetuple())) err_i_folder = os.path.join(self.output_path, err_i_folder_name) utils.check_path_valid(err_i_folder, isdir=True, output=True) info.node_name = self.collection.node_name_list[i] info.kernel_name = self.collection.kernel_name_list[i] # get hisi log self._get_hisi_log(info, err_i_folder) # get op info in build proto file self._get_op_by_graph(aicore_error_data_list[Constant.GRAPH_FILE], info) kernel_meta_path = os.path.join( self.collection.collect_compile_path, 'kernel_meta') if os.path.exists(kernel_meta_path): # 反编译 出错指令 result = self._decompile([info.kernel_name, kernel_meta_path], err_i_folder, info) if result is False: utils.print_warn_log( "decompile kernel_meta file %s failed." % os.path.join( kernel_meta_path, info.kernel_name + ".o")) else: utils.print_warn_log("kernel_meta path %s not exist" % kernel_meta_path) try: # input output address info.aval_addrs = self._get_available_addrs(info.err_time) info.necessary_addr = self._get_necessary_addrs( info.kernel_name) self._check_addr(info.aval_addrs, info.necessary_addr) # self.print_summary(avl_addr, necessary_addr) except BaseException as e: import logging logging.exception(e) print("Check addr error failed") info.input_output_addrs = self._get_input_output_addrs( info, err_i_folder, aicore_error_data_list[Constant.ALLOC_ADDR], aicore_error_data_list[Constant.ACTUAL_ADDR]) # 地址越界信息收集 info.addr_overflow = aicore_error_data_list[Constant.ADDR_OVERFLOW] # 算子代码地址,args地址 info.op_addr, info.args_addr, info.multi_args_addr = \ self._get_op_and_args_addr(info.start_pc) # parse dump if self.collection.collect_dump_path: parser = DumpDataParser(self.collection.collect_dump_path, info.node_name, info.kernel_name) info.dump_info = parser.parse() # write info file self._write_errorinfo_file(err_i_folder, info, i) summary_info_list.append( "%s %s device_id=%s core_id=%s task_id=%s node=%s " "kernel=%s" % (err_i_folder_name, info.aic_error, info.dev_id, info.core_id, info.task_id, info.node_name, info.kernel_name)) utils.print_info_log('Finish to analyze each ai core error.') # write summary info self._write_summary_file(summary_info_list)
def _get_necessary_addrs(self: any, kernal_name: str) -> list: ''' 获取occur_time时刻可用的地址 :param kernal_name: 发生aicore error的kernal_name :return: 需要的空间 ''' result = {} aic_info_cmd = [ 'grep', '-r', '-C', '7', "\[AIC_INFO\] dev_func:{}".format(kernal_name), self.collection.collect_applog_path ] _, aic_info = utils.execute_command(aic_info_cmd) utils.print_info_log( "===============================\n{}\n==================================" .format(aic_info)) aic_info_all_regexp = r"\[AIC_INFO\]\snode_name:(.*?),\snode_type:(.*?),\sstream_id:(\d+),\stask_id:(\d+)" aic_info_all_ret = re.findall(aic_info_all_regexp, aic_info, re.M) if len(aic_info_all_ret) == 0: utils.print_warn_log( "Failed to get [AIC_INFO]\snode_name(.*?),\snode_tye(.*?),\sstream_id:(\d+),\stask_id:(\d+)" ) return node_name = aic_info_all_ret[0][0] node_type = aic_info_all_ret[0][1] stream_id = aic_info_all_ret[0][2] task_id = aic_info_all_ret[0][3] aic_info_input_regexp = r"\[AIC_INFO\]\sinput:(.*?);shape:(.*?);format:(.*?);dtype:(.*?);addr:(.*?)$" aic_info_input_ret = re.findall(aic_info_input_regexp, aic_info, re.M) if len(aic_info_input_ret) == 0: utils.print_warn_log( "Failed to get [AIC_INFO]\sinput:(.*?);shape(.*?);format:(.*?);dtype(.*?);addr:(.*?)" ) return input_params = [] for input_info in aic_info_input_ret: input_param = {} input_param["index"] = input_info[0] input_param["shape"] = input_info[1] input_param["format"] = input_info[2] input_param["dtype"] = input_info[3] input_param["addr"] = input_info[4] input_params.append(input_param) aic_info_output_regexp = r"\[AIC_INFO\]\soutput:(.*?);shape:(.*?);format:(.*?);dtype:(.*?);addr:(.*?)$" aic_info_output_ret = re.findall(aic_info_output_regexp, aic_info, re.M) if len(aic_info_output_ret) == 0: utils.print_warn_log( "Failed to get [AIC_INFO]\soutput:(.*?);shape(.*?);format:(.*?);dtype(.*?);addr:(.*?)" ) return output_params = [] for output_info in aic_info_output_ret: output_param = {} output_param["index"] = output_info[0] output_param["shape"] = output_info[1] output_param["format"] = output_info[2] output_param["dtype"] = output_info[3] output_param["addr"] = output_info[4] output_params.append(output_param) aic_info_blockdim_regexp = r"\[AIC_INFO\]\sblock_dim:(\d+)" aic_info_blockdim_ret = re.findall(aic_info_blockdim_regexp, aic_info, re.M) if len(aic_info_blockdim_ret) == 0: utils.print_warn_log(f"Failed to get {aic_info_blockdim_regexp}") elif len(aic_info_blockdim_ret[0]) == 0: utils.print_info_log(f"get {aic_info_blockdim_regexp} is null") block_dim = "" else: block_dim = int(aic_info_blockdim_ret[0][0]) aic_info_workspace_regex = r"\[AIC_INFO\]\sworkspace_bytes:(.*?)" aic_info_workspace_ret = re.findall(aic_info_workspace_regex, aic_info, re.M) if len(aic_info_workspace_ret) == 0: utils.print_warn_log(f"Failed to get {aic_info_workspace_regex}") elif len(aic_info_workspace_ret[0]) == 0: utils.print_info_log(f"get {aic_info_workspace_regex} is null") workspace = "0" else: workspace = aic_info_workspace_ret[0][0] aic_info_dev_func_regex = r"\[AIC_INFO\]\sdev_func:(.*?)" aic_info_dev_func_ret = re.findall(aic_info_dev_func_regex, aic_info, re.M) aic_info_tvm_magic_regex = r"\[AIC_INFO\]\stvm_magic:(.*?)" aic_info_tvm_magic_ret = re.findall(aic_info_tvm_magic_regex, aic_info, re.M) aic_info_kernel_info_regex = r"\[AIC_INFO\]\skernel_info:(.*?)" aic_info_kernel_info_ret = re.findall(aic_info_kernel_info_regex, aic_info, re.M) aic_info_tiling_key_regex = r"\[AIC_INFO\]\stiling_key:(.*?)" aic_info_tiling_key_ret = re.findall(aic_info_tiling_key_regex, aic_info, re.M) aic_info_tiling_data_regex = r"\[AIC_INFO\]\stiling_data:(.*?)" aic_info_tiling_data_ret = re.findall(aic_info_tiling_data_regex, aic_info, re.M) if len(aic_info_tiling_data_ret) == 0: utils.print_warn_log(f"Failed to get {aic_info_tiling_data_regex}") elif len(aic_info_tiling_data_ret[0]) == 0: utils.print_info_log(f"get {aic_info_tiling_data_regex} is null") tiling_data = "" else: tiling_data = bytes(aic_info_tiling_data_ret[0][0], encoding="utf-8") aic_info_op_file_path_regex = r"\[AIC_INFO\]\sop_file_path:(.*?)" aic_info_op_file_path_ret = re.findall(aic_info_op_file_path_regex, aic_info, re.M) result["input_addr"] = input_params result["output_addr"] = output_params result["workspace"] = workspace return result