mindstudio-probe 1.0.4__py3-none-any.whl → 1.1.1__py3-none-any.whl

msprobe/pytorch/parse_tool/cli.py

@@ -1,8 +1,7 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-# Copyright (C) 2022-2024. Huawei Technologies Co., Ltd. All rights reserved.
-# Licensed under the Apache License, Version 2.0 (the "License");
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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
 #
@@ -13,7 +12,7 @@
 # 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 msprobe.pytorch.parse_tool.lib.interactive_cli import InteractiveCli
 from msprobe.pytorch.common.log import logger
 

msprobe/pytorch/parse_tool/lib/compare.py

@@ -22,7 +22,7 @@ from collections import namedtuple
 from msprobe.pytorch.parse_tool.lib.utils import Util
 from msprobe.pytorch.parse_tool.lib.config import Const
 from msprobe.pytorch.parse_tool.lib.parse_exception import ParseException
-from msprobe.core.common.file_utils import FileChecker, create_directory, load_npy, save_npy_to_txt, write_csv
+from msprobe.core.common.file_utils import create_directory, load_npy, save_npy_to_txt, write_csv, os_walk_for_files
 
 
 class Compare:
@@ -49,10 +49,10 @@ class Compare:
         dump_file = self.util.path_strip(dump_file)
         file_name = ""
         if os.path.isfile(dump_file):
-            self.log.info("Covert file is: %s", dump_file)
+            self.log.info("Covert file is: %s" % dump_file)
             file_name = os.path.basename(dump_file)
         elif os.path.isdir(dump_file):
-            self.log.info("Convert all files in path: %s", dump_file)
+            self.log.info("Convert all files in path: %s" % dump_file)
             file_name = ""
         output = output if output else Const.DUMP_CONVERT_DIR
         convert = self.convert(dump_file, data_format, output, msaccucmp_path)
@@ -62,7 +62,7 @@ class Compare:
             summary_txt = ["SrcFile: %s" % dump_file]
             for convert_file in convert_files.values():
                 summary_txt.append(" - %s" % convert_file.file_name)
-            self.log.info("Transfer result is saved in : %s", os.path.realpath(output))
+            self.log.info("Transfer result is saved in : %s" % os.path.realpath(output))
             self.util.print_panel("\n".join(summary_txt))
 
     def convert(self, dump_file, data_format, output, msaccucmp_path):
@@ -114,11 +114,11 @@ class Compare:
         shape_left = data_left.shape
         shape_right = data_right.shape
         if shape_left != shape_right:
-            self.log.warning("Data shape not equal: %s vs %s", data_left.shape, data_right.shape)
+            self.log.warning("Data shape not equal: %s vs %s" % (data_left.shape, data_right.shape))
         data_left = data_left.reshape(-1)
         data_right = data_right.reshape(-1)
         if data_left.shape[0] != data_right.shape[0]:
-            self.log.warning("Data size not equal: %s vs %s", data_left.shape, data_right.shape)
+            self.log.warning("Data size not equal: %s vs %s" % (data_left.shape, data_right.shape))
             if data_left.shape[0] < data_right.shape[0]:
                 data_left = np.pad(data_left, (0, data_right.shape[0] - data_left.shape[0]), 'constant')
             else:
@@ -160,7 +160,7 @@ class Compare:
         if shape != bench_shape or dtype != bench_dtype:
             self.log.error(
                 "Shape or dtype between two npy files is inconsistent. Please check the two files."
-                "File 1: %s, file 2: %s", file, bench_file)
+                "File 1: %s, file 2: %s" % (file, bench_file))
             self.util.deal_with_dir_or_file_inconsistency(output_path)
             return
         md5_consistency = False
@@ -236,25 +236,18 @@ class Compare:
             golden_subdir_path = os.path.join(golden_dump_dir, golden_subdir_name)
             self.compare_timestamp_directory(my_subdir_path, golden_subdir_path, output_path)
         self.util.change_filemode_safe(output_path)
