mindspore 2.4.1__cp311-cp311-manylinux1_x86_64.whl → 2.5.0__cp311-cp311-manylinux1_x86_64.whl

mindspore/profiler/profiler_action_controller.py

@@ -0,0 +1,187 @@
+# Copyright 2024-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.
+# ============================================================================
+"""Profiler Action Controller"""
+from functools import partial
+from typing import Dict, Optional, Callable, Any
+
+from mindspore.profiler.profiler_interface import ProfilerInterface
+from mindspore.profiler.schedule import ProfilerAction
+
+from mindspore import log as logger
+
+__all__ = []
+
+
+class ProfilerActionController:
+    """
+    A controller class for managing profiler actions and transitions.
+
+    This class handles the actions and transitions between different profiler states.
+    It uses two maps, abnormal_action_map and normal_action_map, to determine the actions
+    to take based on the previous and current profiler actions.
+
+    Attributes:
+        profiler: The profiler instance associated with this controller.
+        prof_interface (ProfilerInterface): The profiler interface instance.
+        on_trace_ready (Optional[Callable[..., Any]]): A callback function to be called when the trace is ready.
+        abnormal_action_map (Dict): A map of abnormal transitions and their corresponding actions.
+        normal_action_map (Dict): A map of normal transitions and their corresponding actions.
+    """
+
+    def __init__(self, prof_interface: ProfilerInterface, on_trace_ready: Optional[Callable[..., Any]] = None) -> None:
+        """
+        Initializes a new instance of ProfActionController.
+
+        Args:
+            prof_interface (ProfilerInterface): The profiler interface instance.
+            on_trace_ready (Optional[Callable[..., Any]]): A callback function to be called when the trace is ready.
+        """
+        self.prof_interface = prof_interface
+        self.abnormal_action_map: Dict = self.init_abnormal_action_map()
+        self.normal_action_map: Dict = self.init_normal_action_map()
+        self.on_trace_ready = on_trace_ready
+
+    def _trace_ready(self):
+        """
+        Calls the on_trace_ready callback function if it is set.
+
+        This method is called when the trace is ready to notify the callback function.
+        """
+        if self.on_trace_ready:
+            self.on_trace_ready()
+
+    def transit_action(self, prev_action: ProfilerAction, current_action: ProfilerAction) -> None:
+        """
+        Handles actions between previous action and latter action
+
+        Args:
+            prev_action: The previous state
+            current_action: the latter state
+        """
+        # Check whether the action is in the abnormal map
+        action_list = self.abnormal_action_map.get((prev_action, current_action), [])
+        if not action_list:
+            if isinstance(prev_action, ProfilerAction) and isinstance(current_action, ProfilerAction):
+                # Check whether the action is in the normal map
+                action_list = self.handle_normal_action(prev_action, current_action)
+        if not action_list:
+            return
+        for action in action_list:
+            action()
+
+    def handle_normal_action(self, start_state: ProfilerAction, end_state: ProfilerAction) -> list:
+        """
+        Obtain the action in the normal state
+
+        Args:
+            start_state: The previous state
+            end_state: the latter state
+
+        Returns:
+            process_action list
+        """
+        process_action = []
+        initial_state = start_state
+
+        # Handle special case for ProfilerAction.RECORD_AND_SAVE to ProfilerAction.RECORD_AND_SAVE transition
+        if start_state == ProfilerAction.RECORD_AND_SAVE and end_state == ProfilerAction.RECORD_AND_SAVE:
+            process_action = [self.prof_interface.stop, self.prof_interface.finalize,
+                              self._trace_ready, self.prof_interface.init,
+                              self.prof_interface.start]
+        else:
+            while start_state != end_state:
+                process_action.extend(self.normal_action_map[start_state])
+                start_state = ProfilerAction.get_by_value((start_state.value + 1) % len(ProfilerAction))
+
+            # Handle special cases for NONE to NONE, WARM_UP to WARM_UP, RECORD to RECORD transitions
+            if initial_state == start_state and initial_state != ProfilerAction.RECORD_AND_SAVE:
+                process_action = []
+
+        return process_action
+
+    def init_normal_action_map(self) -> dict:
+        """
+        Generate a normal action map
+
+        Returns:
+            normal_action_map map
+        """
+        return {
+            ProfilerAction.NONE: [self.prof_interface.init],
+            ProfilerAction.WARM_UP: [self.prof_interface.start],
+            ProfilerAction.RECORD: [],
+            ProfilerAction.RECORD_AND_SAVE: [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear
+            ]
+        }
+
+    def init_abnormal_action_map(self) -> dict:
+        """
+        Generate a abnormal action map
+
+        Returns:
+            abnormal_action_map map
+        """
+        return {
+            (ProfilerAction.WARM_UP, ProfilerAction.NONE): [
+                partial(logger.warning, "Incorrect schedule: WARMUP followed by NONE"),
+                self.prof_interface.start,
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self.prof_interface.clear
+            ],
+            (ProfilerAction.RECORD, ProfilerAction.NONE): [
+                partial(logger.warning, "Incorrect schedule: RECORD followed by NONE"),
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self.prof_interface.clear
+            ],
+            (ProfilerAction.RECORD, ProfilerAction.WARM_UP): [
+                partial(logger.warning, "Incorrect schedule: RECORD followed by WARMUP"),
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self.prof_interface.clear
+            ],
+            # used for exit action
+            (ProfilerAction.WARM_UP, None): [
+                partial(logger.warning,
+                        "Incorrect schedule: Stop profiler while current state is WARMUP "
+                        "which will result in empty parsed data."),
+                self.prof_interface.finalize,
+                self.prof_interface.clear,
+                self.prof_interface.delete_dir
+            ],
+            (ProfilerAction.RECORD, None): [
+                partial(logger.warning,
+                        "Incorrect schedule: Stop profiler while current state is RECORD "
+                        "which may result in incomplete parsed data."),
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear
+            ],
+            (ProfilerAction.RECORD_AND_SAVE, None): [
+                partial(logger.warning,
+                        "Stop profiler while current state is RECORD_AND_SAVE, "
+                        "perhaps the scheduling cycle has not yet completed."),
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear
+            ]
+        }

