mindstudio-probe 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

msprobe/pytorch/common/utils.py

@@ -14,13 +14,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """
+import logging
 import os
 import random
 import stat
+import csv
+import json
 import torch
+import torch.distributed as dist
 import numpy as np
 from functools import wraps
 from msprobe.core.common.exceptions import DistributedNotInitializedError
+from msprobe.core.common.log import logger as common_logger
+from msprobe.core.common.utils import check_file_or_directory_path, check_path_before_create, CompareException
+from msprobe.core.common.file_check import FileCheckConst, change_mode, FileOpen
+
 
 try:
     import torch_npu
@@ -30,13 +38,8 @@ else:
     is_gpu = False
 
 
-torch_without_guard_version_list = ['2.1', '2.2']
-for version in torch_without_guard_version_list:
-    if torch.__version__.startswith(version):
-        torch_without_guard_version = True
-        break
-    else:
-        torch_without_guard_version = False
+torch_without_guard_version = torch.__version__ >= '2.1'
+
 
 if not is_gpu and not torch_without_guard_version:
     from torch_npu.utils.device_guard import torch_device_guard as torch_npu_device_guard
@@ -222,3 +225,76 @@ class Const:
     CONVERT_API = {
         "int32_to_int64": ["cross_entropy"]
     }
+
+
+def get_tensor_rank(in_feat, out_feat):
+    if dist.is_initialized():
+        return dist.get_rank()
+
+    def get_tensor_rank_single(x):
+        if isinstance(x, (list, tuple)):
+            if len(x) > 0:
+                return get_tensor_rank_single(x[0])
+        elif isinstance(x, torch.Tensor):
+            device = x.device
+            if device.type != 'cpu':
+                return device.index
+        return None
+
+    in_rank = get_tensor_rank_single(in_feat)
+    out_rank = get_tensor_rank_single(out_feat)
+    tensor_rank = in_rank if in_rank else out_rank
+    return tensor_rank
+
+
+def get_rank_id():
+    if torch.distributed.is_initialized():
+        return torch.distributed.get_rank()
+    return 0
+
+
+def print_rank_0(message):
+    if dist.is_initialized():
+        if dist.get_rank() == 0:
+            logger.info(message)
+    else:
+        logger.info(message)
+        
+
+def load_pt(pt_path, to_cpu=False):
+    pt_path = os.path.realpath(pt_path)
+    check_file_or_directory_path(pt_path)
+    try:
+        if to_cpu:
+            pt = torch.load(pt_path, map_location=torch.device("cpu"))
+        else:
+            pt = torch.load(pt_path)
+    except Exception as e:
+        raise RuntimeError(f"load pt file {pt_path} failed") from e
+    return pt
+
+
+def save_pt(tensor, filepath):
+    filepath = os.path.realpath(filepath)
+    check_path_before_create(filepath)
+    try:
+        torch.save(tensor, filepath)
+    except Exception as e:
+        common_logger.error("Save pt file failed, please check according possible error causes: "
+                            "1. out of disk space or disk error, "
+                            "2. no permission to write files, etc.")
+        raise RuntimeError(f"save pt file {filepath} failed") from e
+    change_mode(filepath, FileCheckConst.DATA_FILE_AUTHORITY)
+
+
+def _create_logger(level=logging.INFO):
+    logger_ = logging.getLogger()
+    logger_.setLevel(level)
+    ch = logging.StreamHandler()
+    ch.setLevel(level)
+    logger_.addHandler(ch)
+    return logger_
+
+    
+log_level = logging.DEBUG if os.environ.get("API_ACCURACY_CHECK_LOG_LEVEL") == "1" else logging.INFO
+logger = _create_logger(log_level)

msprobe/pytorch/compare/distributed_compare.py

@@ -15,62 +15,17 @@
 # limitations under the License.
 """
 import os
-import sys
-import re
 from msprobe.core.common.utils import CompareException, check_compare_param, \
-    check_configuration_param, task_dumppath_get, check_file_or_directory_path, check_regex_prefix_format_valid
-from msprobe.pytorch.compare.acc_compare import compare_core
+    check_configuration_param, task_dumppath_get
 from msprobe.core.common.file_check import create_directory