-        self.log.info("Compare result is saved in : %s", output_path)
+        self.log.info("Compare result is saved in : %s" % (output_path))
 
     def convert_api_dir_to_npy(self, dump_dir, param, output_dir, msaccucmp_path):
         dump_dir = self.util.path_strip(dump_dir)
-        for root, _, files in os.walk(dump_dir, topdown=True):
-            path_checker = FileChecker(root)
-            path_checker.common_check()
-            for file in files:
-                file_path = os.path.join(root, file)
-                file_name = os.path.basename(file_path)
-                parts = file_name.split(".")
-                if len(parts) < 5:
-                    continue
-                op_name = parts[1]
-                timestamp = parts[-1]
-                output_path = os.path.join(output_dir, op_name, timestamp)
-                self.convert_dump_to_npy(file_path, param, output_path, msaccucmp_path)
-            path_depth = root.count(os.sep)
-            if path_depth <= Const.MAX_TRAVERSAL_DEPTH:
-                yield root, _, files
-            else:
-                _[:] = []
+        files = os_walk_for_files(dump_dir, Const.MAX_TRAVERSAL_DEPTH)
+        filepaths = [os.path.join(file['root'], file['file']) for file in files]
+        for path in filepaths:
+            filename = os.path.basename(path)
+            parts = filename.split(".")
+            if len(parts) < 5:
+                continue
+            op_name = parts[1]
+            timestamp = parts[-1]
+            output_path = os.path.join(output_dir, op_name, timestamp)
+            self.convert_dump_to_npy(path, param, output_path, msaccucmp_path)

msprobe/pytorch/parse_tool/lib/config.py

@@ -33,7 +33,7 @@ class Const:
     OFFLINE_DUMP_CONVERT_PATTERN = \
         r"^([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]+)\.([0-9]+)(\.[0-9]+)?\.([0-9]{1,255})" \
         r"\.([a-z]+)\.([0-9]{1,255})(\.[x0-9]+)?\.npy$"
-    NUMPY_PATTERN = r"^[\w\-_-]\.npy$"
+    NUMPY_PATTERN = r"^[\w\-_.]+\.npy$"
     NPY_SUFFIX = ".npy"
     PKL_SUFFIX = ".pkl"
     DIRECTORY_LENGTH = 4096

msprobe/pytorch/parse_tool/lib/parse_tool.py

@@ -110,6 +110,9 @@ class ParseTool:
         parser.add_argument('-al', '--atol', dest='atol', default=0.001, type=float, help='set rtol')
         parser.add_argument('-rl', '--rtol', dest='rtol', default=0.001, type=float, help='set atol')
         args = parser.parse_args(argv)
+        self.util.check_positive(args.count)
+        self.util.check_positive(args.rtol)
+        self.util.check_positive(args.atol)
         self.util.check_path_valid(args.my_dump_path)
         self.util.check_path_valid(args.golden_dump_path)
         self.util.check_file_path_format(args.my_dump_path, Const.NPY_SUFFIX)
@@ -129,8 +132,7 @@ class ParseTool:
                                 " '-m' and '-g'.")
             raise ParseException("My directory path and golden directory path is same.")
         output_path = self.util.path_strip(args.output_path) if args.output_path else Const.BATCH_COMPARE_DIR
-        if not os.path.isdir(output_path):
-            os.makedirs(output_path, mode=0o750)
+        create_directory(output_path)
         self.compare.compare_converted_dir(my_dump_dir, golden_dump_dir, output_path)
 
     @catch_exception

msprobe/pytorch/parse_tool/lib/utils.py

@@ -28,7 +28,7 @@ from msprobe.pytorch.parse_tool.lib.parse_exception import ParseException
 from msprobe.core.common.file_utils import change_mode, check_other_user_writable,\
     check_path_executable, check_path_owner_consistent
 from msprobe.core.common.const import FileCheckConst
-from msprobe.core.common.file_utils import FileChecker, check_file_or_directory_path, remove_path
+from msprobe.core.common.file_utils import check_file_or_directory_path, remove_path, check_file_type, os_walk_for_files
 from msprobe.pytorch.common.log import logger
 
 