mindspore/profiler/profiler_interface.py

@@ -0,0 +1,114 @@
+# Copyright 2020-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.
+# ============================================================================
+"""ProfilerInterface"""
+from typing import Set
+
+from mindspore import log as logger
+from mindspore.common.api import _pynative_executor
+from mindspore.profiler.common.registry import PROFILERS
+from mindspore.profiler.platform.base_profiler import BaseProfiler
+from mindspore.profiler.common.profiler_context import ProfilerContext
+from mindspore.profiler.common.profiler_path_manager import ProfilerPathManager
+
+
+class ProfilerInterface:
+    """
+    Profiler interface
+    """
+
+    cpu_profiler: BaseProfiler = None
+    device_profiler: BaseProfiler = None
+    platform_profilers_set: Set[BaseProfiler] = set()
+    is_initialized = False
+
+    @classmethod
+    def init(cls):
+        """ProfilerInterface init"""
+        if cls.is_initialized:
+            return
+
+        ProfilerPathManager().set_ascend_ms_dir()
+        ProfilerPathManager().create_profiler_paths()
+        platforms = ProfilerContext().device_target_set
+        for device_target in platforms:
+            cls.platform_profilers_set.add(PROFILERS.modules.get(device_target)())
+
+        cls.is_initialized = True
+        logger.info("ProfilerInterface init")
+
+    @classmethod
+    def start(cls):
+        """ProfilerInterface start"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface start failed, profiler has not been initialized.")
+            return
+
+        for profiler in cls.platform_profilers_set:
+            profiler.start()
+
+        logger.info("ProfilerInterface start")
+
+    @classmethod
+    def stop(cls):
+        """ProfilerInterface stop"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface stop failed, profiler has not been initialized.")
+            return
+
+        _pynative_executor.sync()
+        for profiler in cls.platform_profilers_set:
+            profiler.stop()
+
+        logger.info("ProfilerInterface stop")
+
+    @classmethod
+    def analyse(cls):
+        """ProfilerInterface analyse"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface analyse failed, profiler has not been initialized.")
+            return
+
+        for profiler in cls.platform_profilers_set:
+            profiler.analyse()
+
+        logger.info("ProfilerInterface analyse")
+
+    @classmethod
+    def finalize(cls):
+        """ProfilerInterface finalize"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface finalize failed, profiler has not been initialized.")
+            return
+
+        for profiler in cls.platform_profilers_set:
+            profiler.finalize()
+            profiler = None
+
+        logger.info("ProfilerInterface finalize")
+
+    @classmethod
+    def clear(cls):
+        """ProfilerInterface clear"""
+        if not cls.is_initialized:
+            logger.warning("ProfilerInterface clear failed, profiler has not been initialized.")
+            return
+        cls.platform_profilers_set.clear()
+        cls.is_initialized = False
+        logger.info("ProfilerInterface clear")
+
+    @classmethod
+    def delete_dir(cls):
+        """ProfilerInterface delete dir"""
+        logger.info("ProfilerInterface delete dir")

