#! /usr/bin/env python3 """Provide compiler related tools.""" import os import pathlib import tempfile import shutil import re import json from collections import OrderedDict from functools import lru_cache import numpy as np import sys_flow_v2.flow_constants as fconsts import sys_flow_v2.flow_utils as futils import snoop DEBUG = True if os.environ.get("REGRESSION_DEBUG", False) else False snoop.install(enabled=DEBUG) # constants P_TMP_MODEL = pathlib.Path("/tmp/model_working") P_TMP_INPUT = pathlib.Path("/tmp/input_data") def get_nef_util_bins(): """Get binaries to use.""" bin_nef_util = fconsts.BIN_SET["compiler"]["kneron_nef_utils"] bin_kne_util = fconsts.BIN_SET["compiler"]["kneron_kne_utils"] pb_nef = pathlib.Path(bin_nef_util).parent pb_kne = pathlib.Path(bin_kne_util).parent ADD_NEF_UTIL_PATH = f"""export PATH={pb_nef}:{pb_kne}:$PATH""" return ADD_NEF_UTIL_PATH, bin_nef_util, bin_kne_util ADD_NEF_UTIL_PATH, bin_nef_util, bin_kne_util = get_nef_util_bins() ################################################################################### # get model info from nef + ioinfo.json ################################################################################### def clean_list_nef(list_nef): """Convert to str and make uniq.""" # convert to str. it may be pathlib obj l1 = [str(nef) for nef in list_nef] # make unique l2 = list(set(l1)) return " ".join(l2) def combine_nef(list_nef: list, hw_mode, d_out): """Combine multiple nef into one using nef utils. After combination, the combined.nef will run extra `unpack_nefs()` and re-organized with `ioinfo.json` per model. This side-effect is prepared a combined `ioinfo.json` for dongle inference. Args: list_nef (list): each element is path to nef file. hw_mode (int): specify platform. d_out (pathlib / str) : where to put `combined.nef` and `ioinfo.json` Returns: tuple: multiple info returned: - `p_out`: where is the out folder. usually same as specified. - `p_nef`: path of the combined nef - `p_ioinfo`: path of the (combined) ioinfo.json, prepared for dongle, not for normal process! - `fn_maps`: the combined.nef is unpacked and re-organized in `p_out/unpack`. Per-model file mapping is recorded in this. Same as `unpack_nefs()` returned. """ temp_dir = tempfile.mkdtemp() lst = clean_list_nef(list_nef) cmd = f"{ADD_NEF_UTIL_PATH}; {bin_nef_util} --combine_nef \"{lst}\" -O {temp_dir}" # currently no -o option working. we need to cpy $temp_dir/models_xxx.nef to fn_out cp = futils.run_bash_script(cmd) assert cp.returncode == 0, f"extract nef failed with return code: {cp.returncode}" # check output p_temp = pathlib.Path(temp_dir) nefs = list(p_temp.glob("models_*.nef")) assert len(nefs) == 1, f"combine nef but find {len(nefs)} created: {nefs}" # copy necessary files to p_out p_out = pathlib.Path(d_out) p_out.mkdir(parents=True, exist_ok=True) p_nef = p_out / "combined.nef" shutil.copyfile(nefs[0], p_nef) # prepare ioinfo (for convience of dongle) dongle_io = {} fn_maps, p_dump = unpack_nefs(p_nef, hw_mode) for model_id, (p_unpack, ioinfo) in fn_maps.items(): dongle_io[model_id] = {} dongle_io[model_id]["ioinfo_in"] = ioinfo["input"] dongle_io[model_id]["ioinfo_out"] = ioinfo["output"] p_ioinfo = p_out / "ioinfo.json" with open(p_ioinfo, "w") as f: json.dump(dongle_io, f, cls=NumpyEncoder) shutil.rmtree(temp_dir, ignore_errors=True) return p_out, p_nef, p_ioinfo, fn_maps def guess_available_model_id(p_dump, hw_mode): """Guess model_id from extracted filenames from NEF. NOTE: if the nef is from regression, it will have dfault model_id 32768. Args: p_dump (pathlib / str): where the nef was extracted to. hw_mode (int): specify the platform. Returns: tuple: list of model_id available in givem dump folder. """ if hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: # 540/730/1140 s1 = f"models_{hw_mode}_model_*.kne" s2 = rf"models_{hw_mode}_model_(\d+).kne" else: s1 = "NEF_*modelid_*" s2 = r'NEF_.*?_modelid_(\d+)_.*$' p_nefs = pathlib.Path(p_dump).glob(s1) p_names = [p.name for p in p_nefs] modelids = [] for name in p_names: modelids.extend(re.findall(s2, name)) ids = tuple(set([int(a) for a in modelids])) return ids def verify_ioinfo(ioinfo, nef_version): """Verify ioinfo got enought quantization info.""" missing = False for k1 in ["input", "output"]: if DEBUG: print(f"ioinfo got {len(ioinfo[k1])} {k1}(s).") for i_info, info in enumerate(ioinfo[k1]): for k2 in ["name", "shape", "onnx_shape", "ch_dim", "radix", "scale", "bitw", "data_format"]: if k2 not in info: print(f"Error: {k1}/{i_info} is missing {k2}") missing = True assert not missing def convert_ioinfo(p_sub, hw_mode): """Load ioinfo from io_raw, then save to ioinfo.json . This is a wrapper function to call correct parser according to hw_mode. """ if hw_mode in fconsts.MODE_HW_LIMIT["nef_v0"]: # 520, or 720 pure bin (obsolete) # BUG: only per-layer quantization info # BUG: only sim shape. (no onnx shape. no dimension transpose in sim shape though.) fn_json_raw = list(p_sub.glob("*_setup.bin.json"))[0] ioinfo = parse_setup_json_v0(fn_json_raw) nef_version = 0 elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v1"]: fn_json_raw = list(p_sub.glob("*_setup.bin.json"))[0] ioinfo = parse_setup_json_v1(fn_json_raw) nef_version = 1 elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: # 540/730/1140 # .no_binary.json is from unpack_nefs (during toolchain/inference_csim*) # or from debug version of compiler running. # or kneron_kne_utils -j to extract from release version of compiler fn_json_raw = find_no_binary_json(p_sub) ioinfo = parse_setup_json_v2(fn_json_raw) nef_version = 2 verify_ioinfo(ioinfo, nef_version) fn_ioinfo = p_sub / "ioinfo.json" ioinfo["note"] = f"created by `convert_ioinfo()` from {fn_json_raw}" with open(fn_ioinfo, "w") as f: json.dump(ioinfo, f, cls=NumpyEncoder) return ioinfo def check_kne_util_err(cp, p_kne): """Examine kne_util reported error code to find error detaiils.""" if cp.returncode == 0: return elif cp.returncode == 100: raise FileNotFoundError(f"Given {p_kne} does not exist or file size is 0.") elif cp.returncode == 101: raise PermissionError(f"Failed to read {p_kne}. Please check this file.") elif cp.returncode == 102: raise ValueError(f"Given {p_kne} does not compatible with current schema.") else: raise ChildProcessError(f"kne_util failed with {cp.returncode} .") def find_no_binary_json(p_sub): """Better way to find .no_binary.json . TODO: - what if multiple kne is same folder? """ fn_json_raw = list(p_sub.glob("*.no_binary.json")) if len(fn_json_raw) == 0: # need to extrtact from kne # release version compiler will not create .no_binary.json . p_kne_s = list(p_sub.glob("models_*.kne")) if len(p_kne_s) == 0: raise FileExistsError(f"No models_*.kne and no .no_binary.json found in {p_sub} .") cmd = f"{ADD_NEF_UTIL_PATH}; pushd {p_sub} >> /dev/null && {bin_kne_util} -j {p_kne_s[0].name}" cp = futils.run_bash_script(cmd) check_kne_util_err(cp, p_kne_s[0]) fn_json_raw = list(p_sub.glob("*.no_binary.json")) if len(fn_json_raw) == 0: raise FileExistsError(f"Failed to extract .no_binary.json from {p_kne_s[0].name} .") return fn_json_raw[0] def kne2nef(p_kne, p_nef, hw_mode): """Convert given kne file to nef.""" hw_mode = int(hw_mode) hw_nef_v2 = fconsts.MODE_HW_LIMIT["nef_v2"] assert hw_mode in hw_nef_v2, f"hw_mode ({hw_mode}) must be in {hw_nef_v2}" # model_info using "test" for place holder. toolchain will use actual values. cmd = f"""{ADD_NEF_UTIL_PATH}; {bin_nef_util} --gen --kne {p_kne} --target {hw_mode} -O {p_nef.parent} -o {p_nef.stem} && {bin_nef_util} -U {p_nef} --model_info_version "test" --model_info_name "test" --replace_original """ cp = futils.run_bash_script(cmd) assert cp.returncode == 0, f"convert kne to nef failed with return code: {cp.returncode}." return cp def unpack_nefs(p_nef, hw_mode): """Parse nef to get compiler outputs for csim inference. Ref: `ticket #17762`_ Args: p_nef (pathlib or str): path to the nef file, which may include multiple models. hw_mode (int): specify the platform (520/530/540/630/720/730/1140/etc), because the way to call nef_utils are different. Returns: dict-type: example: `{model_id: (p_sub, ioinfo)}`. - The `model_id` is unique for each released model. - `p_sub` is where the model for `model_id` is unpacked, - the `ioinfo` includes the shape and quantization info of input/output nodes. It will be used to convert input data to bin file as csim/dongle input. .. _ticket #17762: https://redmine.kneron.tw/issues/17762 """ p_out = pathlib.Path(tempfile.mkdtemp(prefix="nef_unpack_")) if hw_mode in fconsts.MODE_HW_LIMIT["nef_v0"]: # 520, or 720 pure bin (obsolete) nef_version = 0 cmd = f"{ADD_NEF_UTIL_PATH}; {bin_nef_util} -X {pathlib.Path(p_nef).absolute()} --keep_all -s -p {hw_mode} -O {p_out}" elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v1"]: # 720/530/630 flatbuffer nef_version = 1 cmd = f"{ADD_NEF_UTIL_PATH}; {bin_nef_util} -X {pathlib.Path(p_nef).absolute()} --keep_all -s -O {p_out}" elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: # 540/730/1140 # 1 nef -> 1 kne (incl multiple models) nef_version = 2 cmd = f"""set -e; {ADD_NEF_UTIL_PATH}; {bin_nef_util} -X {pathlib.Path(p_nef).absolute()} --keep_all -O {p_out} && pushd {p_out} >> /dev/null && {bin_kne_util} -X NEF_0x*_models_{hw_mode}.kne && for k in `ls models_{hw_mode}_model_*.kne` do {bin_kne_util} -j ${{k}} done """ else: raise NotImplementedError # extract nef file cp = futils.run_bash_script(cmd) if DEBUG: print(f"unpack nef (version {nef_version}) to {p_out}") print(cp.stderr) assert cp.returncode == 0, f"extract nef failed with return code: {cp.returncode}." # put each model into submodel # for 520/720/530/630 model_ids = guess_available_model_id(p_out, hw_mode) fn_maps = {} for mid in model_ids: p_sub = p_out / f"model_{mid}" p_sub.mkdir(parents=True, exist_ok=True) if hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: # 540/730/1140 cmd = f"mv {p_out}/models_{hw_mode}_model_{mid}.kne* {p_sub}" else: cmd = f"mv {p_out}/NEF_*_modelid_{mid}_* {p_sub}" cp = futils.run_bash_script(cmd) assert cp.returncode == 0, f"Failed to move model_{mid} bin files. Return code: {cp.returncode}" p_sub = p_out / f"model_{mid}" ioinfo = convert_ioinfo(p_sub, hw_mode) # fn_map = locate_compiler_dump(p_sub, hw_mode, parse_nef=True) fn_maps[mid] = (p_sub, ioinfo) return fn_maps, p_out class NumpyEncoder(json.JSONEncoder): """To save numpy array in json. From `numpy array is not json serializable`_ . .. _numpy array is not json serializable: https://stackoverflow.com/questions/26646362/numpy-array-is-not-json-serializable """ def default(self, obj): """Set default way.""" if isinstance(obj, np.ndarray): return obj.tolist() return json.JSONEncoder.default(self, obj) def parse_setup_json_v0(fn_json): """Parse raw json generated from 520 setup.bin. Necessary info per io node (same for all platform), see `verify_ioinfo()`. NOTE: - we assume only 1 input for 520 models. """ with open(fn_json, "r") as f: raw = json.load(f) ioinfo = {} def get_in(h): v1 = {} # NOTE: for 520, the given dimension is always 1CHW # There will be no onnx shape in setup.bin. # example, [1, 10] will be [1, 10, 1, 1] v1["name"] = "0" v1["shape"] = [1, h["input_channel"], h["input_row"], h["input_col"]] v1["onnx_shape"] = [1, h["input_channel"], h["input_row"], h["input_col"]] v1["bitw"] = 8 # only support 8bit # 520 only support per layer v1["radix"] = [h["input_radix"] for i in range(h["input_channel"])] v1["scale"] = [1.0 for i in range(h["input_channel"])] v1["ch_dim"] = 1 v1["data_format"] = "RGBA_8BIT" # just guess. to keep same format return v1 def get_out(i, h): d = {} # no name saved in 520 setup.bin / nef. so we use index only d["name"] = str(i) d["shape"] = [1, h["ch_length"], h["row_length"], h["col_length"]] d["onnx_shape"] = [1, h["ch_length"], h["row_length"], h["col_length"]] d["bitw"] = 8 # only support 8bit # NOTE: 520 radix/scale are same for all channels d["radix"] = [h["output_radix"] for i in range(h["ch_length"])] per_channel_scales = futils.intle2flt(h["output_scale"]) d["scale"] = [per_channel_scales for i in range(h["ch_length"])] d["ch_dim"] = 1 d["data_format"], _ = parse_data_format(520, h["data_format"]) return d # input. assume only one. # sometime the json have headers or header if "headers" in raw: ioinfo["input"] = [get_in(a) for a in raw["headers"]] else: assert "header" in raw, "Extracted 520 setup.bin.json have no header nor headers." ioinfo["input"] = [get_in(raw["header"])] # output. maybe multiple. ioinfo["output"] = [get_out(i, d) for i, d in enumerate(raw["outputs"])] return ioinfo def check_input_fmt(input_fmt, platform): """Check the input format. Args: input_fmt: None, str或dict类型。如果是dict, key必须是'input_数字_value_info'格式 platform: 硬件平台 Raises: ValueError: 当格式不正确时抛出 Note: Compiler会进行额外的格式检查, 可能会抛出以下错误: * InvalidProgramInput: 当指定不正确的格式时（例如:指定input_fmt为HW5C8B） * UnimplementedFeature: 当指定模型不支持的inproc format时（会触发assert） * HardwareNotSupport: 当指定硬件不支持的格式时（例如: first layer不支持4W4C8B但指定了该格式） Todo: * Check if NUM in 'input_NUM_value_info' is within valid range (1 to max number of inputs) """ if input_fmt is not None: _, supported_formats = get_support_formats(platform) if isinstance(input_fmt, str): if input_fmt not in supported_formats: raise ValueError(f"input_fmt should be in {supported_formats}. But got {input_fmt} .") elif isinstance(input_fmt, dict): pattern = re.compile(r'^input_\d+_value_info$') for k, v in input_fmt.items(): if not pattern.match(k): raise ValueError(f"input_fmt's key should be in 'input_NUM_value_info' format, but got {k}") if v not in supported_formats: raise ValueError(f"input_fmt's value should be in {supported_formats}, but got {v}") def get_support_formats(hw_mode): """Get the list of supported formats for a given hw_mode.""" if hw_mode == 520: """refer to compiler/lib/target/mozart/basic/hw_define.h not using this info now. """ ref = { -1: ("UNKNOWN", 8), 8: ("16W1C8B", 8), 0: ("8W1C16B", 16), 9: ("BY_COL_8BIT", 8), 1: ("BY_COL_16BIT", 16), 10: ("BY_CHNL_8BIT", 8), 2: ("BY_CHNL_16BIT", 16), 15: ("CUSTOMIZE", 8), 16: ("RGBA_8BIT", 8), 17: ("RGBA_16BIT", 16), 18: ("SEQ_32BIT", 32), 100: ("RAW8", 8), 101: ("RAW16", 16), 102: ("RAW_FLOAT", 32), } elif hw_mode == 720: """refer to compiler/lib/target/beethoven/basic/hw_define.h""" ref = { -1: ("UNKNOWN", 8), 0: ("1W16C8B", 8), 1: ("1W16C8B_INTLV", 8), 2: ("1W16C8BHL", 16), 3: ("1W16C8BHL_INTLV", 16), 4: ("4W4C8B", 8), 5: ("16W1C8B", 8), 6: ("8W1C16B", 16), 7: ("PS_8W1C16B", 16), 8: ("PS_1W8C16B", 16), 9: ("PS_1W4C32B", 32), 11: ("PS_2W4C16B", 16), 12: ("PS_4W1C32B", 32), 13: ("PS_1W16C16B", 16), 14: ("PS_1W8C32B", 32), 15: ("PS_1W16C32B", 32), 16: ("PS_4W2C16B", 16), 17: ("PS_2W4C32B", 32), 18: ("PS_2W2C32B", 32), 100: ("RAW8", 8), 101: ("RAW16", 16), 102: ("RAW_FLOAT", 32), } elif hw_mode in [530, 540, 630]: """ 730/540/630 refer to compiler/lib/target/wagner/basic/hw_define.h 530 see refer to compiler/lib/target/bach/basic/hw_define.h but seems same for now UNKNOWN = (int)DATA_FORMAT_FMT_UNKNOWN, 1W16C8B, 1W16C8BHL, 4W4C8B, 4W4C8BHL, 16W1C8B, 16W1C8BHL, 8W1C16B, PS_1W16C24B, RAW_FLOAT = (int)DATA_FORMAT_FMT_RAW_FLOAT, """ ref = { -1: ("UNKNOWN", 8), 0: ("1W16C8B", 8), 1: ("1W16C8BHL", 16), 2: ("4W4C8B", 8), 3: ("4W4C8BHL", 16), 4: ("16W1C8B", 8), 5: ("16W1C8BHL", 16), 6: ("8W1C16B", 16), 7: ("PS_1W16C24B", 24), 100: ("RAW8", 8), 102: ("RAW16", 16), 103: ("RAW_FLOAT", 32), } elif hw_mode in [730]: """ 730/540/630 refer to compiler/lib/target/wagner/basic/hw_define.h UNKNOWN = (int)DATA_FORMAT_FMT_UNKNOWN, 1W16C8B, 1W16C8BHL, 4W4C8B, 4W4C8BHL, 16W1C8B, 16W1C8BHL, 8W1C16B, PS_1W16C24B, 1W16C8B_CH_COMPACT, // only used by fw 1W16C8BHL_CH_COMPACT, // only used by fw RAW_FLOAT = (int)DATA_FORMAT_FMT_RAW_FLOAT, """ ref = { -1: ("UNKNOWN", 8), 0: ("1W16C8B_CH_COMPACT", 8), 1: ("1W16C8BHL_CH_COMPACT", 16), 2: ("4W4C8B", 8), 3: ("4W4C8BHL", 16), 4: ("16W1C8B", 8), 5: ("16W1C8BHL", 16), 6: ("8W1C16B", 16), 7: ("PS_1W16C24B", 24), 8: ("1W16C8B", 8), 9: ("1W16C8BHL", 16), 10: ("HW4C8B_KEEP_A", 8), # inproc 11: ("HW4C8B_DROP_A", 8), # inproc 12: ("HW1C8B", 8), # inproc 13: ("HW1C16B_LE", 16), # inproc 14: ("HW1C16B_BE", 16), # inproc 100: ("RAW8", 8), 102: ("RAW16", 16), 103: ("RAW_FLOAT", 32), } elif hw_mode in [1140]: """ 1140 refer to compiler/lib/ravel/basic/hw_define.h 1W32C8B, 1W32C8BHL, 8W4C8B, 8W4C8BHL, 32W1C8B, 32W1C8BHL, 16W1C16B, PS_1W32C40B, RAW_FLOAT = (int)DATA_FORMAT_FMT_RAW_FLOAT, """ ref = { -1: ("UNKNOWN", 8), 0: ("1W32C8B", 8), 1: ("1W32C8BHL", 16), 2: ("8W4C8B", 8), 3: ("8W4C8BHL", 16), 4: ("32W1C8B", 8), 5: ("32W1C8BHL", 16), 6: ("16W1C16B", 16), 7: ("PS_1W32C40B", 40), 100: ("RAW8", 8), 102: ("RAW16", 16), 103: ("RAW_FLOAT", 32), } else: raise ValueError(f"Unsupported hw_mode: {hw_mode}") fmt_valid = [v[0] for k, v in ref.items() if k >= 0] return ref, fmt_valid def parse_data_format(hw_mode, fmt): """Convert fmt number to real format. The raw ioinfo from compiler use int to represent hardware data format. The data-converter require the input of format in "string". This function will take definition from compiler and hard-code here. Update if compiler changed. Ref: `ticket #17762`_ """ ref, _ = get_support_formats(hw_mode) if int(fmt) not in ref: raise ValueError(f"Unsupported fmt: {fmt} for hw_mode: {hw_mode}") # need format name and bitwidth return ref[int(fmt)] def parse_setup_json_v1(fn_json): """Parse raw json generated from setup.bin (v2 flatbuffer, 530/630/720). Necessary info per io node (same for all platform), please refer to `parse_setup_json_v0()`. """ with open(fn_json, "r") as f: raw = json.load(f) ioinfo = {} def get_platform(j): return int(j["header"]["target"].removeprefix("KL")) platform = get_platform(raw) def get_in(h): v1 = {} v1["name"] = h["name"] # from Jay # setup.bin 的 Tensor 定義： # raw_shape 是 onnx shape # shape 是 hw shape # ioinfo.json 的定義： # onnx_shape 是 onnx_shape # shape 是 hw shape v1["shape"] = np.array(h["shape"]) v1["onnx_shape"] = np.array(h["raw_shape"]) # TODO: is this true? always second? v1["ch_dim"] = 1 v1["data_format"], v1["bitw"] = parse_data_format(platform, h["format"]) # for per channel radix/scale n_ch = v1["onnx_shape"][v1["ch_dim"]] for k in ["radix", "scale"]: t = [a[k] for a in h["quantization"]["fxp_info"]] if len(t) == n_ch: # per channel given v1[k] = np.array(t) else: # per layer given. need expand assert ( len(t) == 1 ), f"channel {n_ch} but got {k} for {len(t)} channels: {t}" v1[k] = np.array([t[0] for i in range(n_ch)]) return v1 # input. maybe multiple ioinfo["input"] = [get_in(d) for d in raw["inputs"]] # output. maybe multiple. ioinfo["output"] = [get_in(d) for d in raw["outputs"]] return ioinfo def patch_16b_output(out_1): """CSIM will have only 8/15 bit dump of .seq files. Convert if compiler give 16bit radix. Output Only. """ if out_1["bitw"] == 16: out_1["radix"] = out_1["radix"] - 1 out_1["bitw"] = 15 return out_1 def parse_setup_json_v2(fn_json): """Parse raw json generated from kne (540/730). NOTE: we suppose only one model in a kne. Necessary info per io node (same for all platform), please refer to `parse_setup_json_v0()`. Ref: `ticket #17762`_ """ with open(fn_json, "r") as f: # MAYBE: .no_binary.json may have inf in it making the json invalid. json_str = futils.preprocess_json(f.read()) raw = json.loads(json_str) n_models = len(raw["models"]) if n_models > 1: print(f"WARNING: found {n_models} in {fn_json}. will only extract first model ioinfo for now.") def get_platform(j): return int(j["header"]["target"].removeprefix("KL")) platform = get_platform(raw) def parse_ch_dim(lst): """Input lst should be a list of 4 elements: [b, c, h, w].""" if lst[0] == -1: # when list is [-1. -1, -1, -1] return 1 else: # there should be no -1 in the list assert lst[1] != -1 return lst[1] def get_in(h): """Convert no_binary.json to ioinfo.json format.""" v1 = {} v1["name"] = h["name"] v1["ndim"] = h["ndim"] v1["shape"] = np.array(h["shape"]) # need to combine shape and inv_shape_intrp_dim to get real onnx_shape. # see #18456 v1["onnx_shape"] = np.array([v1["shape"][a] for a in h["inv_shape_intrp_dim"]]) # v1["ch_dim"] = parse_ch_dim(h["shape_intrp_dim"]) v1["ch_dim"] = h["ch_dim"] n_ch = v1["shape"][v1["ch_dim"]] v1["stride"] = np.array(h["stride_aligned"]) v1["data_format"], v1["bitw"] = parse_data_format(platform, h["format"]) # for per channel radix k = "radix" t = h["quantization"][k] if len(t) == n_ch: # per channel given v1[k] = np.array(t) else: # per layer given. need expand assert len(t) == 1, f"channel {n_ch} but got {k} for {len(t)} channels: {t}" v1[k] = np.array([t[0] for i in range(n_ch)]) # scale k = "scale" scale_le = h["quantization"]["scale"] scale_le_n = h["quantization"]["scale_count"] t = futils.array_le2flt(scale_le, scale_le_n) if len(t) == n_ch: # per channel given v1[k] = np.array(t) else: # per layer given. need expand assert len(t) == 1, f"channel {n_ch} but got {k} for {len(t)} channels: {t}" v1[k] = np.array([t[0] for i in range(n_ch)]) return v1 ioinfo = {} ioinfo["input"] = [get_in(d) for d in raw["models"][0]["header"]["inputs"]] ioinfo["output"] = [patch_16b_output(get_in(d)) for d in raw["models"][0]["header"]["outputs"]] return ioinfo @lru_cache(maxsize=128) def locate_compiler_dump(p_out, hw_mode, parse_nef=False): """Locate important files in compiler dump folder. Each platform has it's own required files to run csim. Some names may change, e.g., test.conf/apb.npu, but they serve same purpose. This function is to find correponding file and return organized as dict, so that each call will always get correct file independant of hw_mode. """ p_out = pathlib.Path(p_out) if hw_mode in [520]: patterns = { "setup_bin": "*setup.bin", "command_bin": "*command.bin", "weight_bin": "*weight.bin", "apb_npu": "*test.conf", # diff } if parse_nef: # HACK # unpack_nefs will genearte ioinfo.json for 520 patterns["ioinfo_json"] = "*ioinfo.json" # diff elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v1"]: patterns = { "setup_bin": "*setup.bin", "command_bin": "*command.bin", "weight_bin": "*weight.bin", "ioinfo_json": "*ioinfo.json", "apb_npu": "*apb.npu", } if hw_mode in [720]: # diff for 520/720 patterns["apb_npu"] = "*test.conf" elif hw_mode in fconsts.MODE_HW_LIMIT["nef_v2"]: patterns = { "kne": f"*models_{hw_mode}*.kne", } else: raise NotImplementedError fn_map = {} for k, v in patterns.items(): ps = list(p_out.glob(v)) assert len(ps) >= 1, f"Looking for {k}, expect 1, but found {len(ps)}: {ps}" fn_map[k] = ps[0] return fn_map # TODELETE # def load_ioinfo_json(fn_ioinfo): # """Load compiler generated ioinfo.json then apply special process. # # Convert `shape`/`onnx_shape`/`radix`/`scale` to numpy array for # better process later. # # NOTE: # No ioinfo.json for 520. # """ # with open(fn_ioinfo, "r") as f: # ioinfo = json.load(f) # # for io in ["input", "output"]: # for a in ioinfo[io]: # a["name"] = futils.clean_name(a["name"]) # for k in ["onnx_shape", "scale", "radix", "shape"]: # a[k] = np.array(a[k]) # return ioinfo def collect_fps_improve(dir_out): """Load the fps improved from ip_evaluator reports. The reults will be compiled with other analysis and put in the final report. Args: `dir_out`: the output folder of compiler. """ p_f = pathlib.Path(dir_out) / "summary_image_cut_search.txt" if not p_f.exists(): return None with open(p_f, "r") as f: lines = f.readlines() prefix = "fps improve:" for line in lines: if line.startswith(prefix): return line.removeprefix(prefix).strip() return None def get_cpu_node_op_type(dir_out): """Extract cpu op related from setup.txt.""" cpu_node_list_str = set() setup_dir = f"{dir_out}/setup.txt" def extract_cpu_op_type(txt): s = re.compile('"(op_type|opcode_index)": *"(.*?)"') return s.findall(txt)[0][1] try: with open(setup_dir, "r") as f: lines = f.readlines() for line in lines: # new setup.txt(opcode_index) # old setup.txt(op_type) if "op_type" in line or "opcode_index" in line: cpu_node_str = extract_cpu_op_type(str(line)) if cpu_node_str == "CpuFusion": continue cpu_node_list_str.add(cpu_node_str) if len(cpu_node_list_str) == 0: return "None" else: return ",".join(cpu_node_list_str) except: # print("No setup.txt found.") return "N/A" def collect_command_weight_size(dir_out): """As name implies.""" cmd_size = None weight_size = None stats_dir = f"{dir_out}/dbg.stat.json" try: with open(stats_dir, "r") as f: stats = json.load(f) cmd_size = int(stats["general"]["cmd_size"] / (10**3)) weight_size = int(stats["general"]["wt_size"] / (10**6)) except: pass return cmd_size, weight_size def find_cpu_nodes(lines): """As name implies.""" nodes = [] found = False for line in lines: if line.startswith("***** Warning: CPU ops types"): found = True continue if found: clean = line.strip().strip(",") if len(clean) > 4: nodes.append(clean) else: found = False if len(nodes) > 0: return "//".join(nodes) else: return "N/A" def collect_FPS(dir_out, hw_mode): """Collect FPS info from compiler output folder. WARNING: - Tiefang will make report same for ALL platforms. - will all be named as `ProfileResult.txt` """ profile_dir = f"{dir_out}/ProfileResult.txt" d_profile = OrderedDict() def search_by_prefix(lines, k): for line in lines: if line.startswith(k): return line.removeprefix(k).strip() return None def gb2mb(line): return float(line.removesuffix("GB")) * 1000 def convert2int(s): if s == "inf" or s is None: return None return int(float(s)) try: with open(profile_dir, "r") as f: lines = f.readlines() # load fps if hw_mode == 520: d_profile["fps"] = search_by_prefix(lines, "output_fps =") d_profile["ITC(ms)"] = search_by_prefix(lines, "output_total_time =") d_profile["RDMA bandwidth GB/s"] = search_by_prefix(lines, "RDMA_bandwidth_GBPs =") d_profile["WDMA bandwidth GB/s"] = search_by_prefix(lines, "WDMA_bandwidth_GBPs =") d_profile["GETW bandwidth GB/s"] = search_by_prefix(lines, "GETW_bandwidth_GBPs =") d_profile["cpu_node"] = find_cpu_nodes(lines) # d_profile[f"RV(mb)"] = search_by_prefix(lines, "output_total_data_move_in_amount =") # d_profile[f"WV(mb)"] = search_by_prefix(lines, "output_total_data_move_out_amount =") else: d_profile["fps"] = search_by_prefix(lines, "output_fps =") d_profile["ITC(ms)"] = search_by_prefix(lines, "output_total_time =") d_profile["C(GOPs)"] = search_by_prefix(lines, "output_total_theory_mac =") d_profile["RDMA bandwidth GB/s"] = search_by_prefix(lines, "RDMA_bandwidth_GBPs =") d_profile["WDMA bandwidth GB/s"] = search_by_prefix(lines, "WDMA_bandwidth_GBPs =") d_profile["GETW bandwidth GB/s"] = search_by_prefix(lines, "GETW_bandwidth_GBPs =") d_profile["RV(mb)"] = gb2mb(search_by_prefix(lines, "output_total_RDMA_amount =")) d_profile["WV(mb)"] = gb2mb(search_by_prefix(lines, "output_total_WDMA_amount =")) d_profile["cpu_node"] = find_cpu_nodes(lines) except: # print("No {} found.".format(profile_dir)) pass # filter None items d_prof = OrderedDict() for k, v in d_profile.items(): if v: # not None d_prof[k] = v return d_prof def parse_fm_cut_summary(p_txt): """Parse the Summary.txt from compiler/fm_cut output for time and iteration records.""" time_total = None n_total = None n_fm_cut = None with open(p_txt, 'r') as file: for line in file: # 提取估计时间 if time_total is None and "Total search time:" in line: time_match = re.search(r"Total search time: *(\d+) mins?", line) if time_match: time_total = int(time_match.group(1)) else: # probally failed by timeout. # TODO: use the timeout value to replace it. time_total = "NA" # 提取计数器信息 if n_total is None and "Totally searched" in line: count_match = re.search(r"Totally searched (\d+) times; Image cut\(compiler\) succeeded (\d+) times!", line) if count_match: n_total = int(count_match.group(1)) n_fm_cut = int(count_match.group(2)) else: n_total = n_fm_cut = "NA" # 如果所有变量都已经找到，可以提前结束循环 if time_total and n_total and n_fm_cut: break if DEBUG: print(f"fm cut: time {time_total} min, total {n_total} iterations, include {n_fm_cut} succcessful fm_cut.") return time_total, n_total, n_fm_cut def lookup_compiler_error(cp, hw_mode, module="compiler"): """Find the detailed error from compiler return code. Ref: https://redmine.kneron.tw/issues/18389 Compiler return code is between 1-30. gen_config.py will return 31-50 if fm_cut failed. """ rc = cp.returncode status = { 1: ("compiler", "compiler common"), 2: ("compiler", "compiler invalid input"), 3: ("compiler", "invalid onnx attribute"), 4: ("HW not support", "Err: 4"), 5: ("compiler", "unexpected graph"), 6: ("unimplemented feature", f"compiler: {rc}"), 7: ("compiler", "value not ready"), 8: ("knerex", "compiler: knerex config error"), 9: ("compiler", "unexpected value"), 111: ("fm_cut", cp.stderr), -15: ("fm_cut", "killed by SIGTERM"), 32: ("fm_cut", f"{hw_mode} is not supported"), 33: ("fm_cut", "No info_cutting.log"), } if rc in status: # specific msgs return status[rc] elif rc >= 1 and rc <= 30: return ("compiler", f"Err: {rc}") elif rc >= 31 and rc <= 50: return ("fm_cut", f"Err: {rc}") else: return (module, f"Err: {rc}") def check_fm_cut_log(log_content): """Extract ret_code from fm_cut log.""" # 定义正则表达式，匹配特定的错误信息 pattern = r'ERROR: run sub-module "image_cut_search" failed[ !]*\[ret_code=(\d+)\. msg="(.*?)"\]' # 在日志内容中查找匹配项 match = re.search(pattern, log_content) if match: # 提取ret_code和msg ret_code = int(match.group(1)) # msg = match.group(2) # not used now if ret_code == 4: return ("HW not support", "reported by fm_cut") elif ret_code == 6: return ("unimplemented feature", "reported by fm_cut") else: return ("compiler", f"fm_cut reported: err {ret_code}") else: return None def parse_compiler_warning(p_compiler_out): """Need to extract warning from compiler logs. Those lines has `[error]` `[critical] [warning]` Extract each line and return a list. NOTE: - keyword in test_case.py: self.graph_warnings """ p_logs = list(p_compiler_out.rglob("batch_compile.log")) warning_lines = [] MARKS = ["[error]", "[critical]", "[warning]"] # 遍历所有日志文件 for p_log in p_logs: try: with open(p_log, "r", encoding="utf-8", errors="ignore") as f: for line_num, line in enumerate(f, 1): line = line.strip() # 检查是否包含警告、错误或关键信息标记 if any(marker in line.lower() for marker in MARKS): # 记录文件名、行号和内容 warning_lines.append({ "file": str(p_log.name), "line": line_num, "content": line }) except Exception as e: pass # 如果读取文件失败，记录错误信息 # warning_lines.append({ # "file": str(p_log.name), # "line": 0, # "content": f"Failed to read file: {str(e)}" # }) return warning_lines def parse_compiler_logs(p_compiler_out): """Extract detailed error from compiler logs.""" p_logs = list(p_compiler_out.rglob("*.log")) # load all the logs t = "" for p_log in p_logs: with open(p_log, "r") as f: t += "".join(f.readlines()) if len(t) == 0: return None # t is a long line with \n in it. results = check_fm_cut_log(t) if results: return results prefixes_1 = { # "ERROR: run sub-module \"image_cut_search\" failed": ("fm_cut", "compiler report"), "Invalid program input: Memory region \[weight\] .*? overlapps \[dram\]": ("compiler", "datapath oversize"), # 720 old setup "CSim only support CPU node in the end of model and write data to output buffer": ("compiler", "cpu node in middle"), } for keyw, (col_name, msg) in prefixes_1.items(): pat1 = re.compile(keyw) if len(pat1.findall(t)) > 0: return (col_name, msg) prefixes = { "Common": ("compiler", ""), "InvalidProgramInput": ("compiler", ""), "InvalidONNXAttribute": ("compiler", ""), "HardwareNotSupport": ("HW not support", "compiler: "), "Hardware not support": ("HW not support", "compiler: "), "UnexpectedGraph": ("compiler", ""), "UnimplementedFeature": ("unimplemented feature", "compiler: "), "ValueNotReady": ("compiler", ""), "KnerexError": ("knerex", "compiler: "), "UnexpectedValue": ("compiler", ""), "creating an EmptyNode instance for op_type:": ("compiler", "unsupported nodes: //"), } for keyw, (col_name, prefix) in prefixes.items(): pat1 = re.compile(f"{keyw}[:\s]*(.*)") if len(pat1.findall(t)) > 0: msg = prefix + "//".join(pat1.findall(t)) return (col_name, msg) # found no detailed error. return None