@@ -71,31 +71,21 @@ class Util:
         check_path_executable(path)
 
     @staticmethod
-    def get_subdir_count(self, directory):
+    def get_subdir_count(directory):
         subdir_count = 0
-        path_checker = FileChecker(directory)
-        path_checker.common_check()
+        check_file_or_directory_path(directory, isdir=True)
         for _, dirs, _ in os.walk(directory):
             subdir_count += len(dirs)
             break
         return subdir_count
 
     @staticmethod
-    def get_subfiles_count(self, directory):
-        file_count = 0
-        for root, _, files in os.walk(directory, topdown=True):
-            path_checker = FileChecker(root)
-            path_checker.common_check()
-            file_count += len(files)
-            path_depth = root.count(os.sep)
-            if path_depth <= Const.MAX_TRAVERSAL_DEPTH:
-                yield root, _, files
-            else:
-                _[:] = []
-        return file_count
+    def get_subfiles_count(directory):
+        files = os_walk_for_files(directory, Const.MAX_TRAVERSAL_DEPTH)
+        return len(files)
 
     @staticmethod
-    def get_sorted_subdirectories_names(self, directory):
+    def get_sorted_subdirectories_names(directory):
         subdirectories = []
         for item in os.listdir(directory):
             item_path = os.path.join(directory, item)
@@ -104,7 +94,7 @@ class Util:
         return sorted(subdirectories)
 
     @staticmethod
-    def get_sorted_files_names(self, directory):
+    def get_sorted_files_names(directory):
         files = []
         for item in os.listdir(directory):
             item_path = os.path.join(directory, item)
@@ -113,7 +103,7 @@ class Util:
         return sorted(files)
 
     @staticmethod
-    def check_npy_files_valid_in_dir(self, dir_path):
+    def check_npy_files_valid_in_dir(dir_path):
         for file_name in os.listdir(dir_path):
             file_path = os.path.join(dir_path, file_name)
             check_file_or_directory_path(file_path)
@@ -123,18 +113,18 @@ class Util:
         return True
 
     @staticmethod
-    def get_md5_for_numpy(self, obj):
+    def get_md5_for_numpy(obj):
         np_bytes = obj.tobytes()
         md5_hash = hashlib.md5(np_bytes)
         return md5_hash.hexdigest()
 
     @staticmethod
-    def deal_with_dir_or_file_inconsistency(self, output_path):
+    def deal_with_dir_or_file_inconsistency(output_path):
         remove_path(output_path)
         raise ParseException("Inconsistent directory structure or file.")
 
     @staticmethod
-    def deal_with_value_if_has_zero(self, data):
+    def deal_with_value_if_has_zero(data):
         if data.dtype in Const.FLOAT_TYPE:
             zero_mask = (data == 0)
             # 给0的地方加上eps防止除0
@@ -147,26 +137,19 @@ class Util:
         return data
     
     @staticmethod
-    def dir_contains_only(self, path, endfix):
-        for root, _, files in os.walk(path, topdown=True):
-            path_checker = FileChecker(root)
-            path_checker.common_check()
-            for file in files:
-                if not file.endswith(endfix):
-                    return False
-            path_depth = root.count(os.sep)
-            if path_depth <= Const.MAX_TRAVERSAL_DEPTH:
-                yield root, _, files
-            else:
-                _[:] = []
+    def dir_contains_only(path, endfix):
+        files = os_walk_for_files(path, Const.MAX_TRAVERSAL_DEPTH)
+        for file in files:
+            if not file['file'].endswith(endfix):
+                return False
         return True
     
     @staticmethod
-    def localtime_str(self):
+    def localtime_str():
         return time.strftime("%Y%m%d%H%M%S", time.localtime())
     
     @staticmethod
-    def change_filemode_safe(self, path):
+    def change_filemode_safe(path):
         change_mode(path, FileCheckConst.DATA_FILE_AUTHORITY)
 
     @staticmethod
@@ -183,7 +166,7 @@ class Util:
         if not cmd:
             self.log.error("Commond is None")
             return -1