mindspore/profiler/schedule.py

@@ -0,0 +1,208 @@
+# Copyright 2020-2023 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.
+# ============================================================================
+"""Profiler Schedule"""
+from enum import Enum
+
+from mindspore import log as logger
+
+__all__ = ["ProfilerAction", "Schedule"]
+
+
+class ProfilerAction(Enum):
+    """
+    Enum class representing different actions that can be performed by the profiler.
+
+    Each member of the enum represents a specific profiling action, which can be used
+    to control the behavior of the profiler at different stages of execution.
+
+    Attributes:
+        NONE (ProfilerAction): No profiling action.
+        WARM_UP (ProfilerAction): Warm-up phase of profiling.
+        RECORD (ProfilerAction): Record phase of profiling.
+        RECORD_AND_SAVE (ProfilerAction): Record and save phase of profiling.
+    """
+    NONE = 0
+    WARM_UP = 1
+    RECORD = 2
+    RECORD_AND_SAVE = 3
+
+    @staticmethod
+    def get_by_value(value):
+        """
+        Retrieves a ProfilerAction enum member by its value.
+
+        Args:
+            value (int): The value of the ProfilerAction enum member to retrieve.
+
+        Returns:
+            ProfilerAction, The enum member corresponding to the given value, or None if not found.
+        """
+        value_map = {action.value: action for action in ProfilerAction}
+        return value_map.get(value, None)
+
+
+class Schedule:
+    r"""
+    This class use to get the actions of each step.
+    The schedule is as follows:
+
+    .. code-block::
+
+        (NONE)        (NONE)          (NONE)       (WARM_UP)       (RECORD)      (RECORD)     (RECORD_AND_SAVE)    None
+        START------->skip_first------->wait-------->warmup-------->active........active.........active----------->stop
+                                      |                                                             |
+                                      |                           repeat_1                          |
+                                      ---------------------------------------------------------------
+
+    The profiler will skip the first ``skip_first`` steps, then wait for ``wait`` steps,
+    then do the warmup for the next ``warmup`` steps, then do the active recording for the next
+    ``active`` steps and then repeat the cycle starting with ``wait`` steps. The optional number
+    of cycles is specified with the ``repeat`` parameter, the zero value means that
+    the cycles will continue until the profiling is finished.
+
+    Keyword Args:
+        wait (int): The number of steps to wait before starting the warm-up phase.
+        active (int): The number of steps to record data during the active phase.
+        warmup (int, optional): The number of steps to perform the warm-up phase. Default: ``0``.
+        repeat (int, optional): The number of times to repeat the cycle. Default: ``0``.
+        skip_first (int, optional): The number of steps to skip at the beginning. Default: ``0``.
+
+    Raises:
+        ValueError: When the parameter step is less than 0.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> import mindspore.dataset as ds
+        >>> from mindspore import context, nn, Profiler
+        >>> from mindspore.profiler import schedule, tensor_board_trace_handler
+        >>>
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.fc = nn.Dense(2, 2)
+        ...
+        ...     def construct(self, x):
+        ...         return self.fc(x)
+        >>>
+        >>> def generator_net():
+        ...     for _ in range(2):
+        ...         yield np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32)
+        >>>
+        >>> def train(test_net):
+        ...     optimizer = nn.Momentum(test_net.trainable_params(), 1, 0.9)
+        ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+        ...     data = ds.GeneratorDataset(generator_net(), ["data", "label"])
+        ...     model = ms.train.Model(test_net, loss, optimizer)
+        ...     model.train(1, data)
+        >>>
+        >>> if __name__ == '__main__':
+        ...     context.set_context(mode=ms.PYNATIVE_MODE, device_target="Ascend")
+        ...
+        ...     net = Net()
+        ...     STEP_NUM = 15
+        ...
+        ...     with Profiler(schedule=schedule(wait=1, warmup=1, active=2, repeat=1, skip_first=2),
+        ...                   on_trace_ready=tensor_board_trace_handler) as prof:
+        ...         for i in range(STEP_NUM):
+        ...             train(net)
+        ...             prof.step()
+    """
+
+    def __init__(self, *, wait: int, active: int, warmup: int = 0, repeat: int = 0, skip_first: int = 0) -> None:
+        self.wait = wait
+        self.active = active
+        self.warmup = warmup
+        self.repeat = repeat
+        self.skip_first = skip_first
+        self._check_params()
+
+    def __call__(self, step: int) -> ProfilerAction:
+        """
+        Obtain the action of the specified step from the schedule.
+
+        Args:
+            step (int): step num.
+
+        Returns:
+            ProfilerAction, The action corresponding to a step.
+        """
+        if step < 0:
+            raise ValueError("Invalid parameter step, which must be not less than 0.")
+        if step < self.skip_first:
+            return ProfilerAction.NONE
+
+        step -= self.skip_first
+
+        num_steps = self.wait + self.warmup + self.active
+        if 0 < self.repeat <= step / num_steps:
+            return ProfilerAction.NONE
+
+        mod_step = step % num_steps
+        if mod_step < self.wait:
+            return ProfilerAction.NONE
+        if mod_step < self.wait + self.warmup:
+            return ProfilerAction.WARM_UP
+        return ProfilerAction.RECORD if mod_step < num_steps - 1 else ProfilerAction.RECORD_AND_SAVE
+
+    def _check_params(self):
+        """
+        Verify all parameters in the schedule,
+        and set them to default values if the parameters are not compliant.
+        """
+        if not isinstance(self.wait, int) or self.wait < 0:
+            logger.warning("Invalid parameter wait, reset it to 0.")
+            self.wait = 0
+        if not isinstance(self.warmup, int) or self.warmup < 0:
+            logger.warning("Invalid parameter warmup, reset it to 0.")
+            self.warmup = 0
+        if not isinstance(self.active, int) or self.active <= 0:
+            logger.warning("Invalid parameter active, reset it to 1.")
+            self.active = 1
+        if not isinstance(self.repeat, int) or self.repeat < 0:
+            logger.warning("Invalid parameter repeat, reset it to 0.")
+            self.repeat = 0
+        if not isinstance(self.skip_first, int) or self.skip_first < 0:
+            logger.warning("Invalid parameter skip_first, reset it to 0.")
+            self.skip_first = 0
+        if self.warmup == 0:
+            logger.warning("Profiler won't be using warmup, this can skew profiler results")
+
+    def to_dict(self):
+        """
+        Convert schedule to a dict.
+
+        Returns:
+            dict, the parameters of schedule and their values.
+        """
+        return {'wait': self.wait, 'active': self.active, 'warmup': self.warmup,
+                'repeat': self.repeat, 'skip_first': self.skip_first}
+
+
+def _default_schedule_fn(_: int) -> ProfilerAction:
+    """
+    Default profiler behavior - immediately starts recording the events,
+    keeps doing it on every profiler step.
+
+    Args:
+        _ (int): step num.
+
+    Returns:
+        ProfilerAction, The RECORD action.
+    """
+    return ProfilerAction.RECORD

