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

msprobe/msaccucmp/vector_cmp/fusion_manager/compare_npu_vs_npu.py

@@ -0,0 +1,339 @@
+# 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:
+NpuVsNpuComparison class. This class mainly involves the compare function.
+"""
+import numpy as np
+
+from msprobe.msaccucmp.cmp_utils import utils
+from msprobe.msaccucmp.cmp_utils import common
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+from msprobe.msaccucmp.dump_parse.dump import CompareData
+from msprobe.msaccucmp.algorithm_manager.algorithm_manager import AlgorithmManager
+from msprobe.msaccucmp.vector_cmp.fusion_manager.fusion_op import FusionOp
+from msprobe.msaccucmp.vector_cmp.fusion_manager.fusion_op import Tensor
+from msprobe.msaccucmp.vector_cmp.fusion_manager import compare_result
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.overflow.overflow_detection import OverflowDetection
+from msprobe.msaccucmp.dump_parse.ffts_parser import FFTSParser
+from msprobe.msaccucmp.dump_parse import dump_utils
+from msprobe.msaccucmp.conversion.tensor_conversion import ConvertSingleTensorFormat 
+
+
+class NpuVsNpuComparison:
+    """
+    The class for npu vs npu comparison
+    """
+
+    def __init__(self: any, compare_data: CompareData, fusion_op_list: list, algorithm_manager: AlgorithmManager,
+                 overflow_detection: bool = False) -> None:
+        self.compare_data = compare_data
+        self.fusion_op_list = fusion_op_list
+        self.algorithm_manager = algorithm_manager
+        self.op_name = fusion_op_list[0].op_name
+        self.overflow_detection = overflow_detection
+        self.enable_padding_restore = True # 预留用于控制是否开启补齐恢复
+        self._tensor_converter = ConvertSingleTensorFormat()
+
+    def check_tensor_valid(self: any, my_output_tensor_list: any, ground_truth_tensor_list: any,
+                           tensor_type: str) -> (int, str):
+        """
+        check tensor valid
+        """
+        # check the length is same
+        if len(my_output_tensor_list) != len(ground_truth_tensor_list):
+            message = log.print_not_match_error(
+                self.op_name, 'number of %s' % tensor_type, str(len(my_output_tensor_list)),
+                str(len(ground_truth_tensor_list)))
+            return CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR, message
+        if len(my_output_tensor_list) != 0:
+            # check each tensor format and shape valid
+            return self._check_op_data_valid(my_output_tensor_list, ground_truth_tensor_list, tensor_type)
+        message = '[%s] There is no %s. Skip the %s:%s.' % (self.op_name, tensor_type, self.op_name, tensor_type)
+        log.print_info_log(message)
+        return CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR, message
+
+    def _restore_tensor_data_if_needed(self, tensor: Tensor):
+        """
+        根据开关决定是否对 tensor 做格式转换 + 按 original_shape 切掉 padding。
+        """
+        if not self._tensor_converter:
+            return tensor.data
+
+        try:
+            # ConvertSingleTensorFormat.__call__ 返回的是 np.ndarray
+            restored = self._tensor_converter(tensor)
+        except CompareError as ee:
+            # 出错时回退到原始数据，保证比对流程不中断
+            log.print_error_log(ee)
+            return tensor.data
+        except Exception as ee:  # 兜底
+            log.print_error_log(ee)
+            return tensor.data
+
+        return restored
+
+    def compare(self: any) -> (int, bool, list):
+        """
+        Compare for npu vs npu by op_name
+        :return ret: return code
+        :return dump_match: True, at least one operator match;False, no operator match
+        :return result: the compare result by the fusion op list
+        """
+        single_op_cmp_result = compare_result.SingleOpCmpResult()
+        if len(self.fusion_op_list) == 1:
+            return self._make_one_dump_file_result()
+        # get my output and ground truth tensor
+        error_msg = []
+        try:
+            my_output_dump_data = self._get_dump_data(
+                self.fusion_op_list[0], self.compare_data.left_dump_info.path,
+                self.compare_data.left_dump_info.op_name_to_task_mode_map, ConstManager.LEFT_TYPE)
+        except CompareError as error:
+            error_msg.append(error.message)
+            fusion_op_result = compare_result.FusionOpComResult(self.algorithm_manager)
+            _result = fusion_op_result.get_result(self.fusion_op_list[0], None, error_msg)
+            result_info = utils.ResultInfo(
+                self.fusion_op_list[0].op_name, True, _result.result_list, error.code,
+                [], _result.input_result_list, _result.output_result_list, _result.is_ffts,
+                {}, True)
+            single_op_cmp_result.update_attr(result_info)
+            return error.code, True, [single_op_cmp_result]
+
+        ground_truth_dump_data = self._get_dump_data(
+            self.fusion_op_list[1], self.compare_data.right_dump_info.path,
+            self.compare_data.right_dump_info.op_name_to_task_mode_map, ConstManager.RIGHT_TYPE)
+
+        compare_vector_result = []
+        # check npu input data valid
+        input_ret, input_error_msg = self.check_tensor_valid(
+            my_output_dump_data.data.input_data, ground_truth_dump_data.data.input_data, ConstManager.INPUT)
+        if input_ret == CompareError.MSACCUCMP_NONE_ERROR:
+            # compare input
+            compare_vector_result += self._compare_by_tensor(my_output_dump_data, ground_truth_dump_data,
+                                                             ConstManager.INPUT)
+
+        # check npu output data valid
+        output_ret, output_error_msg = self.check_tensor_valid(
+            my_output_dump_data.data.output_data, ground_truth_dump_data.data.output_data, ConstManager.OUTPUT)
+
+        if output_ret == CompareError.MSACCUCMP_NONE_ERROR:
+            # compare output
+            compare_vector_result += self._compare_by_tensor(my_output_dump_data, ground_truth_dump_data,
+                                                             ConstManager.OUTPUT)
+
+        if not my_output_dump_data.data.ffts_file_check:
+            msg = "This is a FFTS+ mode dump data, The number of files does not match the number of thread"
+            error_msg.append(msg)
+        # if no input and output, result is NaN
+        if input_ret != CompareError.MSACCUCMP_NONE_ERROR and output_ret != CompareError.MSACCUCMP_NONE_ERROR:
+            error_msg.append(input_error_msg)
+            error_msg.append(output_error_msg)
+            compare_vector_result = None
+        else:
+            output_ret = CompareError.MSACCUCMP_NONE_ERROR
+        fusion_op_result = compare_result.FusionOpComResult(self.algorithm_manager)
+        _result = fusion_op_result.get_result(self.fusion_op_list[0], compare_vector_result, error_msg)
+
+        result_info = utils.ResultInfo(
+            my_output_dump_data.name, True, _result.result_list, output_ret,
+            [], _result.input_result_list, _result.output_result_list, _result.is_ffts,
+            {}, True)
+
+        single_op_cmp_result.update_attr(result_info)
+
+        return output_ret, True, [single_op_cmp_result]
+
+    def _make_one_dump_file_result(self: any) -> (int, bool, list):
+        error_msg = []
+        # if only left or right has dump file, the result is NaN
+        single_op_cmp_result = compare_result.SingleOpCmpResult()
+        if self.fusion_op_list[0].op_type == ConstManager.LEFT_TYPE:
+            message = '[%s] There is no the ground truth dump file for the op "%s".' % (self.op_name, self.op_name)
+            log.print_warn_log(message)
+            error_msg.append(message)
+        elif self.fusion_op_list[0].op_type == ConstManager.RIGHT_TYPE:
+            message = '[%s] There is no the my output dump file for the op "%s".' % (self.op_name, self.op_name)
+            log.print_warn_log(message)
+            error_msg.append(message)
+        fusion_op_result = compare_result.FusionOpComResult(self.algorithm_manager,
+                                                            overflow_detection=self.overflow_detection)
+        _result = fusion_op_result.get_result(self.fusion_op_list[0], None, error_msg, no_dump_file=True)
+
+        result_info = utils.ResultInfo(
+            self.fusion_op_list[0].op_name, False, _result.result_list,
+            CompareError.MSACCUCMP_NO_DUMP_FILE_ERROR,
+            self.fusion_op_list[0].input_list, _result.input_result_list,
+            _result.output_result_list, _result.is_ffts, {}, True)
+
+        single_op_cmp_result.update_attr(result_info)
+
+        return CompareError.MSACCUCMP_NO_DUMP_FILE_ERROR, False, [single_op_cmp_result]
+
+    def _get_dump_data(self: any, fusion_op: FusionOp, dump_path: str,
+                       op_name_to_task_mode_map, dump_type: str) -> Tensor:
+        """
+        get dump data by fusion op output_desc
+        """
+        dump_file_list = fusion_op.output_desc
+        if not dump_file_list:
+            raise CompareError(CompareError.MSACCUCMP_NO_DUMP_FILE_ERROR)
+        dump_data_list = [dump_utils.parse_dump_file(dump_file_path, self.compare_data.dump_version)
+                          for dump_file_path in dump_file_list]
+        dump_mode = op_name_to_task_mode_map.get(self.op_name)
+        if dump_mode == ConstManager.AUTOMATIC_MODE or dump_mode == ConstManager.MANUAL_MODE:
+            ffts_parser = FFTSParser(dump_file_list, dump_data_list)
+            dump_file_path, dump_data = ffts_parser.parse_ffts
+            log.print_info_log(
+                'The "%s" in the path "%s" is FFTS+ dump data. After process the output data, the file path is "%s".'
+                % (fusion_op.op_name, dump_path, dump_file_path))
+        else:
+            dump_file_path = dump_file_list[-1]
+            dump_data = dump_data_list[-1]
+        log.print_info_log('[%s] [%s] %s' % (fusion_op.op_name, dump_type, dump_file_path))
+        if dump_data.op_name and dump_data.attr:
+            fusion_op.op_name = dump_data.op_name
+        tensor = Tensor(fusion_op.op_name, 0, '', [])
+        tensor.set_path(dump_file_path)
+        tensor.set_data(dump_data)
+        return tensor
+
+    def _check_op_data_valid(self: any, my_output_list: any, ground_truth_list: any, tensor_type: str) -> (int, str):
+        """
+        check format and shape of each tensor valid
+        """
+        message = ""
+        tensor_id_prefix = "%s:%s" % (self.op_name, tensor_type)
+        for index, (my_output_tensor, ground_truth_tensor) in enumerate(zip(my_output_list, ground_truth_list)):
+            tensor_id = '%s:%d' % (tensor_id_prefix, index)
+            # check format valid
+            if my_output_tensor.tensor_format != ground_truth_tensor.tensor_format:
+                message = log.print_not_match_error(
+                    self.op_name, 'format',
+                    common.get_format_string(my_output_tensor.tensor_format),
+                    common.get_format_string(ground_truth_tensor.tensor_format), tensor_id)
+                return CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR, message
+
+            # check the length of shape is the same
+            if len(my_output_tensor.shape) != len(ground_truth_tensor.shape):
+                message = log.print_not_match_error(
+                    self.op_name, 'shape',
+                    utils.convert_shape_to_string(my_output_tensor.shape),
+                    utils.convert_shape_to_string(ground_truth_tensor.shape), tensor_id)
+                return CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR, message
+            # check each dim in shape is the same
+            for my_output_dim, ground_truth_dim in zip(my_output_tensor.shape, ground_truth_tensor.shape):
+                if my_output_dim != ground_truth_dim:
+                    message = log.print_not_match_error(
+                        self.op_name, 'shape',
+                        utils.convert_shape_to_string(my_output_tensor.shape),
+                        utils.convert_shape_to_string(ground_truth_tensor.shape), tensor_id)
+                    return CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR, message
+        return CompareError.MSACCUCMP_NONE_ERROR, message
+
+    def _compare_by_one_tensor(self: any, my_output_dump_data: Tensor, ground_truth_dump_data: Tensor,
+                               my_output_tensor: any, ground_truth_tensor: any) -> (list, list):
+        error_msg = []
+        tensor_id = f"{self.op_name}_TENSOR"
+
+        # 1. deserialize output data to array
+        if my_output_tensor and ground_truth_tensor:
+            if self.enable_padding_restore:
+
+                restored_left = self._restore_tensor_data_if_needed(my_output_tensor)
+                restored_right = self._restore_tensor_data_if_needed(ground_truth_tensor)
+
+                # 强制 numpy flatten，避免后端 compare 出现 numpy bool 错误
+                my_output_data_array = np.asarray(restored_left).astype(np.float32).flatten()
+                ground_truth_data_array = np.asarray(restored_right).astype(np.float32).flatten()
+
+                # 若长度不一致，直接报 warning，方便定位问题
+                if my_output_data_array.shape != ground_truth_data_array.shape:
+                    message = f"[{tensor_id}] Shape mismatch after restore: " \
+                              f"{my_output_data_array.shape} vs {ground_truth_data_array.shape}"
+                    log.print_warn_log(message)
+                    raise CompareError(CompareError.MSACCUCMP_INVALID_SHAPE_ERROR, message)
+            else:
+                my_output_data_array = my_output_tensor.data.flatten()
+                ground_truth_data_array = ground_truth_tensor.data.flatten()
+        else:
+            return self.algorithm_manager.make_nan_result(), error_msg
+        
+        try:
+            # 2. compare by support algorithm
+            algorithm_result, error_msg = self.algorithm_manager.compare(
+                my_output_data_array, ground_truth_data_array,
+                {'my_output_dump_file': my_output_dump_data.path,
+                 'ground_truth_dump_file': ground_truth_dump_data.path,
+                 'shape_type': utils.get_shape_type(my_output_tensor.shape)})
+        except CompareError as compare_error:
+            if isinstance(compare_error, CompareError):
+                error_msg.append(compare_error.message)
+            algorithm_result = self.algorithm_manager.make_nan_result()
+
+        return algorithm_result, error_msg
+
+    def _compare_by_tensor(self: any, my_output_dump_data: Tensor, ground_truth_dump_data: Tensor,
+                           tensor_type: str) -> list:
+        tensor_result_list = []
+        if tensor_type == ConstManager.INPUT:
+            my_output_tensor_list = my_output_dump_data.data.input_data
+            ground_truth_tensor_list = ground_truth_dump_data.data.input_data
+            is_input = True
+        else:
+            my_output_tensor_list = my_output_dump_data.data.output_data
+            ground_truth_tensor_list = ground_truth_dump_data.data.output_data
+            is_input = False
+        # compare each tensor
+        for index, (my_output_tensor, ground_truth_tensor) in enumerate(
+                zip(my_output_tensor_list, ground_truth_tensor_list)):
+            tensor_id = '%s:%s:%d' % (my_output_dump_data.name, tensor_type, index)
+            log.print_info_log('[%s] compare %s %s for %s.'
+                               % (self.fusion_op_list[0].op_name,
+                                  common.get_format_string(my_output_tensor.tensor_format),
+                                  utils.convert_shape_to_string(my_output_tensor.shape),
+                                  tensor_id))
+            algorithm_result, error_msg = self._compare_by_one_tensor(my_output_dump_data, ground_truth_dump_data,
+                                                                      my_output_tensor, ground_truth_tensor)
+            # Check whether the current input/output data overflows
+            overflow_result = ''
+            if self.overflow_detection:
+                overflow_result = OverflowDetection.process_model_overflow_detection(my_output_dump_data.name,
+                                                                                     index, is_input, my_output_tensor)
+            my_output_tensor_dtype = utils.get_data_type(my_output_tensor.data_type)
+            ground_truth_tensor_dtype = utils.get_data_type(ground_truth_tensor.data_type)
+            my_output_tensor_address = utils.get_address_from_tensor(my_output_tensor)
+            ground_truth_tensor_address = utils.get_address_from_tensor(ground_truth_tensor)
+            op_type = dump_utils.get_op_type_from_file_name(my_output_dump_data.path)
+
+            # 3. merge result
+            tensor_info = {
+                "tensor_id": tensor_id,
+                "shape": my_output_tensor.shape,
+                "op_type": op_type,
+                "my_output_dtype": my_output_tensor_dtype,
+                "ground_truth_dtype": ground_truth_tensor_dtype,
+                "my_output_address": my_output_tensor_address,
+                "ground_truth_address": ground_truth_tensor_address
+            }
+            tensor_result_list.append(
+                compare_result.TensorResult(
+                    tensor_info, [algorithm_result, overflow_result], error_msg, my_output_tensor.is_ffts))
+        return tensor_result_list

msprobe/msaccucmp/vector_cmp/fusion_manager/compare_result.py

@@ -0,0 +1,326 @@
+# 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 FusionOpComResult class. This file mainly involves the get_result function.
+"""
+import collections
+
+from msprobe.msaccucmp.vector_cmp.fusion_manager import fusion_rule_parser
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+from msprobe.msaccucmp.vector_cmp.range_manager.range_manager import RangeManager
+from msprobe.msaccucmp.algorithm_manager.algorithm_manager import AlgorithmManager
+from msprobe.msaccucmp.vector_cmp.fusion_manager.fusion_op import FusionOp
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+
+
+class TensorResult:
+    """
+    The class for tensor compare result
+    """
+
+    def __init__(self: any, tensor_info: dict, result: list, error_msg: list, is_ffts: bool) -> None:
+        self.tensor_info = tensor_info
+        self.algorithm_result = result[0]
+        self.error_msg = error_msg
+        self.overflow_result = result[1]
+        self.is_ffts = is_ffts
+
+    def get_result(self: any) -> list:
+        """
+        Get tensor result list
+        :return [tensor_id, shape, algorithm_result, error_msg]
+        """
+        shape_str = '[%s]' % ",".join(map(str, self.tensor_info.get("shape", ConstManager.NAN)))
+        if self.overflow_result:
+            result = [shape_str] + [self.overflow_result] + self.algorithm_result + [",".join(self.error_msg)]
+        else:
+            result = [shape_str] + self.algorithm_result + [",".join(self.error_msg)]
+
+        if self.tensor_info.get("tensor_id"):
+            result = [self.tensor_info.get("tensor_id")] + result
+        return result
+
+    def get_algorithm_result(self: any) -> list:
+        """
+        Get algorithm result
+        """
+        return self.algorithm_result
+
+    def get_my_output_dtype(self):
+        return self.tensor_info.get("my_output_dtype", ConstManager.NAN)
+
+    def get_ground_truth_dtype(self):
+        return self.tensor_info.get("ground_truth_dtype", ConstManager.NAN)
+
+    def get_my_output_address(self):
+        return self.tensor_info.get("my_output_address", ConstManager.NAN)
+
+    def get_ground_truth_address(self):
+        return self.tensor_info.get("ground_truth_address", ConstManager.NAN)
+
+    def get_op_type(self):
+        return self.tensor_info.get("op_type", ConstManager.NAN)
+
+
+class PytorchOpInfo:
+    """
+    The class for pytorch op info
+    """
+
+    def __init__(self: any, index: int, op_name: str, my_dump_path: str, ground_truth_dump_path: str) -> None:
+        self.index = index
+        self.op_name = op_name
+        self.my_dump_path = my_dump_path
+        self.ground_truth_dump_path = ground_truth_dump_path
+
+    def get_result(self: any) -> list:
+        """
+        Get op info result
+        :return [index, op_name, my_dump_path, ground_truth_dump_path]
+        """
+        return [str(self.index), self.op_name, self.my_dump_path, self.ground_truth_dump_path]
+
+    def get_op_name(self: any) -> str:
+        """
+        Get op name
+        """
+        return self.op_name
+
+
+class FusionOpComResult:
+    """
+    The class for fusion op compare result
+    """
+
+    def __init__(self: any, algorithm_manager: AlgorithmManager, ground_truth_to_my_output_map: any = None,
+                 overflow_detection: bool = False, dump_is_cpu_or_gpu_data: list = None) -> None:
+        self.algorithm_manager = algorithm_manager
+        self.ground_truth_to_my_output_map = ground_truth_to_my_output_map
+        self.overflow_detection = overflow_detection
+        self.is_ground_truth_gpu_or_cpu = dump_is_cpu_or_gpu_data[0] if dump_is_cpu_or_gpu_data else False
+        self.is_my_dump_gpu_or_cpu = dump_is_cpu_or_gpu_data[1] if dump_is_cpu_or_gpu_data else False
+
+    @staticmethod
+    def _make_ops_without_map(fusion_op: FusionOp, no_dump_file: bool) -> (str, str):
+        my_output_op = fusion_op.op_name
+        ground_truth_op = fusion_op.op_name
+        # if only left or right has dump file
+        if fusion_op.op_type in [ConstManager.LEFT_TYPE, ConstManager.RIGHT_TYPE]:
+            if no_dump_file:
+                if fusion_op.op_type == ConstManager.LEFT_TYPE:
+                    ground_truth_op = '*'
+                elif fusion_op.op_type == ConstManager.RIGHT_TYPE:
+                    my_output_op = '*'
+        else:
+            ground_truth_op = ','.join(fusion_op.attr.original_op_names)
+            if ground_truth_op == '':
+                ground_truth_op = '*'
+        return my_output_op, ground_truth_op
+
+    @staticmethod
+    def _process_input_and_output(result, input_result_list, output_result_list):
+        if ConstManager.INPUT_PATTERN in result[ConstManager.TENSOR_INDEX]:
+            input_result_list.append(result)
+        elif ConstManager.OUTPUT_PATTERN in result[ConstManager.TENSOR_INDEX]:
+            output_result_list.append(result)
+        return input_result_list, output_result_list
+
+    def get_result(self: any, fusion_op: FusionOp, tensor_result: any, error_msg: list,
+                   no_dump_file: bool = False) -> any:
+        """
+        Get fusion op compare result list
+        :param fusion_op: the fusion op
+        :param tensor_result: the tensor result list
+        :param error_msg: error message
+        :param no_dump_file: the result no dump file
+        :return [op_id, my_output_op, ground_truth_op, tensor_id, shape, algorithm_result, error_msg]
+        """
+        result_list = []
+        input_result_list = []
+        output_result_list = []
+        is_ffts = False
+        my_output_op, ground_truth_op = self._make_my_output_op_and_ground_truth_op(fusion_op, no_dump_file)
+        if tensor_result:
+            for item in tensor_result:
+                current_tensor_info = [
+                    str(fusion_op.op_id), item.get_op_type(),
+                    my_output_op, str(item.get_my_output_dtype()),
+                    str(item.get_my_output_address()), ground_truth_op,
+                    str(item.get_ground_truth_dtype()), str(item.get_ground_truth_address())
+                ]
+                self._pre_handle_result(current_tensor_info)
+                result = current_tensor_info + item.get_result()
+                if item.is_ffts:
+                    is_ffts = True
+                    input_result_list, output_result_list = \
+                        self._process_input_and_output(result, input_result_list, output_result_list)
+                RangeManager.adjust_data(result, fusion_op.attr.get_op_sequence())
+                log.print_info_log('[{}] Result: {}'.format(fusion_op.op_name, " ".join(result)))
+                result_list.append(result)
+        else:
+            current_tensor_info = [
+                str(fusion_op.op_id), fusion_op.get_real_op_type(),
+                my_output_op, ConstManager.NAN, ConstManager.NAN,
+                ground_truth_op, ConstManager.NAN, ConstManager.NAN,
+                ConstManager.NAN, ConstManager.NAN
+            ]
+            self._pre_handle_result(current_tensor_info)
+            if self.overflow_detection:
+                # using 'NaN' as an overflow detection for 'no tensor_result'
+                # and insert it after the column 'Shape'.
+                result = current_tensor_info + ['NaN'] + self.algorithm_manager.make_nan_result() \
+                         + [",".join(error_msg)]
+            else:
+                result = current_tensor_info + self.algorithm_manager.make_nan_result() + [",".join(error_msg)]
+            RangeManager.adjust_data(result, fusion_op.attr.get_op_sequence())
+            log.print_info_log('[{}] Result: {}'.format(fusion_op.op_name, " ".join(result)))
+            result_list.append(result)
+
+        Result = collections.namedtuple("Result", ["result_list", "input_result_list", "output_result_list", "is_ffts"])
+        result = Result(result_list, input_result_list, output_result_list, is_ffts)
+        return result
+
+    def get_pytorch_result(self: any, op_info: PytorchOpInfo, tensor_result: any, error_msg: list) -> list:
+        """
+        Get fusion op compare result list
+        :param op_info: the pytorch op info
+        :param tensor_result: the tensor result list
+        :param error_msg: error message
+        :return [op_id, my_output_op, ground_truth_op, tensor_id, shape, algorithm_result, error_msg]
+        """
+        result_list = []
+        if tensor_result:
+            for item in tensor_result:
+                result = op_info.get_result() + [item.get_my_output_dtype()] + item.get_result()
+                log.print_info_log('[%s:%d] Result: %s' % (op_info.op_name, op_info.index, " ".join(result)))
+                result_list.append(result)
+        else:
+            result = op_info.get_result() + [ConstManager.NAN] + [ConstManager.NAN] + \
+                     self.algorithm_manager.make_nan_result() + [",".join(error_msg)]
+            log.print_info_log('[%s:%d] Result: %s' % (op_info.op_name, op_info.index, " ".join(result)))
+            result_list.append(result)
+        return result_list
+
+    def _make_my_output_op_and_ground_truth_op(self: any, fusion_op: FusionOp, no_dump_file: bool) -> (str, str):
+        if self.ground_truth_to_my_output_map:
+            my_output_op, ground_truth_op = fusion_rule_parser. \
+                make_left_and_right_string(self.ground_truth_to_my_output_map)
+        else:
+            my_output_op, ground_truth_op = self._make_ops_without_map(fusion_op, no_dump_file)
+        return my_output_op, ground_truth_op
+
+    def _pre_handle_result(self: any, current_tensor_info: list) -> None:
+        """
+        if dump data is not NPU data, the result will be popped.
+        the index of my dump data address is 3, the index of ground truth data address is 6.
+        args: result list
+        """
+        if self.is_ground_truth_gpu_or_cpu:
+            # op id is inserted as index in header, so address index should plus one.
+            current_tensor_info.pop(ConstManager.GROUND_TRUTH_ADDRESS_INDEX + 1)
+        if self.is_my_dump_gpu_or_cpu:
+            current_tensor_info.pop(ConstManager.MY_OUTPUT_ADDRESS_INDEX + 1)
+
+
+def get_result_title(algorithm_manager: AlgorithmManager, op_header: list, overflow_detection: bool = False) -> list:
+    """
+    Get result title
+    :param algorithm_manager: the algorithm manager
+    :param op_header: the op header
+    :param overflow_detection: whether to display overflow info
+    :return  [Index, op_header, shape, algorithm_result, error_msg]
+    """
+
+    header = ['Index'] + op_header + ['Shape'] + algorithm_manager.get_result_title() + ["CompareFailReason"]
+    # add 'OverFlow' after 'Shape'.
+    if overflow_detection:
+        header.insert(header.index('Shape') + 1, 'OverFlow')
+    RangeManager.adjust_header(header)
+    return header
+
+
+class SingleOpCmpResult:
+    """
+    The class for single op result
+    """
+    def __init__(self: any) -> None:
+        self.op_name = ""
+        self.dump_match = False
+        self.result_list = None
+        self.ret = 0
+        self.input_list = None
+        self.input_result_list = None
+        self.output_result_list = None
+        self.is_ffts = False
+        self.op_name_origin_output_index_map = None
+        self.npu_vs_npu = False
+
+    @staticmethod
+    def get_pre_op_output(op_name: str, index: int, result_mapping: dict) -> list:
+        pre_op_result = result_mapping.get(op_name)
+        if pre_op_result:
+            output_result = pre_op_result.output_result_list[index]
+        else:
+            output_result = None
+            message = "The result of '%s' is not in result mapping" % op_name
+            log.print_warn_log(message)
+        return output_result
+
+    def update_attr(self: any, result_info: collections.namedtuple) -> None:
+        self.op_name = result_info.op_name
+        self.dump_match = result_info.dump_match
+        self.result_list = result_info.result_list
+        self.ret = result_info.ret
+        self.input_list = result_info.input_list
+        self.input_result_list = result_info.input_result_list
+        self.output_result_list = result_info.output_result_list
+        self.is_ffts = result_info.is_ffts
+        self.op_name_origin_output_index_map = result_info.op_name_origin_output_index_map
+        self.npu_vs_npu = result_info.npu_vs_npu
+
+    def check_result_list_valid(self: any) -> None:
+        if len(self.result_list) < len(self.input_result_list):
+            message = "The length of input result list is greater than result list, '%s'" % self.op_name
+            log.print_error_log(message)
+            raise CompareError(CompareError.MSACCUCMP_INVALID_INPUT_MAPPING)
+
+    def find_pre_op(self: any, result_mapping: dict) -> None:
+        """
+        Replace the input of the current operator with the previous output result
+        """
+        self.check_result_list_valid()
+        for index, input_result in enumerate(self.input_result_list):
+            if len(input_result) <= ConstManager.TENSOR_INDEX:
+                log.print_warn_log(f"Broken result, id {index}, skip")
+                continue
+
+            tensor_id = input_result[ConstManager.TENSOR_INDEX]
+            pre_op = self.op_name_origin_output_index_map.get(tensor_id)
+            if not pre_op or len(pre_op) < 2:
+                message = "The tensor index '%s' is invalid, no input mapping information" % tensor_id
+                log.print_error_log(message)
+                raise CompareError(CompareError.MSACCUCMP_INVALID_INPUT_MAPPING)
+            pre_op_name = pre_op[0]
+            pre_op_index = pre_op[1]
+            output_result = self.get_pre_op_output(pre_op_name, pre_op_index, result_mapping)
+            if not output_result:
+                continue
+            origin_result = self.result_list[index][:ConstManager.TENSOR_INDEX + 1]
+            self.result_list[index] = origin_result + output_result[ConstManager.TENSOR_INDEX + 1:]