-        self.log.info("[RUN CMD]: %s", cmd)
+        self.log.info("[RUN CMD]: %s" % cmd)
         cmd = cmd.split(" ")
         complete_process = subprocess.run(cmd, shell=False)
         return complete_process.returncode
@@ -205,7 +188,7 @@ class Util:
         result = subprocess.run(
             [self.python, target_file, "--help"], stdout=subprocess.PIPE, shell=False)
         if result.returncode == 0:
-            self.log.info("Check [%s] success.", target_file)
+            self.log.info("Check [%s] success." % (target_file))
         else:
             self.log.error("Check msaccucmp failed in dir %s" % target_file)
             self.log.error("Please specify a valid msaccucmp.py path or install the cann package")
@@ -244,8 +227,11 @@ class Util:
 
     def check_path_valid(self, path):
         path = self.path_strip(path)
-        path_checker = FileChecker(path)
-        path_checker.common_check()
+        if not path or not os.path.exists(path):
+            self.log.error("The path %s does not exist." % path)
+            raise ParseException(ParseException.PARSE_INVALID_PATH_ERROR)
+        isdir = check_file_type(path) == FileCheckConst.DIR
+        check_file_or_directory_path(path, isdir=isdir)
         return True
 
     def check_files_in_path(self, path):
@@ -273,21 +259,15 @@ class Util:
         self.check_path_valid(path)
         file_list = {}
         re_pattern = re.compile(pattern)
-        for dir_path, _, file_names in os.walk(path, topdown=True):
-            path_checker = FileChecker(dir)
-            path_checker.common_check()
-            for name in file_names:
-                match = re_pattern.match(name)
-                if not match:
-                    continue
-                if extern_pattern != '' and re_pattern.match(extern_pattern) and not re.match(extern_pattern, name):
-                    continue
-                file_list[name] = gen_info_func(name, match, dir_path)
-            path_depth = dir_path.count(os.sep)
-            if path_depth <= Const.MAX_TRAVERSAL_DEPTH:
-                yield dir_path, _, file_names
-            else:
-                _[:] = []
+        files = os_walk_for_files(path, Const.MAX_TRAVERSAL_DEPTH)
+        for file in files:
+            name = file["file"]
+            match = re_pattern.match(name)
+            if not match:
+                continue
+            if extern_pattern != '' and re_pattern.match(extern_pattern) and not re.match(extern_pattern, name):
+                continue
+            file_list[name] = gen_info_func(name, match, file["root"])
         return file_list
 
     def check_file_path_format(self, path, suffix):
@@ -314,3 +294,8 @@ class Util:
         dir1_count = self.get_subdir_count(dir1)
         dir2_count = self.get_subdir_count(dir2)
         return dir1_count == dir2_count
+
+    def check_positive(self, value):
+        if value <= 0.0:
+            self.log.error("Invalid value. It must be greater than 0.")
+            raise ParseException(ParseException.PARSE_INVALID_DATA_ERROR)

msprobe/pytorch/parse_tool/lib/visualization.py

@@ -28,7 +28,7 @@ class Visualization:
         self.util = Util()
 
     def print_npy_summary(self, target_file):
-        np_data = load_npy(target_file, enable_pickle=True)
+        np_data = load_npy(target_file)
         table = self.util.create_table('', ['Index', 'Data'])
         flatten_data = np_data.flatten()
         tablesize = 8
@@ -65,6 +65,8 @@ class Visualization:
                     self.util.log.error("%s %s in line %s" % ("JSONDecodeError", str(e), pkl_line))
                     self.util.log.warning("Please check the pkl file")
                     raise ParseException(ParseException.PARSE_JSONDECODE_ERROR) from e
+                if not isinstance(msg, list) or len(msg) == 0:
+                    break
                 info_prefix = msg[0]
                 if not info_prefix.startswith(api_name):
                     continue

msprobe/pytorch/pt_config.py

@@ -1,12 +1,35 @@
-import json
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
 import os
+import re
 
