mindstudio-probe 8.3.2__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/msaccucmp/dump_parse/ffts_parser.py

@@ -0,0 +1,137 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+import os
+import numpy as np
+
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.dump_parse.dump_data_object import DumpTensor, DumpDataObj
+from msprobe.msaccucmp.dump_parse import dump
+
+
+class FFTSParser:
+    """
+    The class for FFTS mode type parser
+    """
+    def __init__(self, dump_file_list, dump_data_list):
+        self.dump_file_list = dump_file_list
+        self.dump_data_list = dump_data_list
+    
+    @property
+    def parse_ffts(self: any) -> tuple:
+        """
+        parse the ffts mode dump data and merge data
+        @return: file path, dump data
+        """
+        if len(self.dump_file_list) == 1:
+            dump_data = self.dump_data_list[-1]
+            file_path = self.dump_file_list[-1]
+            dump_data.set_op_attr(dump_data.op_name, True)
+            return file_path, dump_data
+        dump_base = self.dump_data_list[0]
+        thread_num = dump_base.get_thread_num
+        if self.check_file_missing(thread_num):
+            dump_base.ffts_file_check = False
+            log.print_warn_log(
+                f"This is a FFTS+ mode dump data {dump_base.op_name},"
+                f" The number of files does not match the number of thread (instance slice num).")
+
+        cut_axis = dump_base.get_cut_axis_auto if dump_base.get_ffts_mode else dump_base.get_cut_axis_manual
+
+        if not cut_axis or self.check_invalid_cut_axis(cut_axis):
+            dump_data_to_file = list(zip(self.dump_data_list, self.dump_file_list))
+            dump_data_to_file.sort(key=lambda x: os.path.basename(x[1]).split(".")[4])
+            file_path = dump_data_to_file[-1][1]
+            dump_data = dump_data_to_file[-1][0]
+            log.print_warn_log("The cut axis of Dump data is invalid. The current compare dump file is {}. "
+                               "All dump files are {}".format(dump_data_to_file[-1][1], ",".join(self.dump_file_list)))
+        else:
+            output_num = len(dump_base.output_data)
+            if dump_base.get_ffts_mode:
+                output_data_list = []
+                for index, dump_file in enumerate(self.dump_data_list):
+                    output_shape = dump_file.calculate_auto_mode_shape(index, "output")
+                    output_data_list.append(dump_file.get_auto_output_data(output_shape))
+            else:
+                output_data_list = [dump_data.get_output_data() for dump_data in self.dump_data_list]
+
+            expected_len = len(output_data_list[0])
+            for output in (output_data_list):
+                if len(output) != expected_len:
+                    log.print_error_log(
+                        f"Inconsistent output length detected: expected {expected_len}, "
+                        f"but got {len(output)}"
+                    )
+                    raise CompareError(CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR)
+
+            dump_data_output_list = []
+            for i in range(output_num):
+                output_index = []
+                for output in output_data_list:
+                    output_index.append(output[i])
+                dump_data_output_list.append(output_index)
+
+            merge_output = self.merge_data(dump_data_output_list, cut_axis)
+            dump_data = self.create_merge_dump_data(dump_base, merge_output)
+            file_path = '.'.join(self.dump_file_list[0].split(".")[:4] + ['*'])
+            log.print_info_log(f"This is a FFTS+ mode dump data {dump_base.op_name}, "
+                               f"output data has been merged, new file path is {file_path}")
+        return file_path, dump_data
+
+    @staticmethod
+    def check_invalid_cut_axis(cut_axis: list) -> bool:
+        """
+        check if the cut axis is valid
+        @param cut_axis: cut axis
+        @return: True or False
+        """
+        return all(dim == [] for dim in cut_axis)
+
+    @staticmethod
+    def merge_data(output_list: list, cut_axis: list) -> list:
+        merge_output = []
+        for index, dim in enumerate(cut_axis):
+            if not dim:
+                merge_output.append(output_list[index][0])
+            else:
+                axis = cut_axis[index][0]
+                merge_output.append(np.concatenate(output_list[index], axis))
+        return merge_output
+
+    @staticmethod
+    def create_merge_dump_data(dump_base: DumpDataObj, merge_output: list) -> DumpDataObj:
+        dump_data = DumpDataObj()
+        op_name = dump.process_op_name(dump_base.op_name) if dump_base.op_name else ""
+        dump_data.set_op_attr(op_name, dump_base.ffts_file_check)
+        for index, data in enumerate(merge_output):
+            shape = list(data.shape)
+            common_attr = dump_base.output_data[index].get_common_attr
+            dump_tensor = DumpTensor(index=index, data=data.reshape(-1), shape=shape,
+                                     data_type=common_attr[0], tensor_format=common_attr[1],
+                                     address=common_attr[2], original_shape=common_attr[3], is_ffts=True)
+            dump_data.output_data.append(dump_tensor)
+        dump_data.input_data = dump_base.input_data
+        return dump_data
+
+    def check_file_missing(self, thread_num: int) -> bool:
+        """
+        check if file number match thread number
+        @param thread_num: thread number
+        @return: True of False
+        """
+        return len(self.dump_data_list) != thread_num

