mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/pytorch/module_processer.py

@@ -0,0 +1,98 @@
+from functools import wraps
+import torch
+from torch.utils.hooks import BackwardHook
+from msprobe.core.common.const import Const
+from msprobe.core.data_dump.scope import ModuleRangeScope
+
+
+class ModuleProcesser:
+    module_stack = []
+    api_parent_node = ""
+    module_node = {}
+    current_module_name = ""
+
+    def __init__(self, scope):
+        if isinstance(scope, ModuleRangeScope):
+            self.scope = scope
+        else:
+            self.scope = None
+        BackwardHook.setup_input_hook = ModuleProcesser.clone_return_value(BackwardHook.setup_input_hook)
+        BackwardHook.setup_output_hook = ModuleProcesser.clone_return_value(BackwardHook.setup_output_hook)
+        BackwardHook.setup_output_hook = ModuleProcesser.filter_tensor_and_tuple(BackwardHook.setup_output_hook)
+        self.module_count = {}
+
+    @staticmethod
+    def filter_tensor_and_tuple(func):
+        @wraps(func)
+        def wrap_by_filter_tensor_and_tuple(*args, **kwargs):
+            # setup_output_hook传入非tensor数据，工具后续dump会报错，处理方式是非tensor数据不传入
+            # setup_output_hook定义为setup_output_hook(self, args)，因此处理第二个位置参数，即*args[1]
+            if not isinstance(args[1], (torch.Tensor, tuple)):
+                return args[1]
+            return func(*args, **kwargs)
+
+        return wrap_by_filter_tensor_and_tuple
+
+    @staticmethod
+    def clone_return_value(func):
+        @wraps(func)
+        def clone_return_value_func(*args, **kwargs):
+            result = func(*args, **kwargs)
+            return ModuleProcesser.clone_if_tensor(result)
+
+        return clone_return_value_func
+    
+    @staticmethod
+    def clone_if_tensor(result):
+        if isinstance(result, torch.Tensor):
+            return result.clone()
+        elif isinstance(result, tuple):
+            return tuple(ModuleProcesser.clone_if_tensor(x) for x in result)
+        elif isinstance(result, list):
+            return list(ModuleProcesser.clone_if_tensor(x) for x in result)
+        elif isinstance(result, dict):
+            return {k: ModuleProcesser.clone_if_tensor(v) for k, v in result.items()}
+        else:
+            return result
+
+    def node_hook(self, name_prefix, start_or_stop, **kwargs):
+
+        def pre_hook(module, input, output=None):
+            try:
+                index = self.module_count_func(name_prefix)
+            except IndexError as e:
+                index = None
+                pass
+            module.mindstudio_reserved_name = full_name = name_prefix + Const.SEP + str(index)
+            if self.module_stack:
+                ModuleProcesser.module_node[full_name] = self.module_stack[-1]
+            else:
+                ModuleProcesser.module_node[full_name] = None
+
+            ModuleProcesser.module_stack.append(full_name)
+            if self.module_stack:
+                ModuleProcesser.api_parent_node = self.module_stack[-1]
+            if self.scope:
+                self.scope.begin_module(full_name)
+
+        def end_hook(module, input, output=None):
+            if self.module_stack:
+                ModuleProcesser.module_stack.pop()
+            if self.module_stack:
+                ModuleProcesser.api_parent_node = self.module_stack[-1]
+            else:
+                ModuleProcesser.api_parent_node = None
+            if self.scope:
+                self.scope.end_module(module.mindstudio_reserved_name)
+
+        if Const.START in start_or_stop:
+            return pre_hook
+        else:
+            return end_hook
+
+    def module_count_func(self, module_name):
+        if module_name not in self.module_count:
+            self.module_count[module_name] = 0
+        else:
+            self.module_count[module_name] += 1
+        return self.module_count[module_name]

