mindspore 2.7.0rc1__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/run_check/_check_version.py

@@ -44,6 +44,23 @@ class EnvChecker(metaclass=ABCMeta):
     def check_version(self):
         pass
 
+    @staticmethod
+    def _concat_variable(env_name, env_value):
+        """concat value to the beginning of env specified by env_name"""
+        if not os.getenv(env_name, ""):
+            os.environ[env_name] = env_value
+        else:
+            paths = os.environ[env_name].split(':')
+            if paths and paths[0] == env_value:
+                return
+            if env_value not in paths:
+                os.environ[env_name] = env_value + ':' + os.environ[env_name]
+            else:
+                # move env_value to beginning
+                new_paths = [p for p in paths if p != env_value]
+                new_paths.insert(0, env_value)
+                os.environ[env_name] = ':'.join(new_paths)
+
 
 class CPUEnvChecker(EnvChecker):
     """CPU environment check."""
@@ -61,10 +78,7 @@ class CPUEnvChecker(EnvChecker):
         """set env for cpu"""
         plugin_dir = os.path.dirname(self.library_path)
         akg_dir = os.path.join(plugin_dir, "plugin/cpu")
-        if os.getenv('LD_LIBRARY_PATH'):
-            os.environ['LD_LIBRARY_PATH'] = akg_dir + ":" + os.environ['LD_LIBRARY_PATH']
-        else:
-            os.environ['LD_LIBRARY_PATH'] = akg_dir
+        EnvChecker._concat_variable('LD_LIBRARY_PATH', akg_dir)
 
 
 class GPUEnvChecker(EnvChecker):
@@ -142,10 +156,7 @@ class GPUEnvChecker(EnvChecker):
         v_str = str(v.major) + "." + str(v.minor)
         plugin_dir = os.path.dirname(self.library_path)
         akg_dir = os.path.join(plugin_dir, "gpu" + v_str)
-        if os.getenv('LD_LIBRARY_PATH'):
-            os.environ['LD_LIBRARY_PATH'] = akg_dir + ":" + os.environ['LD_LIBRARY_PATH']
-        else:
-            os.environ['LD_LIBRARY_PATH'] = akg_dir
+        EnvChecker._concat_variable('LD_LIBRARY_PATH', akg_dir)
         os.environ['CUDA_CACHE_MAXSIZE'] = "4000000000"
 
     def _get_bin_path(self, bin_name):
@@ -258,7 +269,7 @@ class AscendEnvChecker(EnvChecker):
 
     def __init__(self, library_path):
         self.library_path = library_path
-        self.version = ["7.7", "7.8", "8.2"]
+        self.version = ["7.8", "8.2", "8.3"]
 
         # env
         self.path = os.getenv("PATH")
@@ -278,13 +289,6 @@ class AscendEnvChecker(EnvChecker):
         self.ascend_opp_kernel_path_check = "/opp_kernel"
         self.v = ""
 
-    @staticmethod
-    def _concat_variable(env_name, env_value):
-        if os.getenv(env_name) is None:
-            os.environ[env_name] = env_value
-        else:
-            os.environ[env_name] = env_value + ":" + os.environ[env_name]
-
     def check_custom_version(self):
         """custom op version check"""
 
@@ -359,11 +363,6 @@ class AscendEnvChecker(EnvChecker):
         """
             opp kernel install check
         """