-from msprobe.core.common_config import CommonConfig, BaseConfig
-from msprobe.core.common.file_utils import FileOpen
 from msprobe.core.common.const import Const
-from msprobe.pytorch.hook_module.utils import get_ops
+from msprobe.core.common.exceptions import MsprobeException
+from msprobe.core.common.file_utils import FileOpen, load_json, check_file_or_directory_path, check_crt_valid
+from msprobe.core.common.log import logger
+from msprobe.core.common.utils import is_int
+from msprobe.core.common_config import BaseConfig, CommonConfig
 from msprobe.core.grad_probe.constant import level_adp
-from msprobe.core.grad_probe.utils import check_numeral_list_ascend
+from msprobe.core.grad_probe.utils import check_bounds
+from msprobe.pytorch.free_benchmark.common.enums import (
+    DeviceType,
+    HandlerType,
+    PytorchFreeBenchmarkConst,
+)
+from msprobe.pytorch.hook_module.utils import get_ops
 
 
 class TensorConfig(BaseConfig):
@@ -16,23 +39,39 @@ class TensorConfig(BaseConfig):
         self.nfs_path = json_config.get("nfs_path", "")
         self.host = json_config.get("host", "")
         self.port = json_config.get("port", -1)
-        self.tls_path = json_config.get("tls_path", "")
+        self.tls_path = json_config.get("tls_path", "./")
+        self.online_run_ut_recompute = json_config.get("online_run_ut_recompute", False)
         self.check_config()
         self._check_file_format()
-        self._check_tls_path_config()
+        if self.online_run_ut:
+            self._check_online_run_ut()
 
     def _check_file_format(self):
         if self.file_format is not None and self.file_format not in ["npy", "bin"]:
             raise Exception("file_format is invalid")
 
-    def _check_tls_path_config(self):
+    def _check_online_run_ut(self):
+        if not isinstance(self.online_run_ut, bool):
+            raise Exception(f"online_run_ut: {self.online_run_ut} is invalid.")
+
+        if not isinstance(self.online_run_ut_recompute, bool):
+            raise Exception(f"online_run_ut_recompute: {self.online_run_ut_recompute} is invalid.")
+
+        if self.nfs_path:
+            check_file_or_directory_path(self.nfs_path, isdir=True)
+            return
+
         if self.tls_path:
-            if not os.path.exists(self.tls_path):
-                raise Exception("tls_path: %s does not exist" % self.tls_path)
-            if not os.path.exists(os.path.join(self.tls_path, "client.key")):
-                raise Exception("tls_path does not contain client.key")
-            if not os.path.exists(os.path.join(self.tls_path, "client.crt")):
-                raise Exception("tls_path does not contain client.crt")
+            check_file_or_directory_path(self.tls_path, isdir=True)
+            check_file_or_directory_path(os.path.join(self.tls_path, "client.key"))
+            check_file_or_directory_path(os.path.join(self.tls_path, "client.crt"))
+            check_crt_valid(os.path.join(self.tls_path, "client.crt"))
+
+        if not isinstance(self.host, str) or not re.match(Const.ipv4_pattern, self.host):
+            raise Exception(f"host: {self.host} is invalid.")
+
+        if not isinstance(self.port, int) or not (0 < self.port <= 65535):
+            raise Exception(f"port: {self.port} is invalid, port range 0-65535.")
 
 
 class StatisticsConfig(BaseConfig):
@@ -54,30 +93,149 @@ class OverflowCheckConfig(BaseConfig):
         self.check_overflow_config()
 
     def check_overflow_config(self):
-        if self.overflow_nums is not None and not isinstance(self.overflow_nums, int):
+        if self.overflow_nums is not None and not is_int(self.overflow_nums):
             raise Exception("overflow_num is invalid")
         if self.check_mode is not None and self.check_mode not in ["all", "aicore", "atomic"]:
             raise Exception("check_mode is invalid")
 
 
 class FreeBenchmarkCheckConfig(BaseConfig):
+
     def __init__(self, json_config):
         super().__init__(json_config)