msprobe/pytorch/online_dispatch/__init__.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2024-2024 Huawei Technologies Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from signal import signal, SIGPIPE, SIG_DFL
+from .dispatch import PtdbgDispatch
+signal(SIGPIPE, SIG_DFL)
+
+
+__all__ = ["PtdbgDispatch"]

msprobe/pytorch/online_dispatch/compare.py

@@ -0,0 +1,236 @@
+# 进行比对及结果展示
+import os
+import sys
+import csv
+import json
+from collections import namedtuple
+from rich.table import Table
+from rich.console import Console
+from .single_compare import single_benchmark_compare_wrap
+from .utils import DispatchException
+from msprobe.core.common.const import CompareConst
+from msprobe.core.common.file_check import FileOpen
+from msprobe.pytorch.common.log import logger
+from msprobe.core.common.utils import CompareException
+
+ELEMENT_NUM_THRESHOLD = 100
+ZERO_NUM_THRESHOLD = 0.1
+FLOAT_PRECISION = 14
+
+ResultInfo = namedtuple('ResultInfo', ['api_name', 'is_fwd_success', 'is_bwd_success',
+                                       'fwd_compare_alg_results', 'bwd_compare_alg_results'])
+
+def get_file_content_bytes(file):
+    with FileOpen(file, 'rb') as file_handle:
+        return file_handle.read()
+
+
+def get_json_contents(file_path):
+    ops = get_file_content_bytes(file_path)
+    try:
+        json_obj = json.loads(ops)
+    except ValueError as error:
+        logger.error('Failed to load "%s". %s' % (file_path, str(error)))
+        raise CompareException(CompareException.INVALID_FILE_ERROR) from error
+    if not isinstance(json_obj, dict):
+        logger.error('Json file %s, content is not a dictionary!' % file_path)
+        raise CompareException(CompareException.INVALID_FILE_ERROR)
+    return json_obj
+
+
+def write_csv(data, filepath):
+    with FileOpen(filepath, 'a', encoding='utf-8-sig') as f:
+        writer = csv.writer(f)
+        writer.writerows(data)
+
+
+class Saver:
+    # consts for result csv
+    COLUMN_API_NAME = "API name"
+    COLUMN_FORWARD_SUCCESS = "Forward Test Success"
+    COLUMN_BACKWARD_SUCCESS = "Backward Test Success"
+    COLUMN_STACK_INFO = "Traceback callstack info"
+
+    def __init__(self, save_path, detail_save_path, stack_info):
+        self.save_path = save_path
+        self.detail_save_path = detail_save_path
+        self.stack_info = stack_info
+
+        self.test_result_cnt = {
+            "forward_fail_num": 0, "backward_fail_num": 0, "forward_and_backward_fail_num": 0, "success_num": 0,
+            "total_num": 0, "forward_or_backward_fail_num": 0
+        }
+
+    def write_csv_title(self):
+        summary_test_rows = [[self.COLUMN_API_NAME, self.COLUMN_FORWARD_SUCCESS, self.COLUMN_BACKWARD_SUCCESS, "Message"]]
+        write_csv(summary_test_rows, self.save_path)
+
+        detail_test_rows = [[
+            "Npu Name", "Bench Dtype", "NPU Dtype", "Shape",
+            "error_balance", "max_abs_diff", "max_abs_idx",
+            "max_rel_diff", "max_rel_idx", "eb_thd",
+            "error_thd", "Status","Message"
+        ]]
+        write_csv(detail_test_rows, self.detail_save_path)
+
+    def print_pretest_result(self):
+        self.get_statistics_from_result_csv()
+        if self.test_result_cnt.get("total_num") != 0:
+            passing_rate = str(self.test_result_cnt.get("success_num") /
+                               (self.test_result_cnt.get("total_num") + sys.float_info.epsilon))
+        else:
+            passing_rate = "0"
+
+        console = Console()
+        table_total = Table(
+            show_header=True, title="Overall Statistics", show_lines=True, width=75
+        )
+        table_total.add_column("Result")
+        table_total.add_column("Statistics")
+        table_total.add_row("[green]Pass[/green]", str(self.test_result_cnt.get("success_num")))
+        table_total.add_row("[red]Fail[/red]", str(self.test_result_cnt.get("forward_and_backward_fail_num") +
+                                                   self.test_result_cnt.get("forward_or_backward_fail_num")))
+        table_total.add_row("Passing Rate", passing_rate)
+
+        table_detail = Table(
+            show_header=True, title="Detail Statistics", show_lines=True, width=75
+        )
+        table_detail.add_column("Result")
+        table_detail.add_column("Statistics")
+        table_detail.add_row("Only Forward Fail", str(self.test_result_cnt.get("forward_fail_num")))
+        table_detail.add_row("Only Backward Fail", str(self.test_result_cnt.get("backward_fail_num")))
+        table_detail.add_row(
+            "Both Forward & Backward Fail", str(self.test_result_cnt.get("forward_and_backward_fail_num")))
+
+        console.print(table_total)
+        console.print(table_detail)
+
+    def get_statistics_from_result_csv(self):
+        checklist = [CompareConst.TRUE, CompareConst.FALSE, CompareConst.NA, CompareConst.SKIP]
+        with FileOpen(self.save_path, 'r') as file:
+            reader = csv.reader(file)
+            result_csv_rows = [row for row in reader]
+        result_csv_name = os.path.basename(self.save_path)
+        for item in result_csv_rows[1:]:
+            if not isinstance(item, list) or len(item) < 3:
+                raise ValueError("The number of columns in %s is incorrect" % result_csv_name)
+            if not all(item[i] and item[i].upper() in checklist for i in (1, 2)):
+                raise ValueError(
+                    "The value in the 2nd or 3rd column of %s is wrong, it must be TRUE, FALSE, SKIP or N/A"
+                    % result_csv_name)
+            column1 = item[1].upper()
+            column2 = item[2].upper()
+            if column1 == CompareConst.SKIP:
+                continue
+            self.test_result_cnt["total_num"] += 1
+            if column1 == CompareConst.TRUE and column2 in [CompareConst.TRUE, 'N/A']:
+                self.test_result_cnt['success_num'] += 1
+            elif column1 == CompareConst.FALSE and column2 == CompareConst.FALSE:
+                self.test_result_cnt['forward_and_backward_fail_num'] += 1
+            elif column1 == CompareConst.FALSE:
+                self.test_result_cnt['forward_fail_num'] += 1
+                self.test_result_cnt['forward_or_backward_fail_num'] += 1
+            else:
+                self.test_result_cnt['backward_fail_num'] += 1
+                self.test_result_cnt['forward_or_backward_fail_num'] += 1
+
+    def write_summary_csv(self, test_result):
+        test_rows = []
+        if self.stack_info:
+            test_rows[0].append(self.COLUMN_STACK_INFO)
+
+        name = test_result.api_name
+        df_row = [test_result.api_name, test_result.is_fwd_success, test_result.is_bwd_success]
+        if test_result.is_fwd_success == "SKIP" or test_result.is_bwd_success == "SKIP":
+            df_row.append(test_result.fwd_compare_alg_results)
+        if self.stack_info:
+            stack_info = "\n".join(self.stack_info[name])
+            df_row.append(stack_info)
+        test_rows.append(df_row)
+        write_csv(test_rows, self.save_path)
+
+    def write_detail_csv(self, test_result):
+        def get_rows_from_list(result, name, sub_prefix):
+            rows = []
+            if isinstance(result, list):
+                for i, test_subject in enumerate(result):
+                    subject = sub_prefix + "." + name + ".output." + str(i)
+                    test_subject = ["{:.{}f}".format(item, FLOAT_PRECISION) if isinstance(item, float) else item for
+                                    item in test_subject]
+                    rows.append([subject] + list(test_subject))
+            return rows
+
+        test_rows = []
+        subject_prefix = test_result.api_name
+        fwd_result = test_result.fwd_compare_alg_results
+        bwd_result = test_result.bwd_compare_alg_results
+
+        test_rows.extend(get_rows_from_list(fwd_result, "forward", subject_prefix))
+        test_rows.extend(get_rows_from_list(bwd_result, "backward", subject_prefix))
+
+        write_csv(test_rows, self.detail_save_path)
+
+    def record_results(self, result_info):
+        self.write_summary_csv(result_info)
+        self.write_detail_csv(result_info)
+
+
+class Comparator:
+
+    def __init__(self, result_csv_path, details_csv_path, is_continue_run_ut, stack_info_json_path=None):
+        self.save_path = result_csv_path
+        self.detail_save_path = details_csv_path
+        if stack_info_json_path:
+            self.stack_info = get_json_contents(stack_info_json_path)
+        else:
+            self.stack_info = None
+        self.saver = Saver(result_csv_path, details_csv_path, self.stack_info)
+
+        if is_continue_run_ut and not os.path.exists(self.save_path) and not os.path.exists(self.detail_save_path):
+            self.saver.write_csv_title()
+
+    @staticmethod
+    def _compare_core_wrapper(bench_out, npu_out):
+        detailed_result_total = []
+        test_final_success = True
+        status, details = single_benchmark_compare_wrap(npu_out, bench_out)
+        if not isinstance(status, list):
+            detailed_result_total.append(details)
+            test_final_success = status
+        else:
+            for item, item_status in enumerate(status):
+                detailed_result_total.append(details.get(item, 'key does not exist'))
+                if not item_status:
+                    test_final_success = False
+        return test_final_success, detailed_result_total
+
+    @staticmethod
+    def _compare_dropout(bench_out, npu_out):
+        tensor_num = bench_out.numel()
+        if tensor_num >= ELEMENT_NUM_THRESHOLD:
+            if abs((bench_out == 0).sum() - (npu_out == 0).cpu().sum()) / tensor_num < ZERO_NUM_THRESHOLD:
+                return True, 1
+            else:
+                return False, 0
+        else:
+            return True, 1
+
+    def compare_output(self, api_name, bench_out, npu_out, bench_grad=None, npu_grad=None):
+        if "dropout" in api_name:
+            is_fwd_success, fwd_compare_alg_results = self._compare_dropout(bench_out, npu_out)
+        else:
+            is_fwd_success, fwd_compare_alg_results = self._compare_core_wrapper(bench_out, npu_out)
+        if bench_grad and npu_grad:
+            if "dropout" in api_name:
+                is_bwd_success, bwd_compare_alg_results = self._compare_dropout(bench_grad[0], npu_grad[0])
+            else:
+                is_bwd_success, bwd_compare_alg_results = self._compare_core_wrapper(bench_grad, npu_grad)
+        else:
+            is_bwd_success, bwd_compare_alg_results = True, None
+        if is_bwd_success and bwd_compare_alg_results is None:
+            self.saver.record_results(ResultInfo(api_name, is_fwd_success, CompareConst.NA, fwd_compare_alg_results,
+                                      bwd_compare_alg_results))
+        else:
+            self.saver.record_results(ResultInfo(api_name, is_fwd_success, is_bwd_success, fwd_compare_alg_results,
+                                      bwd_compare_alg_results))
+        return is_fwd_success, is_bwd_success