-from msprobe.pytorch.common.log import logger
+from msprobe.core.common.exceptions import FileCheckException
+from msprobe.core.common.log import logger
+from msprobe.core.common.const import Const
+from msprobe.pytorch.compare.pt_compare import PTComparator
+from msprobe.core.compare.utils import check_and_return_dir_contents, extract_json
 
 
 def compare_distributed(npu_dump_dir, bench_dump_dir, output_path, **kwargs):
-    def check_and_return_dir_contents(dump_dir, prefix):
-        """
-        check the given dump dir and validate files in dump dir by using the given prefix patterns to build a
-        pattern: ^{prefix}(?:0|[0-9][1-9]*)?$
-
-        Args:
-            dump_dir (str): dump dir
-            prefix (str): prefix for the patterns, prefix should be less than 20 characters and alphanumeric/-/_ only
-
-        Returns:
-            content [list]: dir contents
-        Raises:
-            CompareException: invalid path
-            ValueError: prefix not match the patterns
-
-        """
-        check_regex_prefix_format_valid(prefix)
-        check_file_or_directory_path(dump_dir, True)
-        contents = os.listdir(dump_dir)
-        pattern = re.compile(rf'^{prefix}(?:0|[0-9][1-9]*)?$')
-        for name in contents:
-            if not pattern.match(name):
-                logger.error(
-                    f"dump_dir contains '{name}'. Expected '{prefix}'. This name is not in the format of dump "
-                    f"output. Please check and delete irrelevant files in {dump_dir} and try again."
-                )
-                raise CompareException(CompareException.INVALID_PATH_ERROR)
-        return contents
-
-    def extract_json(dirname, stack_json=False):
-        json_path = ''
-        for fname in os.listdir(dirname):
-            full_path = os.path.join(dirname, fname)
-            if full_path.endswith('.json'):
-                json_path = full_path
-                if not stack_json and 'stack' not in json_path:
-                    break
-                if stack_json and 'stack' in json_path:
-                    break
-
-        # Provide robustness on invalid directory inputs
-        if not json_path:
-            logger.error(f'No file is found in dump dir {dirname}. ')
-            raise CompareException(CompareException.NO_DUMP_FILE_ERROR)
-        return json_path
-
     if kwargs.get('suffix'):
         logger.error("Argument 'suffix' is not supported for compare_distributed.")
         raise CompareException(CompareException.INVALID_PARAM_ERROR)
@@ -86,26 +41,26 @@ def compare_distributed(npu_dump_dir, bench_dump_dir, output_path, **kwargs):
                         'or use compare() api and manually match the ranks.')
         raise CompareException(CompareException.INVALID_PATH_ERROR)
     for nr, br in zip(npu_ranks, bench_ranks):
-        n_dir = os.path.join(npu_dump_dir, nr)
-        b_dir = os.path.join(bench_dump_dir, br)
-        s_dir = b_dir
-        npu_json_path = extract_json(n_dir, stack_json=False)
-        bench_json_path = extract_json(b_dir, stack_json=False)
-        stack_json_path = extract_json(s_dir, stack_json=True)
+        npu_data_dir = os.path.join(npu_dump_dir, nr)
+        bench_data_dir = os.path.join(bench_dump_dir, br)
+        npu_path = extract_json(npu_data_dir, stack_json=False)
+        bench_path = extract_json(bench_data_dir, stack_json=False)
+        stack_path = extract_json(npu_data_dir, stack_json=True)
 
         dump_result_param = {
-            'npu_json_path': npu_json_path,
-            'bench_json_path': bench_json_path,
-            'stack_json_path': stack_json_path,
+            'npu_json_path': npu_path,
+            'bench_json_path': bench_path,
+            'stack_json_path': stack_path,
             'is_print_compare_log': True
         }
         try:
             summary_compare, md5_compare = task_dumppath_get(dump_result_param)
             check_configuration_param(stack_mode, auto_analyze, fuzzy_match)
             create_directory(output_path)
-            check_compare_param(dump_result_param, output_path, stack_mode=stack_mode, summary_compare=summary_compare)
-        except CompareException as error:
+            check_compare_param(dump_result_param, output_path, summary_compare=summary_compare, md5_compare=md5_compare)
+        except (CompareException, FileCheckException) as error:
             logger.error('Compare failed. Please check the arguments and do it again!')