mindspore/rewrite/api/symbol_tree.py

@@ -331,8 +331,7 @@ class SymbolTree:
         Nodes in `new_nodes` will be inserted into SymbolTree sequentially, and then `old_node` will be deleted.
 
         Note:
-            - Replace support one-to-one replacement or one-to-multi replacement. If you need multi-to-multi
-              replacement, please refer to `PatternEngine`.
+            - Replace only support one-to-one replacement or one-to-multi replacement.
             - Caller should maintain the topological relationship between each node in the `new_nodes` , as well as
               the topological relationship between nodes in the `new_nodes` and nodes in the original tree.
 

mindspore/run_check/_check_version.py

@@ -25,6 +25,7 @@ from abc import abstractmethod, ABCMeta
 from packaging import version
 import numpy as np
 from mindspore import log as logger
+from mindspore.log import vlog_print
 from mindspore._c_expression import MSContext, ms_ctx_param
 from ..version import __version__
 
@@ -258,7 +259,7 @@ class AscendEnvChecker(EnvChecker):
 
     def __init__(self, library_path):
         self.library_path = library_path
-        self.version = ["7.3", "7.5"]
+        self.version = ["7.5", "7.6"]
 
         # env
         self.path = os.getenv("PATH")
@@ -266,7 +267,7 @@ class AscendEnvChecker(EnvChecker):
         self.ld_lib_path = os.getenv("LD_LIBRARY_PATH")
         self.ascend_opp_path = os.getenv("ASCEND_OPP_PATH")
         self.ascend_aicpu_path = os.getenv("ASCEND_AICPU_PATH")