msprobe/pytorch/online_dispatch/dispatch.py

@@ -0,0 +1,274 @@
+import os
+import time
+import json
+from pathlib import Path
+from multiprocessing import Manager, Pool
+
+import yaml
+import torch
+
+from torch.utils._python_dispatch import TorchDispatchMode
+
+try:
+    import torch_npu
+except ImportError:
+    is_npu = False
+else:
+    is_npu = True
+
+from .dump_compare import dispatch_workflow, dispatch_multiprocess, error_call, TimeStatistics, \
+    DispatchRunParam, DisPatchDataInfo
+from .utils import get_callstack, data_to_cpu, logger_debug, logger_error, logger_warn, logger_logo, get_sys_info, \
+    DispatchException
+from .compare import Comparator
+from msprobe.core.common.file_check import FileOpen
+from msprobe.core.common.utils import check_file_or_directory_path, check_path_before_create
+from msprobe.core.common.const import Const, CompareConst
+
+current_time = time.strftime("%Y%m%d%H%M%S")
+RESULT_FILE_NAME = "accuracy_checking_result_" + current_time + ".csv"
+DETAILS_FILE_NAME = "accuracy_checking_details_" + current_time + ".csv"
+
+
+class PtdbgDispatch(TorchDispatchMode):
+    def __init__(self, dump_mode=Const.OFF, api_list=None, debug=False, dump_path=None, tag=None, process_num=0):
+        super(PtdbgDispatch, self).__init__()
+        logger_logo()
+        if not is_npu:
+            logger_error("Please confirm you run environment installed torch_npu!")
+            return
+        if dump_path is None:
+            logger_error("Please set dump_path when dump_mode is config!")
+        check_file_or_directory_path(dump_path, True)
+
+        self.device_id = torch_npu._C._npu_getDevice()
+        self.dump_mode = dump_mode
+        self.dump_api_list = api_list
+        self.debug_flag = debug
+        self.api_index = 0
+        self.single_api_index_dict = {}
+        self.device_dump_path_cpu = None
+        self.device_dump_path_npu = None
+        self.all_summery = []
+        self.call_stack_list = []
+        self.process_num = process_num
+        self.filter_dump_api()
+        self.check_param()
+        dir_name = self.get_dir_name(tag)
+        self.root_path = os.path.join(os.path.realpath(dump_path), dir_name)
+        self.root_cpu_path = os.path.join(self.root_path, f'cpu')
+        self.root_npu_path = os.path.join(self.root_path, f'npu')
+        check_path_before_create(self.root_cpu_path)
+        check_path_before_create(self.root_npu_path)
+        Path(self.root_cpu_path).mkdir(mode=0o750, parents=True, exist_ok=True)
+        Path(self.root_npu_path).mkdir(mode=0o750, parents=True, exist_ok=True)
+
+        self.result_csv_path = os.path.join(self.root_path, RESULT_FILE_NAME)
+        self.detail_csv_path = os.path.join(self.root_path, DETAILS_FILE_NAME)
+        self.comparator = Comparator(self.result_csv_path, self.detail_csv_path, False)
+
+        self.aten_ops_blacklist = []
+        self.npu_adjust_autogard = []
+        yaml_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "torch_ops_config.yaml")
+        self.load_yaml_file(yaml_path)
+
+        self.lock = None
+        if process_num > 0:
+            self.pool = Pool(process_num)
+        if debug:
+            logger_debug(f'Main pid:{os.getpid()} device:{self.device_id} dump_list:{self.dump_api_list} '
+                         f'dump_mode:{self.dump_mode} cpu_path[{self.root_cpu_path}], npu_path[{self.root_npu_path}], '
+                         f'process[{process_num}]')
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        super().__exit__(exc_type, exc_val, exc_tb)
+
+        if not is_npu:
+            return
+        logger_debug(f'start write compare csv: Rank[{self.device_id}], Pid[{os.getpid()}')
+
+        if self.process_num > 0:
+            self.pool.close()
+            self.pool.join()
+            summery_path = os.path.join(self.root_cpu_path, f'summary.json')
+            if not os.path.exists(summery_path):
+                logger_error("Please check train log, An exception may have occurred!")
+                return
+            check_file_or_directory_path(summery_path, False)
+            fp_handle = open(summery_path, "r")
+            while True:
+                json_line_data = fp_handle.readline()
+                if json_line_data == '\n':
+                    continue
+                if len(json_line_data) == 0:
+                    break
+                msg = json.loads(json_line_data)
+                self.all_summery[msg[0]] = msg[1]
+            fp_handle.close()
+
+        if self.debug_flag:
+            input_num = 0
+            output_num = 0
+            total_num = 0
+
+            for list_data in self.all_summery:
+                for data in list_data:
+                    logger_debug(f'summery: Device[{self.device_id}], Pid[{os.getpid()}], Data[{data}]')
+                    if "_input" in data[CompareConst.NPU_NAME]:
+                        input_num = input_num + 1
+                    if "_output" in data[CompareConst.NPU_NAME]:
+                        output_num = output_num + 1
+                    total_num = total_num + 1
+            logger_debug(f'Dispatch exit: Device[{self.device_id}], Pid[{os.getpid()} Input[{input_num}] '
+                         f'Output[{output_num}] Total[{total_num}] API_Total[{self.api_index}]]')
+
+    def __torch_dispatch__(self, func, types, args=(), kwargs=None):
+        if not is_npu:
+            logger_error("Please confirm you run environment installed torch_npu!")
+            return func(*args, **kwargs)
+
+        func_name_split_list = func.__name__.split(".")
+        aten_api = func_name_split_list[0]
+        try:
+            aten_api_overload_name = func_name_split_list[1]
+        except IndexError:
+            logger_error(f"Please check the func name {func.__name__}!")
+            return func(*args, **kwargs)
+
+        self.enable_autogard(aten_api)
+        if aten_api in self.aten_ops_blacklist:
+            npu_out = func(*args, **kwargs)
+            return npu_out
+
+        call_stack = get_callstack()
+        self.call_stack_list.append(call_stack)
+        self.api_index += 1
+        if aten_api not in self.single_api_index_dict:
+            self.single_api_index_dict[aten_api] = 1
+        else:
+            self.single_api_index_dict[aten_api] += 1
+
+        run_param = self.get_run_param(aten_api, func.__name__, aten_api_overload_name)
+
+        if self.debug_flag:
+            logger_debug(f'Dispatch Info: Rank[{self.device_id}], Pid[{os.getpid()}], Func[{func.__name__}], '
+                         f'Name[{run_param.aten_api}_{run_param.single_api_index}], '
+                         f'Count[{self.api_index}], Sys[{get_sys_info()}]')
+
+        cpu_args = []
+        cpu_kwargs = []
+        data_to_cpu(args, 0, cpu_args)
+        data_to_cpu(kwargs, 0, cpu_kwargs)
+        cpu_args = cpu_args[0]
+        cpu_kwargs = cpu_kwargs[0]
+
+        with TimeStatistics("NPU RUN", run_param):
+            npu_out = func(*args, **kwargs)
+        npu_out_cpu = []
+        data_to_cpu(npu_out, 0, npu_out_cpu)
+        npu_out_cpu = npu_out_cpu[0]
+
+        with TimeStatistics("CPU RUN", run_param):
+            cpu_out = func(*cpu_args, **cpu_kwargs)
+
+        if isinstance(cpu_out, torch.Tensor) and cpu_out.dtype in [torch.bfloat16, torch.float16, torch.half]:
+            cpu_out = cpu_out.float()
+
+        if self.process_num == 0:
+            self.all_summery.append([])
+            data_info = DisPatchDataInfo(cpu_args, cpu_kwargs, self.all_summery, func, npu_out_cpu, cpu_out, self.lock)
+            dispatch_workflow(run_param, data_info)
+        else:
+            self.lock.acquire()
+            self.all_summery.append([])
+            self.lock.release()
+            run_param.process_flag = True
+            if self.check_fun(func, run_param):
+                data_info = DisPatchDataInfo(cpu_args, cpu_kwargs, self.all_summery, None, npu_out_cpu, cpu_out,
+                                             self.lock)
+                self.pool.apply_async(func=dispatch_multiprocess, args=(run_param, data_info),
+                                      error_callback=error_call)
+            else:
+                logger_error("can not get correct function please set process_num=0")
+        return npu_out
+
+    @staticmethod
+    def check_fun(func, run_param):
+        if hasattr(torch.ops.aten, run_param.aten_api):
+            aten_func = getattr(torch.ops.aten, run_param.aten_api)
+            if hasattr(aten_func, run_param.aten_api_overload_name):
+                aten_overload_func = getattr(aten_func, run_param.aten_api_overload_name)
+                if id(aten_overload_func) == id(func):
+                    run_param.func_namespace = "aten"
+                    return True
+        return False
+
+    def get_dir_name(self, tag):
+        # guarantee file uniqueness
+        time.sleep(1)
+        time_now = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
+        if tag is None or not isinstance(tag, str):
+            logger_warn('There is not tag or the type of tag is not string.')
+            dir_name = f'msprobe_rank{self.device_id}_{time_now}'
+        else:
+            dir_name = f'msprobe_{tag}_rank{self.device_id}_{time_now}'
+        return dir_name
+
+    def load_yaml_file(self, file_path):
+        with FileOpen(file_path, 'r') as f:
+            yaml_file = yaml.safe_load(f)
+            self.aten_ops_blacklist = yaml_file.get('aten_ops_blacklist')
+            self.npu_adjust_autogard = yaml_file.get('npu_adjust_autogard')
+
+    def filter_dump_api(self):
+        if self.dump_mode != Const.LIST or not self.dump_api_list:
+            self.dump_api_list = []
+            return
+        aten_api_list = dir(torch.ops.aten)
+        dump_api_list = []
+        for aten_api in self.dump_api_list:
+            if aten_api in aten_api_list:
+                dump_api_list.append(aten_api)
+            else:
+                logger_warn(f'{aten_api} is not aten api will not dump, please refer to torch.ops.aten')
+        self.dump_api_list = dump_api_list
+
+    def get_run_param(self, aten_api, func_name, aten_api_overload_name):
+        run_param = DispatchRunParam(self.debug_flag, self.device_id, self.root_npu_path, self.root_cpu_path,
+                                     self.process_num, self.comparator)
+        run_param.dump_flag, run_param.auto_dump_flag = self.get_dump_flag(aten_api)
+        run_param.func_name = func_name
+        run_param.aten_api = aten_api
+        run_param.aten_api_overload_name = aten_api_overload_name
+        run_param.single_api_index = self.single_api_index_dict[aten_api]
+        run_param.api_index = self.api_index
+        return run_param
+
+    def get_dump_flag(self, aten_api):
+        dump_flag = False
+        auto_dump_flag = False
+        if self.dump_mode == Const.ALL:
+            dump_flag = True
+        if self.dump_mode == Const.LIST and aten_api in self.dump_api_list:
+            dump_flag = True
+        if self.dump_mode == Const.AUTO:
+            auto_dump_flag = True
+        return dump_flag, auto_dump_flag
+
+    def check_param(self):
+        if self.dump_mode not in Const.ONLINE_DUMP_MODE:
+            logger_error('The parameter "dump mode" can only be one of {}.'.format(Const.ONLINE_DUMP_MODE))
+            raise DispatchException(DispatchException.INVALID_PARAMETER)
+        if not isinstance(self.dump_api_list, list):
+            logger_error('The type of parameter "api_list" can only be list.')
+            raise DispatchException(DispatchException.INVALID_PARAMETER)
+        if not isinstance(self.debug_flag, bool):
+            logger_error('The type of parameter "debug" can only be bool.')
+            raise DispatchException(DispatchException.INVALID_PARAMETER)
+        if not isinstance(self.process_num, int) or self.process_num < 0:
+            logger_error('The type of parameter "process_num" can only be int and it should not be less than 0.')
+            raise DispatchException(DispatchException.INVALID_PARAMETER)
+
+    def enable_autogard(self, aten_api):
+        if aten_api in self.npu_adjust_autogard:
+            torch._C._dispatch_tls_set_dispatch_key_excluded(torch._C.DispatchKey.AutogradFunctionality, False)