-            sys.exit(error.code)
-        compare_core(dump_result_param, output_path, suffix=f'_{nr}-{br}', summary_compare=summary_compare,
+            raise CompareException(error.code) from error
+        pt_comparator = PTComparator()
+        pt_comparator.compare_core(dump_result_param, output_path, suffix=f'_{nr}-{br}', summary_compare=summary_compare,
                      md5_compare=md5_compare, **kwargs)

msprobe/pytorch/compare/match.py

@@ -1,16 +1,13 @@
 import os
-import yaml
-from msprobe.core.common.file_check import FileOpen
-from msprobe.core.common.utils import CompareException
+from msprobe.core.common.utils import CompareException, load_yaml
 
 
 class AtenIrMapping():
     def __init__(self):
         cur_path = os.path.dirname(os.path.realpath(__file__))
         yaml_path = os.path.join(cur_path, "mapping.yaml")
-        with FileOpen(yaml_path, 'r') as f:
-            self.aten_mapping = yaml.safe_load(f)
-
+        self.aten_mapping = load_yaml(yaml_path)
+    
     def match(self, op1, op2):
         if "Aten" in op1 and "Aten" not in op2:
             return self.match_op(op1, op2)

msprobe/pytorch/compare/pt_compare.py

@@ -0,0 +1,40 @@
+import os.path
+import torch
+from msprobe.core.common.const import FileCheckConst, Const
+from msprobe.core.common.log import logger
+from msprobe.core.common.exceptions import FileCheckException
+from msprobe.core.compare.acc_compare import Comparator 
+from msprobe.core.common.utils import create_directory, check_configuration_param, task_dumppath_get, \
+    check_compare_param, FileChecker
+from msprobe.core.common.utils import CompareException
+
+
+class PTComparator (Comparator):
+    def __init__(self):
+        self.frame_name = PTComparator.__name__
+    
+    def read_npy_data(self, dir_path, file_name):
+        data_path = os.path.join(dir_path, file_name)
+        path_checker = FileChecker(data_path, FileCheckConst.FILE, FileCheckConst.READ_ABLE,
+                                FileCheckConst.PT_SUFFIX, False)
+        data_path = path_checker.common_check()
+        data_value = torch.load(data_path, map_location=torch.device('cpu')).detach()       # detach for less memory
+        if data_value.dtype == torch.bfloat16:
+            data_value = data_value.to(torch.float32)
+        data_value = data_value.numpy()
+        return data_value  
+    
+    
+def compare(input_param, output_path, stack_mode=False, auto_analyze=True, fuzzy_match=False):
+    try:
+        summary_compare, md5_compare = task_dumppath_get(input_param)
+        check_configuration_param(stack_mode, auto_analyze, fuzzy_match)
+        create_directory(output_path)
+        check_compare_param(input_param, output_path, summary_compare, md5_compare)
+    except (CompareException, FileCheckException) as error:
+        logger.error('Compare failed. Please check the arguments and do it again!')
+        raise CompareException(error.code) from error
+    pt_comparator = PTComparator()
+    pt_comparator.compare_core(input_param, output_path, stack_mode=stack_mode,
+                 auto_analyze=auto_analyze, fuzzy_match=fuzzy_match, summary_compare=summary_compare,
+                 md5_compare=md5_compare)

msprobe/pytorch/debugger/debugger_config.py

@@ -21,7 +21,7 @@ class DebuggerConfig:
         self.acl_config = common_config.acl_config if common_config.acl_config else ""
         self.is_forward_acl_dump = True
         self.summary_mode = task_config.summary_mode if task_config.summary_mode else Const.STATISTICS
-        self.overflow_num = task_config.overflow_num if task_config.overflow_num else 1
+        self.overflow_nums = task_config.overflow_nums if task_config.overflow_nums else 1
         self.framework = Const.PT_FRAMEWORK
 
         if self.task == Const.FREE_BENCHMARK:
@@ -35,7 +35,16 @@ class DebuggerConfig:
                 "preheat_step": task_config.preheat_step if task_config.preheat_step else 15, 
                 "max_sample": task_config.max_sample if task_config.max_sample else 20, 
             }
-            
+
+        self.online_run_ut = False
+        if self.task == Const.TENSOR:
+            # dump api tensor and collaborate with online run_ut
+            self.online_run_ut = task_config.online_run_ut if task_config.online_run_ut else False
+            self.nfs_path = task_config.nfs_path if task_config.nfs_path else ""
+            self.tls_path = task_config.tls_path if task_config.tls_path else ""
+            self.host = task_config.host if task_config.host else ""
+            self.port = task_config.port if task_config.port else -1
+
         self.check()
         if self.step:
             self.step.sort()