msprobe/msaccucmp/dump_parse/mapping.py

@@ -0,0 +1,62 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+"""
+Function:
+This file mainly involves the mapping function.
+"""
+import os
+import csv
+
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+from msprobe.msaccucmp.cmp_utils.utils import check_file_size
+
+
+def _handle_csv_object(csv_object: any, mapping_file_path: str) -> dict:
+    hash_to_file_name_map = {}
+    for item in csv_object:
+        if len(item) == 2:
+            hash_to_file_name_map[item[0]] = item[1]
+        else:
+            log.print_error_log(
+                'The content (%s) of the mapping file "%r" is invalid.' % (item, mapping_file_path))
+    return hash_to_file_name_map
+
+
+def read_mapping_file(mapping_file_path: str) -> dict:
+    """
+    Read mapping file
+    :param mapping_file_path: mapping file path
+    :return: hash_to_file_name_map
+    """
+    hash_to_file_name_map = {}
+    if not os.path.isfile(mapping_file_path):
+        return hash_to_file_name_map
+    check_file_size(mapping_file_path, ConstManager.ONE_HUNDRED_MB)
+    try:
+        with open(mapping_file_path, "r") as mapping_file:
+            csv_object = csv.reader(mapping_file)
+            return _handle_csv_object(csv_object, mapping_file_path)
+    except csv.Error:
+        log.print_error_log('Failed to read csv object. The content of the mapping file "%r" is invalid.'
+                            % mapping_file_path)
+    except (OSError, SystemError, ValueError, TypeError, RuntimeError, MemoryError) as error:
+        log.print_open_file_error(mapping_file_path, error)
+    finally:
+        pass
+    return hash_to_file_name_map

msprobe/msaccucmp/dump_parse/nano_dump_data.py