-        self.fuzz_device = json_config.get("fuzz_device")
-        self.pert_mode = json_config.get("pert_mode")
-        self.handler_type = json_config.get("handler_type")
-        self.fuzz_level = json_config.get("fuzz_level")
-        self.fuzz_stage = json_config.get("fuzz_stage")
-        self.if_preheat = json_config.get("if_preheat")
-        self.preheat_step = json_config.get("preheat_step")
-        self.max_sample = json_config.get("max_sample")
+        self.fuzz_device = json_config.get("fuzz_device", PytorchFreeBenchmarkConst.DEFAULT_DEVICE)
+        self.pert_mode = json_config.get("pert_mode", PytorchFreeBenchmarkConst.DEFAULT_MODE)
+        self.handler_type = json_config.get("handler_type", PytorchFreeBenchmarkConst.DEFAULT_HANDLER)
+        self.fuzz_level = json_config.get("fuzz_level", PytorchFreeBenchmarkConst.DEFAULT_FUZZ_LEVEL)
+        self.fuzz_stage = json_config.get("fuzz_stage", PytorchFreeBenchmarkConst.DEFAULT_FUZZ_STAGE)
+        self.if_preheat = json_config.get("if_preheat", False)
+        self.preheat_step = json_config.get("preheat_step", PytorchFreeBenchmarkConst.DEFAULT_PREHEAT_STEP)
+        self.max_sample = json_config.get("max_sample", PytorchFreeBenchmarkConst.DEFAULT_PREHEAT_STEP)
         self.check_freebenchmark_config()
 
     def check_freebenchmark_config(self):
-        if self.if_preheat and self.handler_type == "fix":
-            raise Exception("Preheating is not supported in fix handler type")
-        if self.preheat_step and self.preheat_step == 0:
-            raise Exception("preheat_step cannot be 0")
+        self._check_pert_mode()
+        self._check_fuzz_device()
+        self._check_handler_type()
+        self._check_fuzz_stage()
+        self._check_fuzz_level()
+        self._check_if_preheat()
+        if self.handler_type == HandlerType.FIX:
+            self._check_fix_config()
+        if self.if_preheat:
+            self._check_preheat_config()
+
+    def _check_pert_mode(self):
+        if self.pert_mode not in PytorchFreeBenchmarkConst.PERTURBATION_MODE_LIST:
+            msg = (
+                f"pert_mode is invalid, it should be one of"
+                f" {PytorchFreeBenchmarkConst.PERTURBATION_MODE_LIST}"
+            )
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+
+    def _check_fuzz_device(self):
+        if self.fuzz_device not in PytorchFreeBenchmarkConst.DEVICE_LIST:
+            msg = (
+                f"fuzz_device is invalid, it should be one of"
+                f" {PytorchFreeBenchmarkConst.DEVICE_LIST}"
+            )
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+        if (self.fuzz_device == DeviceType.CPU) ^ (
+                self.pert_mode in PytorchFreeBenchmarkConst.CPU_MODE_LIST
+        ):
+            msg = (
+                f"You neet to and can only set fuzz_device as {DeviceType.CPU} "
+                f"when pert_mode in {PytorchFreeBenchmarkConst.CPU_MODE_LIST}"
+            )
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+
+    def _check_handler_type(self):
+        if self.handler_type not in PytorchFreeBenchmarkConst.HANDLER_LIST:
+            msg = (
+                f"handler_type is invalid, it should be one of"
+                f" {PytorchFreeBenchmarkConst.HANDLER_LIST}"
+            )
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+
+    def _check_fuzz_stage(self):
+        if self.fuzz_stage not in PytorchFreeBenchmarkConst.FUZZ_STAGE_LIST:
+            msg = (
+                f"fuzz_stage is invalid, it should be one of"
+                f" {PytorchFreeBenchmarkConst.FUZZ_STAGE_LIST}"
+            )
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+
+    def _check_fuzz_level(self):
+        if self.fuzz_level not in PytorchFreeBenchmarkConst.FUZZ_LEVEL_LIST:
+            msg = (
+                f"fuzz_level is invalid, it should be one of"
+                f" {PytorchFreeBenchmarkConst.FUZZ_LEVEL_LIST}"
+            )
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+
+    def _check_if_preheat(self):
+        if not isinstance(self.if_preheat, bool):
+            msg = "if_preheat is invalid, it should be a boolean"
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+
+    def _check_preheat_config(self):
+        if not is_int(self.preheat_step):
+            msg = "preheat_step is invalid, it should be an integer"
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+        if self.preheat_step <= 0:
+            msg = "preheat_step must be greater than 0"
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+        if not is_int(self.max_sample):
+            msg = "max_sample is invalid, it should be an integer"
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+        if self.max_sample <= 0:
+            msg = "max_sample must be greater than 0"
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+
+    def _check_fix_config(self):
+        if self.if_preheat:
+            msg = f"Preheating is not supported for {HandlerType.FIX} handler type"
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+        if self.fuzz_stage not in PytorchFreeBenchmarkConst.FIX_STAGE_LIST:
+            msg = (
+                f"The fuzz_stage when opening {HandlerType.FIX} handler must be one of "
+                f"{PytorchFreeBenchmarkConst.FIX_STAGE_LIST}"
+            )
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
+        if self.pert_mode not in PytorchFreeBenchmarkConst.FIX_MODE_LIST:
+            msg = (
+                f"The pert_mode when opening {HandlerType.FIX} handler must be one of "
+                f"{PytorchFreeBenchmarkConst.FIX_MODE_LIST}"
+            )
+            logger.error_log_with_exp(
+                msg, MsprobeException(MsprobeException.INVALID_PARAM_ERROR, msg)
+            )
 
 
 class RunUTConfig(BaseConfig):