msprobe/pytorch/debugger/precision_debugger.py

@@ -4,11 +4,14 @@ from msprobe.pytorch.debugger.debugger_config import DebuggerConfig
 from msprobe.pytorch.service import Service
 from msprobe.pytorch.common.log import logger
 from msprobe.pytorch.pt_config import parse_json_config
-from msprobe.core.common.exceptions import MsaccException
+from msprobe.core.common.exceptions import MsprobeException
+from msprobe.core.common.const import Const
+from msprobe.pytorch.grad_probe.grad_monitor import GradientMonitor
 
 
 class PrecisionDebugger:
     _instance = None
+    tasks_not_need_debugger = [Const.GRAD_PROBE]
 
     def __new__(cls, *args, **kwargs):
         if cls._instance is None:
@@ -27,9 +30,14 @@ class PrecisionDebugger:
         step=None,
     ):
         if not hasattr(self, "initialized"):
+            self.api_origin = False
             self.initialized = True
             self.model = self.check_model_valid(model)
             common_config, task_config = parse_json_config(config_path, task)
+            self.task = common_config.task
+            if self.task == Const.GRAD_PROBE:
+                self.gm = GradientMonitor(common_config, task_config)
+                return
             if step:
                 common_config.step = step
             self.config = DebuggerConfig(
@@ -50,23 +58,35 @@ class PrecisionDebugger:
     def check_model_valid(model):
         if not model or isinstance(model, torch.nn.Module):
             return model
-        raise MsaccException(
-            MsaccException.INVALID_PARAM_ERROR, "model 参数必须是torch.nn.Module类型。"
+        raise MsprobeException(
+            MsprobeException.INVALID_PARAM_ERROR, "model 参数必须是torch.nn.Module类型。"
         )
 
     @classmethod
     def start(cls):
         instance = cls._instance
+        if instance.task in PrecisionDebugger.tasks_not_need_debugger:
+            return
         if not instance:
             raise Exception("No instance of PrecisionDebugger found.")
         if instance.enable_dataloader:
             logger.warning_on_rank_0("DataLoader is enabled, start() skipped.")
         else:
-            instance.service.start(instance.model)
+            instance.service.start(instance.model, instance.api_origin)
+            instance.api_origin = False
+
+    # 指定代码段dump前反向结束符，之后的计算过程数据将被忽略，无法被dump
+    @classmethod
+    def forward_backward_dump_end(cls):
+        instance = cls._instance
+        instance.service.forward_backward_dump_end()
+        instance.api_origin = True
 
     @classmethod
     def stop(cls):
         instance = cls._instance
+        if instance.task in PrecisionDebugger.tasks_not_need_debugger:
+            return
         if not instance:
             raise Exception("PrecisionDebugger instance is not created.")
         if instance.enable_dataloader:
@@ -76,10 +96,20 @@ class PrecisionDebugger:
 
     @classmethod
     def step(cls):
+        if cls._instance.task in PrecisionDebugger.tasks_not_need_debugger:
+            return
         if not cls._instance:
             raise Exception("PrecisionDebugger instance is not created.")
         cls._instance.service.step()
 
+    @classmethod
+    def monitor(cls, model):
+        if not cls._instance:
+            raise Exception("PrecisionDebugger instance is not created.")
+        if cls._instance.task != Const.GRAD_PROBE:
+            return
+        cls._instance.gm.monitor(model)
+
 
 def iter_tracer(func):
     def func_wrapper(*args, **kwargs):

msprobe/pytorch/doc/api_accuracy_checker.md

@@ -8,7 +8,7 @@
 
 **真实数据模式**：精度预检工具支持随机生成模式和真实数据模式，即在预检dump时可以选择由工具构造随机数进行输入获得dump数据或选择获取真实输入数据进行预检dump操作；随机生成模式执行效率高，可以快速获得结果，但数据精度低，只能大致判断精度问题；真实数据模式执行效率略低于随机生成模式，但是数据精度高，可以准确判断精度问题。
 
-**工具支持PyTorch版本**：2.0/2.1/2.2。
+**工具支持PyTorch版本**：1.11/2.0/2.1/2.2。
 
 **工具特性**
 
@@ -21,7 +21,7 @@
 精度预检操作流程如下：
 
 1. 在NPU和GPU环境下分别安装msprobe工具。详见《[MindStudio精度调试工具](../../README.md)》的“工具安装”章节。
-2. 在NPU训练脚本内添加msprobe工具dump接口PrecisionDebugger采集待预检数据。详见《[精度数据采集](./dump.md)》。
+2. 在NPU训练脚本内添加msprobe工具dump接口PrecisionDebugger，采集待预检数据。详见《[精度数据采集](./dump.md)》，注意需要配置level="L1"。
 3. 将NPU环境下dump的预检数据拷贝至GPU环境。
 4. 在NPU和GPU环境下分别执行run_ut，生成结果用于最终api_precision_compare操作的输入。详见“**run_ut预检操作**”。
 5. 将NPU和GPU执行run_ut生成的`accuracy_checking_details_{timestamp}.csv`结果文件拷贝至同一环境下。
@@ -51,10 +51,12 @@ run_ut预检操作包括如下场景：
    | -api_info或--api_info_file   | 指定API信息文件dump.json。                                   | 是                                 |
    | -save_error_data             | 保存精度未达标的API输入输出数据。                            | 否                                 |
    | -o或--out_path               | 指定run_ut执行结果存盘路径，默认“./”（相对于run_ut的路径）。 | 否                                 |
+   |                              |                                                              |                                    |
    | -j或--jit_compile            | 开启jit编译。                                                | 否                                 |
    | -d或--device                 | 指定Device ID，选择UT代码运行所在的卡，默认值为0。           | 否                                 |
    | -csv_path或--result_csv_path | 指定本次运行中断时生成的`accuracy_checking_result_{timestamp}.csv`文件路径，执行run_ut中断时，若想从中断处继续执行，配置此参数即可。需要指定为上次中断的`accuracy_checking_result_{timestamp}.csv`文件。详见“**断点续检**”。 | run_ut操作中断后继续执行场景下必选 |
    | -f或--filter_api             | 过滤模型中除最大值和最小值以外其他参数和结构相同的API。适用于模型较大且重复API较多的场景。 | 否                                 |
+   | -config或--config_path       | 指定预检操作过程中的额外配置（包括黑名单、白名单等）的[config.json](https://gitee.com/ascend/mstt/tree/master/debug/accuracy_tools/msprobe/config)文件，默认未配置。config.json文件的配置可参考《[配置文件说明](https://gitee.com/ascend/mstt/blob/master/debug/accuracy_tools/msprobe/config/README.md#pytorch场景task配置为run_ut)》。 | 否                                 |
    
    run_ut执行结果包括`accuracy_checking_result_{timestamp}.csv`和`accuracy_checking_details_{timestamp}.csv`两个文件。`accuracy_checking_result_{timestamp}.csv`是API粒度的，标明每个API是否通过测试。建议用户先查看`accuracy_checking_result_{timestamp}.csv`文件，对于其中没有通过测试的或者特定感兴趣的API，根据其API name字段在`accuracy_checking_details_{timestamp}.csv`中查询其各个输出的达标情况以及比较指标。详细介绍请参见“**预检结果**”。
    
@@ -64,7 +66,7 @@ run_ut预检操作包括如下场景：
    msprobe -f pytorch run_ut -api_info ./dump.json -save_error_data
    ```
 
-   数据默认会存盘到'./ut_error_data{timestamp}'路径下（相对于启动run_ut的路径），有需要的话，用户可以通过修改mstt/debug/accuracy_tools/api_accuracy_checker目录下，config.yaml文件的error_data_path参数来配置保存路径，详见“config.yaml文件说明”。
+   数据默认会存盘到'./ut_error_data{timestamp}'路径下（相对于启动run_ut的路径），有需要的话，用户可以通过error_data_path参数来配置保存路径，error_data_path参数在[config.json](https://gitee.com/ascend/mstt/tree/master/debug/accuracy_tools/msprobe/config)文件或config.yaml文件配置，config.json文件需要在run_ut操作时通过-config参数指定，config.yaml文件详见“**config.yaml文件说明**”。
 
 #### 使用multi_run_ut.py执行多线程预检
 
@@ -99,23 +101,65 @@ msprobe -f pytorch multi_run_ut -api_info ./dump.json -n 32 -d 0 1 2 3
 msprobe -f pytorch run_ut -api_info ./dump.json -csv_path /home/xxx/ut/accuracy_checking_result_{timestamp}.csv
 ```
 
-#### API预检白名单
+#### API预检黑名单和白名单
 
-run_ut过程支持API预检白名单，操作方式如下：
+run_ut过程支持API预检黑名单和白名单，通过如下文件配置black_list（黑名单）或white_list（白名单）参数来指定不需要或需要预检的API名称：
 
-修改mstt/debug/accuracy_tools/api_accuracy_checker目录下config.yaml文件的white_list参数，配置需要预检的API名称，详见“config.yaml文件说明”。
+- 配置[config.json](https://gitee.com/ascend/mstt/tree/master/debug/accuracy_tools/msprobe/config)文件，config.json文件需要在run_ut操作时通过-config参数指定。
+- 配置config.yaml文件，详见“**config.yaml文件说明**”。
+
+config.json文件的优先级高于config.yaml文件，即执行config.json文件时，config.yaml文件的配置不生效。
 
 ### config.yaml文件说明
 
-config.yaml文件可以通过配置参数来控制dump和run_ut操作的白名单等功能。
+config.yaml文件可以通过配置参数来控制dump和run_ut操作的白名单、黑名单等功能。操作步骤如下：
+
+1. 查找msprobe工具安装路径。
+
+   ```bash
+   pip show mindstudio-probe
+   ```
+
+   输出结果如下示例：
+
+   ```bash
+   Name: mindstudio-probe
+   Version: 1.0
+   Summary: This is a pytorch precision comparison tools
+   Home-page:
+   Author:
+   Author-email:
+   License:
+   Location: /home/xx/anaconda3/envs/pt21py38/lib/python3.8/site-packages
+   Requires: numpy, openpyxl, pandas, pyyaml, rich, tqdm, wheel
+   Required-by:
+   ```
+
+   Location字段为msprobe工具的安装路径，那么config.yaml文件位置为/home/xx/anaconda3/envs/pt21py38/lib/python3.8/site-packages/msprobe/pytorch/api_accuracy_checker/config.yaml
+
+2. 进入config.yaml文件
+
+   ```bash
+   vi /home/xx/anaconda3/envs/pt21py38/lib/python3.8/site-packages/msprobe/pytorch/api_accuracy_checker/config.yaml
+   ```
+
+3. 修改config.yaml文件参数。
+
+   ```yaml
+   white_list: []
+   black_list: []
+   error_data_path: './'
+   precision: 14
+   ```
 
-文件路径为：mstt/debug/accuracy_tools/msprobe/pytorch/api_accuracy_checker/config.yaml 
+   | 参数名称        | 说明                                                         | 是否必选 |
+   | --------------- | ------------------------------------------------------------ | -------- |
+   | white_list      | API dump白名单，仅对指定的API进行dump。参数示例：white_list=["conv1d", "conv2d"]。默认未配置白名单，即dump全量API数据。 | 否       |
+   | black_list      | API dump黑名单，被指定的API不进行dump。参数示例：black_list=["conv1d", "conv2d"]。默认未配置黑名单，即dump全量API数据。 | 否       |
+   | error_data_path | 配置保存精度未达标的API输入输出数据路径。参数示例"error_data_path": "./"。默认为当前路径。 | 否       |
+   | precision       | 浮点数表示位数，默认取小数点后14位。                         | 否       |
 
-| 参数名称        | 说明                                                         | 是否必选 |
-| --------------- | ------------------------------------------------------------ | -------- |
-| white_list      | API dump白名单，指定dump具体API数据，也可以直接配置预检的API白名单，详细请参见“**API预检白名单**”。参数示例：white_list=["conv1d", "conv2d"]。默认未配置白名单，即dump全量API数据。 | 否       |
-| error_data_path | 配置保存精度未达标的API输入输出数据路径。                    | 否       |
-| precision       | 浮点数表示位数，默认取小数点后14位。                         | 否       |
+   说明：white_list和black_list同时配置时，二者配置的API名单若无交集，则白名单生效，若API名单存在交集，则白名单排除的部分以及交集的API不进行dump。
 
 ## 预检结果