-        if not self.ascend_opp_path is None:
+        if self.ascend_opp_path is not None:
             self.compiler_version = self.ascend_opp_path.split("opp")[0] + "compiler/version.info"
         else:
             self.compiler_version = ""
@@ -286,19 +287,13 @@ class AscendEnvChecker(EnvChecker):
 
     def check_custom_version(self):
         """custom op version check"""
-        custom_ascendc_soc_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                              "../lib/plugin/ascend/custom_ascendc_ops/op_impl/ai_core/tbe/kernel",
-                                              MSContext.get_instance().get_ascend_soc_version())
-        if not os.path.exists(custom_ascendc_soc_dir):
-            logger.debug(f"The path {custom_ascendc_soc_dir} of the custom ascend c operator does not exist.")
-            return False
 
         if not Path(self.compiler_version).is_file():
             return True
 
         cur_version = self._read_version(self.compiler_version)
         custom_version_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                           "../lib/plugin/ascend/custom_ascendc_ops/version.info")
+                                           "../lib/plugin/ascend/custom_ascendc_910/version.info")
         with open(custom_version_path, 'r') as f:
             all_info = f.readlines()
             for line in all_info:
@@ -372,12 +367,21 @@ class AscendEnvChecker(EnvChecker):
         curr_path = os.path.realpath(os.path.dirname(__file__))
         cust_aicpu_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicpu_ops"))
         cust_aicore_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_aicore_ops"))