@@ -0,0 +1,392 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+"""
+Function:
+This file mainly involves the nano dump function.
+"""
+import os
+import struct
+import warnings
+from typing.io import BinaryIO
+from enum import Enum
+
+from msprobe.msaccucmp.cmp_utils import path_check
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager, DD
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.cmp_utils.tlv_parse import TLV
+
+
+NANO_DUMP_DATA_MAGIC_NUM = 0x5a5a5a5a
+TLV_TYPE_INPUT_DESC = 4
+TLV_TYPE_OUTPUT_DESC = 5
+
+INPUT_DESC_TLV_TYPE_SHAPE_DIMS = 0
+INPUT_DESC_TLV_TYPE_ORI_SHAPE_DIMS = 1
+
+OUTPUT_DESC_L3_TLV_TYPE_SHAPE_DIMS = 0
+OUTPUT_DESC_L3_TLV_TYPE_ORI_SHAPE_DIMS = 1
+OUTPUT_DESC_L3_TLV_TYPE_ORI_NAME = 2
+
+INPUT_INFO_CONFIG_TAB = [
+    {'Name': 'data_type', 'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'format', 'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'address_type', 'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'address', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT64'},
+    {'Name': 'offset', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT64'},
+    {'Name': 'size', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT64'},
+    {'Name': 'tlv_list_len', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT32'},
+    {'Name': 'shape_dims', 'TLV_Type': 'TLNV', 'Ele_Type': 'UINT64',
+     'Tag': INPUT_DESC_TLV_TYPE_SHAPE_DIMS
+     },
+    {'Name': 'original_shape_dims', 'TLV_Type': 'TLNV', 'Ele_Type': 'UINT64',
+     'Tag': INPUT_DESC_TLV_TYPE_ORI_SHAPE_DIMS
+     }
+]
+
+INPUTS_LIST_CONFIG_TAB = [
+    {'Name': 'inputs_num', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT32'},
+    {'Name': 'inputs', 'TLV_Type': 'NV', 'Ele_Type': INPUT_INFO_CONFIG_TAB, 'N': 'inputs_num'}
+]
+
+INPUTS_CONFIG_TAB = [
+    {'Name': 'input_desc', 'TLV_Type': 'TLV', 'Ele_Type': INPUTS_LIST_CONFIG_TAB, 'Tag': TLV_TYPE_INPUT_DESC}
+]
+
+OUTPUT_INFO_CONFIG_TAB = [
+    {'Name': 'data_type', 'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'format', 'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'address_type', 'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'original_index', 'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'original_data_type', 'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'original_format', 'TLV_Type': 'ATOM', 'Ele_Type': 'INT32'},
+    {'Name': 'address', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT64'},
+    {'Name': 'offset', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT64'},
+    {'Name': 'size', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT64'},
+    {'Name': 'tlv_list_len', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT32'},
+    {'Name': 'shape_dims', 'TLV_Type': 'TLNV', 'Ele_Type': 'UINT64',
+     'Tag': OUTPUT_DESC_L3_TLV_TYPE_SHAPE_DIMS
+     },
+    {'Name': 'original_shape_dims', 'TLV_Type': 'TLNV', 'Ele_Type': 'UINT64',
+     'Tag': OUTPUT_DESC_L3_TLV_TYPE_ORI_SHAPE_DIMS
+     },
+    {'Name': 'origin_name', 'TLV_Type': 'TLNV', 'Ele_Type': 'CHAR',
+     'Tag': OUTPUT_DESC_L3_TLV_TYPE_ORI_NAME
+     }
+]
+
+OUTPUTS_LIST_CONFIG_TAB = [
+    {'Name': 'outputs_num', 'TLV_Type': 'ATOM', 'Ele_Type': 'UINT32'},
+    {'Name': 'outputs', 'TLV_Type': 'NV', 'Ele_Type': OUTPUT_INFO_CONFIG_TAB, 'N': 'outputs_num'}
+]
+
+OUTPUTS_CONFIG_TAB = [
+    {'Name': 'output_desc', 'TLV_Type': 'TLV', 'Ele_Type': OUTPUTS_LIST_CONFIG_TAB, 'Tag': TLV_TYPE_OUTPUT_DESC}
+]
+
+
+class NanoDataType(Enum):
+    DT_FLOAT = 0
+    DT_FLOAT16 = 1
+    DT_INT8 = 2
+    DT_INT16 = 6
+    DT_UINT16 = 7
+    DT_UINT8 = 4
+    DT_INT32 = 3
+    DT_INT64 = 9
+    DT_UINT32 = 8
+    DT_UINT64 = 10
+    DT_BOOL = 12
+    DT_DOUBLE = 11
+    DT_STRING = 13
+    DT_DUAL_SUB_INT8 = 14
+    DT_DUAL_SUB_UINT8 = 15
+    DT_COMPLEX64 = 16
+    DT_COMPLEX128 = 17
+    DT_QINT8 = 18
+    DT_QINT16 = 19
+    DT_QINT32 = 20
+    DT_QUINT8 = 21
+    DT_QUINT16 = 22,
+    DT_RESOURCE = 23
+    DT_STRING_REF = 24
+    DT_DUAL = 25
+    DT_VARIANT = 26
+    DT_BF16 = 27
+    DT_UNDEFINED = 28
+    DT_INT4 = 29
+    DT_UINT1 = 30
+    DT_INT2 = 31
+    DT_UINT2 = 32
+    DT_MAX = 33
+
+
+NANO_DATA_TYPE_TO_PROTO_DATA_TYPE = {
+    NanoDataType.DT_FLOAT.value: DD.DT_FLOAT,
+    NanoDataType.DT_FLOAT16.value: DD.DT_FLOAT16,
+    NanoDataType.DT_DOUBLE.value: DD.DT_DOUBLE,
+    NanoDataType.DT_INT8.value: DD.DT_INT8,
+    NanoDataType.DT_INT16.value: DD.DT_INT16,
+    NanoDataType.DT_INT32.value: DD.DT_INT32,
+    NanoDataType.DT_INT64.value: DD.DT_INT64,
+    NanoDataType.DT_UINT8.value: DD.DT_UINT8,
+    NanoDataType.DT_UINT16.value: DD.DT_UINT16,
+    NanoDataType.DT_UINT32.value: DD.DT_UINT32,
+    NanoDataType.DT_UINT64.value: DD.DT_UINT64,
+    NanoDataType.DT_BOOL.value: DD.DT_BOOL,
+    NanoDataType.DT_COMPLEX64.value: DD.DT_COMPLEX64,
+    NanoDataType.DT_COMPLEX128.value: DD.DT_COMPLEX128,
+    NanoDataType.DT_BF16.value: DD.DT_BF16,
+    NanoDataType.DT_UINT1.value: DD.DT_UINT1,
+    NanoDataType.DT_RESOURCE.value: DD.DT_INT64,
+}
+
+
+class EmptyObj:
+    pass
+
+
+class NanoDumpData:
+    def __init__(self, op_type="", op_name="", dump_time=0) -> None:
+        self.magic_num = None
+        self.version_id = 0
+        self.op_type = op_type
+        self.op_name = op_name
+        self.dump_time = dump_time
+        self.inputs = []
+        self.outputs = []
+
+    @staticmethod
+    def _unpack_value(aux: bytes, value_type: str) -> (bytes, any):
+        type_para = ConstManager.UNPACK_FORMAT.get(value_type)
+        _fmt, _size = type_para.get('FMT'), type_para.get('SIZE')
+
+        if len(aux) < _size:
+            raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR)
+
+        value = struct.unpack(_fmt, aux[:_size])[0]
+        return aux[_size:], value
+
+    def parse_tlv_head(self, content: bytes) -> None:
+        aux = content
+
+        # magic_num
+        aux, self.magic_num = self._parse_uint32(aux)
+        if self.magic_num != NANO_DUMP_DATA_MAGIC_NUM:
+            # parse data from bin file stream
+            raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR)
+
+        # version_id
+        aux, self.version_id = self._parse_uint32(aux)
+
+        # inputs
+        intputs_desc_obj = EmptyObj()
+        tlv = TLV(INPUTS_CONFIG_TAB)
+        try:
+            aux, nested_obj = tlv.parse_tlv_by_cfg_tab(aux, intputs_desc_obj)
+        except CompareError as error:
+            log.print_error_log('Failed to decode inputs info %s', error)
+            raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR) from error
+
+        if nested_obj.input_desc is not None:
+            self.inputs = nested_obj.input_desc.inputs
+
+        # outputs
+        outputs_desc_obj = EmptyObj()
+        tlv = TLV(OUTPUTS_CONFIG_TAB)
+        try:
+            aux, nested_obj = tlv.parse_tlv_by_cfg_tab(aux, outputs_desc_obj)
+        except CompareError as error:
+            log.print_error_log('Failed to decode outputs info %s' % error)
+            raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR) from error
+
+        if nested_obj.output_desc is not None:
+            self.outputs = nested_obj.output_desc.outputs
+
+        self._convert_data_type_to_proto_data_type()
+
+    def _parse_uint32(self, aux: bytes) -> (bytes, any):
+        return self._unpack_value(aux, 'UINT32')
+
+    def _convert_data_type_to_proto_data_type(self):
+        for index, item in enumerate(self.inputs):
+            self.inputs[index].data_type = NANO_DATA_TYPE_TO_PROTO_DATA_TYPE.get(item.data_type)
+
+        for index, item in enumerate(self.outputs):
+            self.outputs[index].data_type = NANO_DATA_TYPE_TO_PROTO_DATA_TYPE.get(item.data_type)
+            self.outputs[index].original_data_type = NANO_DATA_TYPE_TO_PROTO_DATA_TYPE.get(item.original_data_type)
+
+
+class NanoDumpDataParser:
+    """
+    The class for big dump data parser
+    """
+    warnings.filterwarnings("ignore")
+
+    def __init__(self: any, dump_file_path: str) -> None:
+        self.dump_file_path = dump_file_path
+        self.file_size = os.path.getsize(self.dump_file_path)
+        self.tlv_header_length = 0
+
+        file_name = os.path.basename(self.dump_file_path)
+        op_name = file_name.split('.')[1]
+        dump_time = file_name.split('.')[4]
+        self.nano_dump_data = NanoDumpData(op_name, dump_time)
+
+    def parse(self: any) -> NanoDumpData:
+        """
+        Parse the dump file path by nano dump data format
+
+        file format:
+        |tlv head length| tlv head |input0 data |input1 data |...|output0 data |output1 data |...|
+        |uint64         | tlv head |input0 data |input1 data |...|output0 data |output1 data |...|
+
+        tlv head format:
+        |——uint32 magicnum  //0x5A5A5A5A
+        |——uint32 version_id
+        |——list of tensor(input和output)
+
+        :return: NanoDumpData
+        :exception when read or parse file error
+        """
+        with open(self.dump_file_path, 'rb') as dump_file:
+            self._read_header_length(dump_file)
+            self._read_tlv_head_data(dump_file)
+            self._check_size_match()
+            self._read_input_data(dump_file)
+            self._read_output_data(dump_file)
+            return self.nano_dump_data
+
+    def _check_size_match(self: any) -> None:
+        input_data_size = 0
+        for item in self.nano_dump_data.inputs:
+            input_data_size += item.size
+        output_data_size = 0
+        for item in self.nano_dump_data.outputs:
+            output_data_size += item.size
+
+        if self.tlv_header_length + input_data_size + output_data_size + \
+                ConstManager.UINT64_SIZE != self.file_size:
+            log.print_error_log(
+                'The file size (%d) of %r is not equal to %d (tlv_header_length)'
+                '+ %d(the sum of input data) + %d(the sum of output data) '
+                '. Please check the dump file.'
+                % (self.file_size, self.dump_file_path,
+                   self.tlv_header_length, input_data_size, output_data_size))
+            raise CompareError(CompareError.MSACCUCMP_UNMATCH_STANDARD_DUMP_SIZE)
+
+    def _read_header_length(self: any, dump_file: BinaryIO) -> None:
+        # read tlv header length
+        tlv_header_length = dump_file.read(ConstManager.UINT64_SIZE)
+        self.tlv_header_length = struct.unpack(ConstManager.UINT64_FMT, tlv_header_length)[0]
+
+        if self.tlv_header_length > self.file_size - ConstManager.UINT64_SIZE:
+            log.print_warn_log(
+                'The header content size (%d) of %r must be less than or'
+                ' equal to %d (file size) - %d (tlv header length).'
+                ' Please check the dump file.'
+                % (self.tlv_header_length, self.dump_file_path, self.file_size, ConstManager.UINT64_SIZE))
+            raise CompareError(CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR)
+
+    def _read_tlv_head_data(self: any, dump_file: BinaryIO) -> None:
+        content = dump_file.read(self.tlv_header_length)
+        try:
+            self.nano_dump_data.parse_tlv_head(content)
+        except CompareError as de_error:
+            log.print_warn_log(
+                'Failed to parse the serialized header content of %r. '
+                'Please check the dump file. %s '
+                % (self.dump_file_path, str(de_error)))
+            raise CompareError(CompareError.MSACCUCMP_PARSE_NANO_DUMP_FILE_ERROR) from de_error
+
+    def _read_input_data(self: any, dump_file: BinaryIO) -> None:
+        for data_input in self.nano_dump_data.inputs:
+            setattr(data_input, 'data', dump_file.read(data_input.size))
+
+    def _read_output_data(self: any, dump_file: BinaryIO) -> None:
+        for data_output in self.nano_dump_data.outputs:
+            setattr(data_output, 'data', dump_file.read(data_output.size))
+
+
+class NanoDumpDataHandler:
+    """
+    Handle dump data
+    """
+
+    def __init__(self: any, dump_file_path: str) -> None:
+        self.dump_file_path = dump_file_path
+        self.file_size = 0
+
+    def check_is_nano_dump_format(self):
+        ret = path_check.check_path_valid(self.dump_file_path, True)
+        if ret != CompareError.MSACCUCMP_NONE_ERROR:
+            return False
+
+        self.file_size = os.path.getsize(self.dump_file_path)
+        head_len = ConstManager.UINT64_SIZE + ConstManager.UINT32_SIZE
+        if self.file_size > head_len:
+            with open(self.dump_file_path, 'rb') as dump_file:
+                # read tlv_head_len
+                _ = dump_file.read(ConstManager.UINT64_SIZE)
+
+                # read magicnum
+                magicnum = dump_file.read(ConstManager.UINT32_SIZE)
+                magicnum = struct.unpack(ConstManager.UINT32_FMT, magicnum)[0]
+                return True if magicnum == NANO_DUMP_DATA_MAGIC_NUM else False
+        return False
+
+    def check_argument_valid(self: any) -> None:
+        """
+        check argument valid
+        :exception when invalid
+        """
+        file_name = os.path.basename(self.dump_file_path)
+
+        if len(file_name.split('.')) < 5:
+            raise CompareError(CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR, "The file name has no dump time")
+
+        if not self.check_is_nano_dump_format():
+            raise CompareError(CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR)
+
+        head_len = ConstManager.UINT64_SIZE * 2 + ConstManager.UINT32_SIZE * 2
+        if self.file_size < head_len:
+            log.print_error_log(
+                'The file size (%d) of %r must to bigger than%d (head_len).'
+                'Please check the dump file.'
+                % (self.file_size, self.dump_file_path, head_len))
+
+        if self.file_size > ConstManager.ONE_GB:
+            log.print_warn_log(
+                'The size (%d) of %r exceeds 1GB, it may task more time to run, please wait.'
+                % (self.file_size, self.dump_file_path))
+
+    def parse_dump_data(self: any) -> NanoDumpData:
+        """
+        Parse dump file
+        :param dump_version: the dump version
+        :return: DumpData
+        """
+        self.check_argument_valid()
+        try:
+            nano_dump_parser = NanoDumpDataParser(self.dump_file_path)
+            return nano_dump_parser.parse()
+        except CompareError as error:
+            message = 'Failed to parse the dump file %r, type is nano dump format. Please check the dump file. %s' \
+                      % (self.dump_file_path, str(error))
+            log.print_error_log(message)
+            raise error