-        from mindspore._c_expression import MSContext
-        soc_version = MSContext.get_instance().get_ascend_soc_version()
-        if soc_version == "ascend310":
-            return
-
         opp_kernel_path = self.ascend_opp_path.replace("opp", "opp_kernel")
         if not os.path.exists(opp_kernel_path):
             logger.critical("MindSpore relies on \"Ascend opp_kernel\" folder of the Ascend AI software package ("
@@ -389,7 +388,7 @@ class AscendEnvChecker(EnvChecker):
         os.environ['IGNORE_INFER_ERROR'] = "1"
         plugin_dir = os.path.dirname(self.library_path)
         akg_dir = os.path.join(plugin_dir, "ascend")
-        AscendEnvChecker._concat_variable('LD_LIBRARY_PATH', akg_dir)
+        EnvChecker._concat_variable('LD_LIBRARY_PATH', akg_dir)
 
         self._check_env()
 
@@ -493,6 +492,85 @@ def _set_pb_env():
         os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
 
 
+def _check_dir_path_safety(dir_path):
+    """Check safety of env directory path."""
+    if not os.path.exists(dir_path):
+        logger.warning(f"Path {dir_path} not exists.")
+        return False
+
+    if not os.path.isdir(dir_path):
+        logger.warning(f"Path {dir_path} is not a directory.")
+        return False
+
+    # check if path is suspicious
+    suspicious_patterns = [
+        "/tmp/", "/var/tmp/", "/dev/", "/proc/",
+        "\\temp\\", "\\windows\\temp\\",
+        "appdata", "local\\temp"
+    ]
+    lower_path = dir_path.lower()
+    for pattern in suspicious_patterns:
+        if pattern in lower_path:
+            logger.warning(f"Path {dir_path} is suspicious.")
+            return False
+
+    # check whether the path points to a system-critical directory
+    critical_dirs = [
+        "/bin", "/sbin", "/usr/bin", "/usr/sbin",
+        "/windows", "/system32", "c:\\windows"
+    ]
+    for critical_dir in critical_dirs:
+        if critical_dir in lower_path:
+            logger.warning(f"Path {dir_path} points to a system-critical directory.")
+            return False
+
+    return True
+
+
+def check_cuda_path_safety(cuda_path):
+    """Check safety of cuda path."""
+    if not _check_dir_path_safety(cuda_path):
+        return False
+
+    expected_files = ["nvcc", "cudart.dll", "cudart.so"]
+    has_expected_content = False
+    for expected_file in expected_files:
+        if os.path.exists(os.path.join(cuda_path, "bin", expected_file)):
+            has_expected_content = True
+            break
+
+    if not has_expected_content:
+        logger.warning(f"The directory {cuda_path} does not contain the typical file structure of CUDA")
+        return False
+
+    return True
+
+
+def check_cudnn_path_safety(cudnn_path):
+    """Check safety of cudnn path."""
+    if not _check_dir_path_safety(cudnn_path):
+        return False
+
+    expected_files = [
+        "include/cudnn.h",
+        "lib64/libcudnn.so",  # Linux
+        "lib/libcudnn.dylib",  # macOS
+        "lib/x64/cudnn.lib",  # Windows
+        "bin/cudnn64_7.dll"   # Windows
+    ]
+    found_files = []
+    for expected_file in expected_files:
+        full_path = os.path.join(cudnn_path, expected_file)
+        if os.path.exists(full_path):
+            found_files.append(expected_file)
+
+    if not found_files:
+        logger.warning(f"The directory {cudnn_path} does not contain the typical file structure of CUDNN")
+        return False
+
+    return True
+
+
 def _add_cuda_path():
     """add cuda path on windows."""
     if platform.system().lower() == 'windows':
@@ -500,15 +578,21 @@ def _add_cuda_path():
         if cuda_home is None:
             pass
         else:
+            if not check_cuda_path_safety(cuda_home):
+                logger.error(f"CUDA_PATH {cuda_home} is not safe, skip add cuda path.")
+                return
             cuda_bin_path = os.path.join(os.environ['CUDA_PATH'], 'bin')
             if sys.version_info >= (3, 8):
                 os.add_dll_directory(cuda_bin_path)
             else:
                 os.environ['PATH'] += os.pathsep + cuda_bin_path
-        cudann_home = os.environ.get('CUDNN_HOME')
-        if cudann_home is None:
+        cudnn_home = os.environ.get('CUDNN_HOME')
+        if cudnn_home is None:
             pass
         else:
+            if not check_cudnn_path_safety(cudnn_home):
+                logger.error(f"CUDNN_HOME {cuda_home} is not safe, skip add cudnn home.")
+                return
             cuda_home_bin_path = os.path.join(os.environ['CUDNN_HOME'], 'bin')
             if sys.version_info >= (3, 8):
                 os.add_dll_directory(cuda_home_bin_path)

mindspore/runtime/__init__.py

@@ -17,21 +17,24 @@
 The runtime interface.
 """
 
-from mindspore.runtime.executor import launch_blocking, dispatch_threads_num, set_cpu_affinity, set_kernel_launch_group
-from mindspore.runtime.memory import set_memory, memory_stats, memory_reserved, max_memory_reserved, empty_cache, \
-                                 memory_replay, reset_peak_memory_stats, memory_summary, memory_allocated, \
-                                 max_memory_allocated, reset_max_memory_reserved, reset_max_memory_allocated
+from mindspore.runtime.executor import launch_blocking, dispatch_threads_num, set_cpu_affinity,\
+                                    set_kernel_launch_group, set_kernel_launch_capture
+from mindspore.runtime.memory import set_memory, memory_stats, memory_reserved, max_memory_reserved, empty_cache,\
+                                 memory_replay, reset_peak_memory_stats, memory_summary, memory_allocated,\
+                                 max_memory_allocated, reset_max_memory_reserved, reset_max_memory_allocated,\
+                                 PluggableAllocator, MemPool, use_mem_pool
 from mindspore.runtime.stream import Stream, synchronize, set_cur_stream, current_stream, \
     default_stream, communication_stream, StreamCtx
 from mindspore.runtime.event import Event
 from .executor import launch_blocking
 
 __all__ = [
-    "launch_blocking", "dispatch_threads_num", "set_cpu_affinity", "set_kernel_launch_group",
+    "launch_blocking", "dispatch_threads_num", "set_cpu_affinity",
+    "set_kernel_launch_group", "set_kernel_launch_capture",
     "Stream", "communication_stream", "synchronize", "set_cur_stream", "current_stream", "default_stream", "StreamCtx",
     "set_memory", "memory_stats", "memory_reserved", "max_memory_reserved", "empty_cache", "memory_replay",
     "reset_peak_memory_stats", "memory_summary", "memory_allocated", "max_memory_allocated",
-    "reset_max_memory_reserved", "reset_max_memory_allocated", "Event"
+    "reset_max_memory_reserved", "reset_max_memory_allocated", "Event", "PluggableAllocator", "MemPool", "use_mem_pool"
 ]
 
 __all__.sort()

mindspore/runtime/executor.py

@@ -179,6 +179,9 @@ def set_kernel_launch_group(thread_num=2, kernel_group_num=8):
     if RuntimeConf.get_instance().is_kernel_launch_group_configured():
         raise RuntimeError("The 'kernel_launch_group' can not be set repeatedly.")
 
+    if RuntimeConf.get_instance().get_enable_kernel_launch_capture():
+        raise RuntimeError("The kernel launch group and kernel launch capture can not be set together")
+
     if thread_num < 1:
         raise ValueError(f"The value of thread_num should be at least 1, but got {thread_num}")
 
@@ -190,3 +193,35 @@ def set_kernel_launch_group(thread_num=2, kernel_group_num=8):
                          f"be evenly divisible by thread_num: {thread_num}")
 
     return RuntimeConf.get_instance().set_kernel_launch_group(thread_num, kernel_group_num)
+
+
+@args_type_check(enable_capture_graph=bool)
+def set_kernel_launch_capture(enable_capture_graph, op_capture_skip=None):
+    """
+    In O0/O1 mode, the incremental inference scenario supports graph capture.
+    By capturing the CPU-side operator dispatch behavior into a graph,
+    the performance of CPU-side operator dispatch is improved.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        enable_capture_graph (bool): Whether to enable graph capture.
+            It can be turned on or off at any position in the script.
+        op_capture_skip (list): Custom non-captured operator names. Default: ``None``.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> op_capture_skip = ['matmul', 'addn']
+        >>> ms.runtime.set_kernel_launch_capture(True, op_capture_skip)
+    """
+    if RuntimeConf.get_instance().is_kernel_launch_group_configured():
+        raise RuntimeError("The kernel launch group and kernel launch capture can not be set together")
+
+    if op_capture_skip is None:
+        op_capture_skip = []
+
+    if not isinstance(op_capture_skip, list):
+        raise TypeError("op_capture_skip must be a list")
+
+    return RuntimeConf.get_instance().set_kernel_launch_capture(enable_capture_graph, op_capture_skip)

mindspore/runtime/memory.py

@@ -14,9 +14,15 @@
 # ============================================================================
 
 """Memory interfaces."""
+import contextlib
+import ctypes
 import os
 from mindspore._c_expression import RuntimeConf, DeviceManagerConf, _memory_stats, \
     _reset_max_mem_reserved, _reset_max_mem_allocated, DeviceContextManager, _empty_cache, _memory_replay
+try:
+    from mindspore._c_expression import _enable_pluggable_allocator, _disable_pluggable_allocator
+except ImportError:
+    pass
 from mindspore import _checkparam as Validator
 from mindspore._checkparam import args_type_check
 from mindspore import log as logger
@@ -50,6 +56,7 @@ def set_memory(init_size="2GB", increase_size="2GB", max_size="1024GB", optimize
             The format is "xxGB". Default is the maximum available memory of the device, expressed as ``1024GB``.
         optimize_level (str): The memory optimize level. The value must be in ['O0', 'O1']. Default: ``O0`` .
         huge_page_reserve_size (str): The reserved size of huge page memory. The format is "xxGB". Default: ``0GB``.
+            When virtual memory is enabled, reserve huge page function is not available and this parameter is ignored.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -405,3 +412,109 @@ def memory_replay(file_path):
         >>> ms.runtime.memory_replay("/data/memory_block.csv")
     """
     _memory_replay(os.path.realpath(file_path))
+
+
+class PluggableAllocator():
+    r"""
+    Receive a .so file via ctypes, and dynamically load the alloc and free functions within it.
+    It needs to be used in conjunction with :class:`mindspore.runtime.MemPool` and
+    :func:`mindspore.runtime.use_mem_pool` to take over the memory allocation and free
+    in the MindSpore memory pool.
+
+    .. warning::
+        This is currently supported only in unix OSs.
+
+    Args:
+        path_to_so_file(str): Path in the file system to the `.so` file containing
+            the allocator functions.
+        alloc_fn_name(str): Name of the function to perform the memory allocation
+            in the so file. The signature must be:
+            `void* alloc_fn(size_t size, int device, aclrtStream stream);` .
+        free_fn_name(str): Name of the function to perform the memory release
+            in the so file. The signature must be:
+            `void free_fn(void* ptr, size_t size, aclrtStream stream);` .
+
+    Supported Platforms:
+        ``Ascend``
+    """
+
+    def __init__(self, path_to_so_file: str, alloc_fn_name: str, free_fn_name: str):
+        allocator = ctypes.CDLL(path_to_so_file)
+        alloc_fn = ctypes.cast(getattr(allocator, alloc_fn_name), ctypes.c_void_p).value
+        free_fn = ctypes.cast(getattr(allocator, free_fn_name), ctypes.c_void_p).value
+        if alloc_fn is None:
+            raise ValueError(f"Cannot find allocator function {alloc_fn_name} in {path_to_so_file}")
+        if free_fn is None:
+            raise ValueError(f"Cannot find free function {free_fn_name} in {path_to_so_file}")
+        self._alloc_fn = alloc_fn
+        self._free_fn = free_fn
+
+    @property
+    def alloc_fn_ptr(self) -> int:
+        """Function pointer of the allocator function."""
+        return self._alloc_fn
+
+    @property
+    def free_fn_ptr(self) -> int:
+        """Function pointer of the free function."""
+        return self._free_fn
+
+
+class MemPool():
+    r"""
+    A MemPool warp a :class:`mindspore.runtime.PluggableAllocator`,
+    and pass it to :func:`mindspore.runtime.use_mem_pool`.
+
+    Args:
+        allocator(mindspore.runtime.PluggableAllocator): a mindspore.runtime.PluggableAllocator
+            that can be used to define how memory gets allocated and freed in the pool.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+
+    def __init__(self, allocator: PluggableAllocator):
+        self._allocator = allocator
+
+    @property
+    def allocator(self) -> PluggableAllocator:
+        """The allocator used by the pool."""
+        return self._allocator
+
+
+@contextlib.contextmanager
+def use_mem_pool(pool: MemPool):
+    r"""
+    A context manager that routes allocations and deallocations to a given pool.
+
+    Note:
+        - This context manager makes only current thread's allocations route to the given pool.
+        - If a new thread is spawned inside the context manager the allocations in that thread
+          will not route to the given pool.
+        - Only by allocating Device memory inside the context manager, the allocation operation
+          can be routed to the given pool.
+        - Only Atlas A2 training series products support this interface.
+
+    Args:
+        pool(mindspore.runtime.MemPool): a MemPool object that warp a PluggableAllocator.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> path = "/path/to/allocator.so"
+        >>> allocator = ms.runtime.PluggableAllocator(path, "Alloc", "Free")
+        >>> mem_pool = ms.runtime.MemPool(allocator)
+        >>> shape = (1024, 1024)
+        >>> x = ms.ops.Ones()(shape, ms.float32)
+        >>> with ms.runtime.use_mem_pool(mem_pool):
+        >>>     y = ms.ops.Ones()(shape, ms.float32)
+        >>> output = x + y
+    """
+    allocator = pool.allocator
+    _enable_pluggable_allocator(allocator.alloc_fn_ptr, allocator.free_fn_ptr)
+    try:
+        yield
+    finally:
+        _disable_pluggable_allocator()

mindspore/runtime/thread_bind_core.py

@@ -38,7 +38,7 @@ def execute_command(cmd_list):
             out, _ = p.communicate(timeout=1000)
         res = out.decode()
         return res
-    except FileNotFoundError as e:
+    except OSError  as e:
         raise RuntimeError("Failed to execute command") from e
 
 

mindspore/{experimental/llm_boost → tools}/__init__.py

@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""LlmBoost Register"""
+"""Tools module."""
 from __future__ import absolute_import
 
-from mindspore.experimental.llm_boost.atb import LlamaBoost, QwenBoost
-from mindspore.experimental.llm_boost.ascend_native import *
-from mindspore.experimental.llm_boost.register import LlmBoostRegister
+__all__ = ["stress_detect", "sdc_detect_start", "sdc_detect_stop", "get_sdc_detect_result", "set_dump"]
 
-__all__ = ["LlmBoostRegister"]
+from .stress_detect import stress_detect
+from .sdc_detect import sdc_detect_start, sdc_detect_stop, get_sdc_detect_result
+from .data_dump import set_dump

mindspore/tools/data_dump.py

@@ -0,0 +1,130 @@
+# Copyright 2021-2025 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.
+# ============================================================================
+"""Controlling dump behavior."""
+from __future__ import absolute_import
+from warnings import warn
+
+import mindspore.context as context
+from mindspore._c_expression import security
+
+
+def set_dump(target, enabled=True):
+    """
+    Enable or disable dump for the `target` and its contents.
+
+    `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
+    Please note that this API takes effect only when the Dump function is enabled, and the `dump_mode`
+    field in the Dump configuration file is set to `"2"` with the `ms_backend` compilation backend
+    (please refer to the backend parameter in
+    `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_).
+    See the `dump document <https://www.mindspore.cn/tutorials/en/master/debug/dump.html>`_ for details.
+    By default, instances of :class:`mindspore.nn.Cell` and :class:`mindspore.ops.Primitive` do not enable
+    the Dump data feature.
+
+    Note:
+        1. This API is only available for JIT compilation, requires 'Ascend' as the device_target and
+           `ms_backend` as the compilation backend (please refer to the backend parameter in
+           `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_),
+           and does not support fused operators.
+        2. This API only supports being called before training starts.
+           If you call this API during training, it may not be effective.
+        3. After using `set_dump(Cell, True)` , operators in forward and backward
+           computation  (computation generated by the grad operations) of the
+           cell will be dumped.
+        4. For :class:`mindspore.nn.SoftmaxCrossEntropyWithLogits` layer, the forward
+           computation and backward computation use the same set of
+           operators. So you can only see dump data from backward computation.
+           Please note that :class:`mindspore.nn.SoftmaxCrossEntropyWithLogits` layer will also use
+           the above operators internally when initialized with `sparse=True` and
+           `reduction="mean"` .
+
+    Args:
+        target (Union[Cell, Primitive]): The Cell instance or Primitive instance
+            to which the dump flag is set.
+        enabled (bool, optional): ``True`` indicates that the dump is enabled, and ``False`` indicates that
+            the dump is disabled.
+            Default: ``True`` .
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        .. note::
+            Please set environment variable `MINDSPORE_DUMP_CONFIG` to the dump config file and set `dump_mode` field
+            in dump config file to 2 before running this example.
+            See `dump document <https://www.mindspore.cn/tutorials/en/master/debug/dump.html>`_ for details.
+
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> import mindspore.nn as nn
+        >>> from mindspore import Tensor, jit
+        >>> from mindspore.tools import set_dump
+        >>>
+        >>> ms.set_device(device_target="Ascend")
+        >>>
+        >>> class MyNet(nn.Cell):
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.conv1 = nn.Conv2d(5, 6, 5, pad_mode='valid')
+        ...         self.relu1 = nn.ReLU()
+        ...
+        ...     @jit
+        ...     def construct(self, x):
+        ...         x = self.conv1(x)
+        ...         x = self.relu1(x)
+        ...         return x
+        >>>
+        >>> if __name__ == "__main__":
+        ...     net = MyNet()
+        ...     set_dump(net.conv1)
+        ...     input_tensor = Tensor(np.ones([1, 5, 10, 10], dtype=np.float32))
+        ...     output = net(input_tensor)
+    """
+    if security.enable_security():
+        raise ValueError('The set_dump API is not supported, please recompile '
+                         'source without "-s on".')
+
+    import mindspore.nn as nn  # avoid circular import
+    from mindspore.ops import Primitive
+    if not isinstance(target, nn.Cell) and not isinstance(target, Primitive):
+        raise ValueError(f"The \"target\" parameter must be an instance of "
+                         f"Cell or Primitive, "
+                         f"but got an instance of {type(target)}.")
+
+    if not isinstance(enabled, bool):
+        raise ValueError("The \"enabled\" parameter must be bool.")
+
+    # Checking for device target and mode.
+    current_target = context.get_context("device_target")
+    if current_target != "Ascend":
+        # We will not return here in case user changed device_target later.
+        warn("Current device_target is {}, which is not supported by set_dump. "
+             "Only Ascend device target is supported currently. "
+             "If you have Ascend device, consider set device_target to Ascend "
+             "before calling set_dump.".format(current_target))
+
+    # The actual set dump logic.
+    if isinstance(target, nn.Cell):
+        target.add_flags(dump=enabled)
+        for cell in target.cells():
+            set_dump(cell, enabled)
+
+        primitives = getattr(target, "_primitives", {})
+        for value in primitives.values():
+            if value and "dump" in value.attrs:
+                set_dump(value, enabled)
+
+    if isinstance(target, Primitive):
+        target.add_prim_attr("dump", "true" if enabled else "false")

mindspore/tools/sdc_detect.py

@@ -0,0 +1,91 @@
+# Copyright 2025 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.
+# ============================================================================
+"""SDC detect."""
+from mindspore import _c_expression
+
+
+def sdc_detect_start():
+    """
+    Start silent data corruption detection. It will check the inputs and outputs of MatMul operations during the
+    forward and backward computations on the current device, which may increase execution time. The overhead of the
+    check time decreases as the matrix shapes increase. Starting sdc detection results in approximately 100%
+    performance degradation for a single 4096-sized MatMul computation, and approximately 90% degradation on the
+    Llama2-7B model (model parallel is 4, pipeline parallel is 2, and using qkv concatenation and ffn concatenation in
+    decoder layers).
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore.tools import sdc_detect_start
+        >>> sdc_detect_start()
+    """
+    _c_expression.sdc_detect_start()
+
+
+def sdc_detect_stop():
+    """
+    Stop silent data corruption detection.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore.tools import sdc_detect_stop
+        >>> sdc_detect_stop()
+    """
+    _c_expression.sdc_detect_stop()
+
+
+def get_sdc_detect_result():
+    """
+    Get the result of silent data corruption detection.
+
+    Returns:
+        bool, indicating whether silent data corruption has occurred after detection start.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore.tools import get_sdc_detect_result
+        >>> result = get_sdc_detect_result()
+        >>> print(result)
+        False
+    """
+    return _c_expression.get_sdc_detect_result()
+
+
+class _SdcDetector:
+    """
+    Manager of feature value sampling for SDC detect
+    """
+    def __init__(self):
+        self.param_count = -1
+
+    def need_sample(self):
+        """"If need to sample feature value."""
+        if not _c_expression.is_silent_detect_enable():
+            return False
+        grad_sample_interval = _c_expression.get_silent_detect_config('grad_sample_interval')
+        self.param_count = (self.param_count + 1) % grad_sample_interval
+        return self.param_count == 0
+
+    @staticmethod
+    def get_dump_name(param_name):
+        """Get dump file name with sdc prefix."""
+        return _c_expression.get_silent_detect_feature_name(param_name)
+
+_sdc_detector = _SdcDetector()