@@ -93,7 +251,7 @@ class RunUTConfig(BaseConfig):
         self.host = json_config.get("host", "")
         self.port = json_config.get("port", -1)
         self.rank_list = json_config.get("rank_list", Const.DEFAULT_LIST)
-        self.tls_path = json_config.get("tls_path", "")
+        self.tls_path = json_config.get("tls_path", "./")
         self.check_run_ut_config()
 
     @classmethod
@@ -118,13 +276,8 @@ class RunUTConfig(BaseConfig):
 
     @classmethod
     def check_tls_path_config(cls, tls_path):
-        if tls_path:
-            if not os.path.exists(tls_path):
-                raise Exception("tls_path: %s does not exist" % tls_path)
-            if not os.path.exists(os.path.join(tls_path, "server.key")):
-                raise Exception("tls_path does not contain server.key")
-            if not os.path.exists(os.path.join(tls_path, "server.crt")):
-                raise Exception("tls_path does not contain server.crt")
+        if tls_path and not os.path.exists(tls_path):
+            raise Exception("tls_path: %s does not exist" % tls_path)
 
     def check_run_ut_config(self):
         RunUTConfig.check_filter_list_config(Const.WHITE_LIST, self.white_list)
@@ -141,13 +294,13 @@ class GradToolConfig(BaseConfig):
         self.param_list = json_config.get("param_list", [])
         self.bounds = json_config.get("bounds", [-1, 0, 1])
         self._check_config()
-    
+
     def _check_config(self):
         if self.grad_level not in level_adp.keys():
             raise Exception(f"grad_level must be one of {level_adp.keys()}")
         if not isinstance(self.param_list, list):
             raise Exception(f"param_list must be a list")
-        check_numeral_list_ascend(self.bounds)
+        check_bounds(self.bounds)
 
 
 def parse_task_config(task, json_config):
@@ -178,10 +331,9 @@ def parse_json_config(json_file_path, task):
     if not json_file_path:
         config_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
         json_file_path = os.path.join(config_dir, "config.json")
-    with FileOpen(json_file_path, 'r') as file:
-        json_config = json.load(file)
+    json_config = load_json(json_file_path)
     common_config = CommonConfig(json_config)
-    if task and task in Const.TASK_LIST:
+    if task:
         task_config = parse_task_config(task, json_config)
     else:
         task_config = parse_task_config(common_config.task, json_config)