-        cust_ascendc_path = os.path.realpath(os.path.join(curr_path, "../lib/plugin/ascend/custom_ascendc_ops"))
+        cust_ascendc_ascend910_path = os.path.realpath(
+            os.path.join(curr_path, "../lib/plugin/ascend/custom_ascendc_910"))
+        cust_ascendc_ascend910b_path = os.path.realpath(
+            os.path.join(curr_path, "../lib/plugin/ascend/custom_ascendc_910b"))
         if os.getenv('ASCEND_CUSTOM_OPP_PATH'):
             os.environ['ASCEND_CUSTOM_OPP_PATH'] = os.environ['ASCEND_CUSTOM_OPP_PATH'] + ":" + \
-                                                   cust_ascendc_path + ":" + cust_aicore_path + ":" + cust_aicpu_path
+                                                   cust_ascendc_ascend910_path + ":" + cust_ascendc_ascend910b_path + \
+                                                   ":" + cust_aicore_path + ":" + cust_aicpu_path
         else:
-            os.environ['ASCEND_CUSTOM_OPP_PATH'] = cust_ascendc_path + ":" + cust_aicore_path + ":" + cust_aicpu_path
+            os.environ['ASCEND_CUSTOM_OPP_PATH'] = cust_ascendc_ascend910_path + ":" + \
+                                                   cust_ascendc_ascend910b_path + ":" + cust_aicore_path + ":" + \
+                                                   cust_aicpu_path
+        # Ignore ge infer missing error. To be removed after infers are completed.
+        os.environ['FAST_IGNORE_INFER_ERROR'] = "1"
+        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)
@@ -400,7 +404,7 @@ class AscendEnvChecker(EnvChecker):
                 "Environment Variable PYTHONPATH is set. For details, refer to the installation guidelines: "
                 "https://www.mindspore.cn/install")
 
-        if self.ld_lib_path is None or not self.ld_lib_path_check_fwk in self.ld_lib_path:
+        if self.ld_lib_path is None or self.ld_lib_path_check_fwk not in self.ld_lib_path:
             logger.warning("Can not find driver so(need by mindspore-ascend). Please check whether the "
                            "Environment Variable LD_LIBRARY_PATH is set. For details, refer to the installation "
                            "guidelines: https://www.mindspore.cn/install")
@@ -507,3 +511,4 @@ def _add_cuda_path():
 _set_pb_env()
 check_version_and_env_config()
 _add_cuda_path()
+vlog_print("1", "ME", __file__, sys._getframe().f_lineno, "Initialization MindSpore.")

mindspore/runtime/__init__.py

@@ -0,0 +1,37 @@
+# Copyright 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.
+# ============================================================================
+
+"""
+The runtime interface.
+"""
+
+from mindspore.runtime.executor import launch_blocking, dispatch_threads_num, set_cpu_affinity
+from mindspore.runtime.memory import set_memory, memory_stats, memory_reserved, max_memory_reserved, empty_cache,\
+                                 reset_peak_memory_stats, memory_summary, memory_allocated,\
+                                 max_memory_allocated, reset_max_memory_reserved, reset_max_memory_allocated
+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",
+    "Stream", "communication_stream", "synchronize", "set_cur_stream", "current_stream", "default_stream", "StreamCtx",
+    "set_memory", "memory_stats", "memory_reserved", "max_memory_reserved", "empty_cache", "reset_peak_memory_stats",
+    "memory_summary", "memory_allocated", "max_memory_allocated", "reset_max_memory_reserved",
+    "reset_max_memory_allocated", "Event"
+]
+
+__all__.sort()

mindspore/runtime/device.py

@@ -0,0 +1,27 @@
+# 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.
+# ============================================================================
+
+"""Runtime inner interfaces."""
+
+from mindspore import log as logger
+import mindspore as ms
+
+
+def _is_supported():
+    device_target = ms.context.get_context("device_target")
+    if device_target == 'CPU':
+        logger.error(f"CPU device is not supported. Please use correct device")
+        return False
+    return True