mindspore 2.6.0rc1__cp39-cp39-win_amd64.whl → 2.7.0rc1__cp39-cp39-win_amd64.whl

mindspore/profiler/profiler_action_controller.py

@@ -13,45 +13,41 @@
 # limitations under the License.
 # ============================================================================
 """Profiler Action Controller"""
+__all__ = []
+
 from functools import partial
-from typing import Dict, Optional, Callable, Any
+from typing import Optional, Callable, Any, Dict
 
 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.
+    It uses an 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.
+        action_map (Dict): A map of state 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.
+        Initializes a new instance of ProfilerActionController.
 
         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
+        self.action_map = self._init_action_map()
 
     def _trace_ready(self):
         """
@@ -64,80 +60,34 @@ class ProfilerActionController:
 
     def transit_action(self, prev_action: ProfilerAction, current_action: ProfilerAction) -> None:
         """
-        Handles actions between previous action and latter action
+        Handles actions between previous action and current 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:
+            current_action: the current state
         """
-        Obtain the action in the normal state
+        # Get the action list for this state transition
+        action_list = self.action_map.get((prev_action, current_action))
 
-        Args:
-            start_state: The previous state
-            end_state: the latter state
+        if action_list:
+            logger.info(f"ProfilerAction transition: {prev_action} -> {current_action}")
+            for action in action_list:
+                action()
 
-        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.clear, 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:
+    def _init_action_map(self) -> Dict:
         """
-        Generate a normal action map
+        Initialize the action map for state transitions.
 
         Returns:
-            normal_action_map map
+            Dict: A map of state transitions and their corresponding actions.
         """
-        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
+        action_map = {
+            (ProfilerAction.NONE, ProfilerAction.NONE): [],
+            (ProfilerAction.NONE, ProfilerAction.WARM_UP): [self.prof_interface.init],
+            (ProfilerAction.NONE, ProfilerAction.RECORD): [self.prof_interface.init, self.prof_interface.start],
+            (ProfilerAction.NONE, ProfilerAction.RECORD_AND_SAVE): [self.prof_interface.init,
+                                                                    self.prof_interface.start],
 
-        Returns:
-            abnormal_action_map map
-        """
-        return {
             (ProfilerAction.WARM_UP, ProfilerAction.NONE): [
                 partial(logger.warning, "Incorrect schedule: WARMUP followed by NONE"),
                 self.prof_interface.start,
@@ -145,6 +95,10 @@ class ProfilerActionController:
                 self.prof_interface.finalize,
                 self.prof_interface.clear
             ],
+            (ProfilerAction.WARM_UP, ProfilerAction.WARM_UP): [],
+            (ProfilerAction.WARM_UP, ProfilerAction.RECORD): [self.prof_interface.start],
+            (ProfilerAction.WARM_UP, ProfilerAction.RECORD_AND_SAVE): [self.prof_interface.start],
+
             (ProfilerAction.RECORD, ProfilerAction.NONE): [
                 partial(logger.warning, "Incorrect schedule: RECORD followed by NONE"),
                 self.prof_interface.stop,
@@ -157,7 +111,40 @@ class ProfilerActionController:
                 self.prof_interface.finalize,
                 self.prof_interface.clear
             ],
-            # used for exit action
+            (ProfilerAction.RECORD, ProfilerAction.RECORD): [],
+            (ProfilerAction.RECORD, ProfilerAction.RECORD_AND_SAVE): [],
+
+            (ProfilerAction.RECORD_AND_SAVE, ProfilerAction.NONE): [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear
+            ],
+            (ProfilerAction.RECORD_AND_SAVE, ProfilerAction.WARM_UP): [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear,
+                self.prof_interface.init,
+            ],
+            (ProfilerAction.RECORD_AND_SAVE, ProfilerAction.RECORD): [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear,
+                self.prof_interface.init,
+                self.prof_interface.start
+            ],
+            (ProfilerAction.RECORD_AND_SAVE, ProfilerAction.RECORD_AND_SAVE): [
+                self.prof_interface.stop,
+                self.prof_interface.finalize,
+                self._trace_ready,
+                self.prof_interface.clear,
+                self.prof_interface.init,
+                self.prof_interface.start
+            ],
+
+            # Used for exit action
             (ProfilerAction.WARM_UP, None): [
                 partial(logger.warning,
                         "Incorrect schedule: Stop profiler while current state is WARMUP "
@@ -185,3 +172,4 @@ class ProfilerActionController:
                 self.prof_interface.clear
             ]
         }
+        return action_map

mindspore/profiler/schedule.py

@@ -13,12 +13,12 @@
 # limitations under the License.
 # ============================================================================
 """Profiler Schedule"""
+__all__ = ["ProfilerAction", "Schedule"]
+
 from enum import Enum
 
 from mindspore import log as logger
 
-__all__ = ["ProfilerAction", "Schedule"]
-
 
 class ProfilerAction(Enum):
     """
@@ -83,8 +83,14 @@ class Schedule:
             must be greater than or equal to 0. Default value: ``0``.
         repeat (int, optional): The number of times to repeat the cycle.
             If repeat is set to 0, the Profiler will determine the repeat value based on the number of times the model
-            is trained, which will generate one more performance data with incomplete collection. The data in the last
-            step is abnormal data that users do not need to pay attention to. Default value: ``0``.
+            is trained, for example, if the total training steps are 100, wait+active+warmup=10, skip_first=10,
+            Then repeat=(100-10)/10=9, indicating that the execution is repeated 9 timeswhich will
+            generate one more performance data with incomplete collection. The data in the last step is abnormal data
+            that users do not need to pay attention to. Suggest configuring integers greater than 0. When using
+            cluster analysis tools or MindStudio Insight to view, it is recommended to configure it as 1;
+            If the setting is greater than 1, the collected performance data folder needs to be divided into repeat and
+            other parts, placed in different folders for re-parsing, and classified according to the timestamp order in
+            the folder name. Default value: ``0``.
         skip_first (int, optional): The number of steps to skip at the beginning. Must be greater than or equal to 0.
             Default value: ``0``
 

mindspore/rewrite/common/config.py

@@ -16,6 +16,7 @@
 MindSpore rewrite configurations.
 """
 
+
 def clear_caches():
     """clear rewrite caches"""
     from ..parsers import AssignParser

mindspore/rewrite/common/namer.py

@@ -222,6 +222,7 @@ class ClassNamer(Namer):
 
         super(ClassNamer, self).add_name(name + self._prefix)
 
+
 class FunctionNamer(Namer):
     """
     Used for unique-ing function name in a network.

mindspore/rewrite/common/namespace.py

@@ -34,6 +34,7 @@ _ms_cells_to_subtree = False
 # Paths of modules which will not be considered as third party module
 _ignore_third_party_paths = []
 
+
 def is_subtree(cls_inst):
     """Determine whether 'cls_inst' is a subtree."""
     cls_name = type(cls_inst).__name__

mindspore/rewrite/node/node.py

@@ -124,9 +124,14 @@ class Node:
         self._init_cls = None
 
     @classmethod
-    def create_call_method(cls, ast_node: Optional[ast.AST], targets: [Union[ScopedValue, str]],
-                           func_name: Union[ScopedValue, str], args: [ScopedValue] = None,
-                           kwargs: {str: ScopedValue}=None, name: str = ""):
+    def create_call_method(
+            cls,
+            ast_node: Optional[ast.AST],
+            targets: [Union[ScopedValue, str]],
+            func_name: Union[ScopedValue, str],
+            args: [ScopedValue] = None,
+            kwargs: {str: ScopedValue} = None,  # pylint: disable=bad-whitespace
+            name: str = ""):
         """
         Class method of Node. Instantiate an instance of node whose type is CallCell. A CallCell node represents an
         invoking to cell-op.
@@ -227,8 +232,12 @@ class Node:
         return cls(NodeType.MathOps, ast_node, targets, op_type, args, None, name, None)
 
     @staticmethod
-    def _create_call_function(function: FunctionType, targets: [Union[ScopedValue, str]], args: [ScopedValue] = None,
-                              kwargs: {str: ScopedValue}=None):
+    def _create_call_function(
+            function: FunctionType,
+            targets: [Union[ScopedValue, str]],
+            args: [ScopedValue] = None,
+            kwargs: {str: ScopedValue} = None  # pylint: disable=bad-whitespace
+    ):
         """
         Create a node that corresponds to a function call.
 
@@ -275,9 +284,14 @@ class Node:
         return CallFunction(targets, func_name, args, kwargs, node_name, ast_node, None, None, func_obj, False)
 
     @staticmethod
-    def create_call_op(op: Union[Cell, Primitive], ast_node: Optional[ast.AST], targets: [Union[ScopedValue, str]],
-                       args: [ScopedValue] = None, kwargs: {str: ScopedValue}=None, node_name: str = "",
-                       is_sub_net: bool = False):
+    def create_call_op(
+            op: Union[Cell, Primitive],
+            ast_node: Optional[ast.AST],
+            targets: [Union[ScopedValue, str]],
+            args: [ScopedValue] = None,
+            kwargs: {str: ScopedValue} = None,  # pylint: disable=bad-whitespace
+            node_name: str = "",
+            is_sub_net: bool = False):
         """
         Static method of Node. Instantiate an instance of node whose type is `CallCell` or `CallPrimitive`.
         If op is custom defined, it is treated by TreeNode.
@@ -325,9 +339,15 @@ class Node:
         return Node.create_call_buildin_op(op, ast_node, new_targets, func_name, args, kwargs, node_name)
 
     @classmethod
-    def create_call_buildin_op(cls, op: Union[Cell, Primitive], ast_node: Optional[ast.AST], targets: [ScopedValue],
-                               func_name: ScopedValue, args: [ScopedValue] = None, kwargs: {str: ScopedValue}=None,
-                               node_name: str = ""):
+    def create_call_buildin_op(
+            cls,
+            op: Union[Cell, Primitive],
+            ast_node: Optional[ast.AST],
+            targets: [ScopedValue],
+            func_name: ScopedValue,
+            args: [ScopedValue] = None,
+            kwargs: {str: ScopedValue} = None,  # pylint: disable=bad-whitespace
+            node_name: str = ""):
         """
         Class method of Node. Instantiate an instance of node whose type is `CallCell` or `CallPrimitive`.
         A `CallCell` node represents an invoking to cell-op.

mindspore/rewrite/parsers/assign_parser.py

@@ -46,7 +46,7 @@ class AssignParser(Parser):
     """Parse ast.Assign in construct function to node of SymbolTree."""
 
     # Types for creating Cell Container node
-    types_for_cell_container = [SequentialCell,]
+    types_for_cell_container = [SequentialCell]
     # If mindspore built-in function to be parsered or skipped
     _skip_ms_function = False
     # Functions in black list will not be parsed

mindspore/rewrite/symbol_tree/symbol_tree.py

@@ -1790,7 +1790,7 @@ class SymbolTree(Observer, Observable, NodeManager):
                         if idx > 0:
                             name_need_suffix[name] = suffix_alias(alias, idx)
                         break
-                    elif ast_node.module.startswith(path):
+                    if ast_node.module.startswith(path):
                         # e.g. origin code is 'from a.b import A' and new code is 'from a.b.c import A'
                         # then we just need to update name to A_{idx}
                         if idx > 0:

mindspore/run_check/_check_version.py

@@ -124,9 +124,9 @@ class GPUEnvChecker(EnvChecker):
         for path in self.cuda_lib_path:
             real_path = glob.glob(path + "/lib*/libcudart.so.*.*.*")
             # /usr/lib/x86_64-linux-gnu is a default dir for cuda10.1 on ubuntu.
-            if real_path == []:
+            if not real_path:
                 real_path = glob.glob(path + "/x86_64-linux-gnu/libcudart.so.*.*.*")
-            if real_path == []:
+            if not real_path:
                 continue
             ls_cudart = subprocess.run(["ls", real_path[0]], timeout=10, text=True,
                                        capture_output=True, check=False)
@@ -258,7 +258,7 @@ class AscendEnvChecker(EnvChecker):
 
     def __init__(self, library_path):
         self.library_path = library_path
-        self.version = ["7.6", "7.7"]
+        self.version = ["7.7", "7.8", "8.2"]
 
         # env
         self.path = os.getenv("PATH")
@@ -293,7 +293,7 @@ class AscendEnvChecker(EnvChecker):
 
         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_910/version.info")
+                                           "../lib/plugin/ascend/custom_ascendc_910b/version.info")
         with open(custom_version_path, 'r') as f:
             all_info = f.readlines()
             for line in all_info:
@@ -375,18 +375,15 @@ 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_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_ascend910_path + ":" + cust_ascendc_ascend910b_path + \
-                                                   ":" + cust_aicore_path + ":" + cust_aicpu_path
-        else:
-            os.environ['ASCEND_CUSTOM_OPP_PATH'] = cust_ascendc_ascend910_path + ":" + \
                                                    cust_ascendc_ascend910b_path + ":" + cust_aicore_path + ":" + \
                                                    cust_aicpu_path
+        else:
+            os.environ['ASCEND_CUSTOM_OPP_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"

mindspore/runtime/__init__.py

@@ -18,8 +18,8 @@ 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,\
-                                 reset_peak_memory_stats, memory_summary, memory_allocated,\
+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.stream import Stream, synchronize, set_cur_stream, current_stream, \
     default_stream, communication_stream, StreamCtx
@@ -29,9 +29,9 @@ from .executor import launch_blocking
 __all__ = [
     "launch_blocking", "dispatch_threads_num", "set_cpu_affinity", "set_kernel_launch_group",
     "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"
+    "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"
 ]
 
 __all__.sort()

mindspore/runtime/event.py

@@ -16,7 +16,6 @@
 from mindspore._c_expression import Event as Event_
 from mindspore._c_expression import Stream as Stream_
 from mindspore._c_expression import current_stream as current_stream_
-from mindspore import _checkparam as Validator
 from .device import _is_supported
 
 function_event_status = {'Event': False, 'wait': False}
@@ -71,9 +70,16 @@ class Event(Event_):
             function_event_status['Event'] = True
             if not _is_supported():
                 return
-        # pylint: disable=useless-super-delegation
-        Validator.check_bool(enable_timing, "enable_timing", "Event")
-        Validator.check_bool(blocking, "blocking", "Event")
+        if not isinstance(enable_timing, bool):
+            raise TypeError(
+                f"For 'Event', the 'enable_timing' must be a bool,"
+                f" but got {type(enable_timing).__name__}."
+            )
+        if not isinstance(blocking, bool):
+            raise TypeError(
+                f"For 'Event', the 'blocking' must be a bool,"
+                f" but got {type(blocking).__name__}."
+            )
         super().__init__(enable_timing, blocking)
 
     def record(self, stream=None):

mindspore/runtime/executor.py

@@ -15,7 +15,8 @@
 
 """Executor manager interfaces."""
 from mindspore._c_expression import RuntimeConf
-from mindspore.runtime.thread_bind_core import _get_cpu_affinity_policy
+from mindspore.runtime.thread_bind_core import _get_cpu_affinity_strategy, _validate_affinity_cpu_list, \
+    _validate_module_cpu_index, _adapt_to_dict
 from mindspore._checkparam import args_type_check
 from mindspore import _checkparam as Validator
 from mindspore import log as logger
@@ -64,57 +65,64 @@ def dispatch_threads_num(threads_num):
     return RuntimeConf.get_instance().set_dispatch_threads_num(threads_num)
 
 
-@args_type_check(enable_affinity=bool, affinity_cpu_list=dict)
-def set_cpu_affinity(enable_affinity, affinity_cpu_list=None):
+def set_cpu_affinity(enable_affinity, affinity_cpu_list=None, module_to_cpu_dict=None):
     """
-    Enable thread-level core binding to assign specific CPU cores to MindSpore's main modules (main thread, pynative,
-    runtime, minddata), to prevent unstable performance caused by MindSpore's threads seizing CPU.
+    Enable thread-level core binding to allocate specific CPU cores for key MindSpore modules (main thread, pynative,
+    runtime, and minddata), preventing performance instability caused by CPU core contention among MindSpore threads.
 
     Note:
-        - Provides two binding modes: 1. Automatically generates binding policies based on available CPUs, NUMA nodes,
-          and device resources in the environment to bind cores at thread level. 2. Thread-level bonding based on
-          customized bonding policies passed in by `affinity_cpu_list`.
-
-        - The automated bind-core policy generation scenario invokes system commands to obtain CPU, NUMA node, and
+        - Flexible Core Binding Configuration:
+
+          1. When `affinity_cpu_list` is not specified, the process automatically determines the CPU affinity range
+             based on available CPU cores, NUMA nodes, and device resources in the environment.
+          2. When `affinity_cpu_list` is specified, the process manually binds to the CPU range defined in
+             `affinity_cpu_list`.
+          3. When `module_to_cpu_dict` is not specified, the default bind-core strategy assigns the CPU
+             cores to the `"main"` module.
+          4. When `module_to_cpu_dict` is specified, the process manually binds each module to CPU ranges as
+             defined in `module_to_cpu_dict`.
+        - The automated bind-core strategy generation scenario invokes system commands to obtain CPU, NUMA node, and
           device resources on the environment, and some commands cannot be executed successfully due to environment
-          differences; the automated bind-core policy generated will vary according to the resources available on the
+          differences; the automated bind-core strategy generated will vary according to the resources available on the
           environment:
 
           1. `cat /sys/fs/cgroup/cpuset/cpuset.cpus`, to obtain the available CPU resources on the environment; if the
              execution of this command fails, the bind-core function will not take effect.
           2. `npu-smi info -m`, get the available NPU resources on the environment; if the execution of this command
-             fails, the bind-core policy will be generated only based on the available CPU resources,
+             fails, the bind-core strategy will be generated only based on the available CPU resources,
              without considering the device affinity.
           3. `npu-smi info -t board -i {NPU_ID} -c {CHIP_ID}`, get NPU details based on the logical ID of the device;
-             if the execution of this command fails, the bind-core policy is generated based on the available CPU
+             if the execution of this command fails, the bind-core strategy is generated based on the available CPU
              resources only, regardless of device affinity.
           4. `lspci -s {PCIe_No} -vvv`, get the hardware information of the device on the environment; if the execution
-             of this command fails, the bind-core policy is generated only based on the available CPU resources,
+             of this command fails, the bind-core strategy is generated only based on the available CPU resources,
              without considering the device affinity.
           5. `lscpu`, get information about CPUs and NUMA nodes on the environment; if the execution of this command
-             fails, only the available CPU resources are used to generate the bind-core policy, without considering
+             fails, only the available CPU resources are used to generate the bind-core strategy, without considering
              the device affinity.
 
     Args:
-        enable_affinity (bool): Switches on/off thread-level core binding.
-        affinity_cpu_list (dict, optional): Specifies a customized bind-core policy. The key to be passed
-            into the dict needs to be in string ``"deviceX"`` format, and the value needs to be in list
-            ``["cpuidX-cpuidY"]`` format. Default: ``None``, i.e., use the bind-core policy generated automatically
-            based on the environment. It is allowed to pass the empty dict ``{}``, in which case the bind-core
-            policy generated automatically based on the environment will be used.
+        enable_affinity (bool): Enables/disables thread-level core binding.
+        affinity_cpu_list (list, optional): Manually specifies the CPU affinity range for the process. Format:
+            `["cpuidX-cpuidY"]` (e.g., ``["0-3", "8-11"]``). Default: ``None`` (uses auto-generated binding strategy
+            based on system resources). Passing an empty list `[]` behaves the same as ``None``.
+        module_to_cpu_dict (dict, optional): Customizes core binding for specific modules. Valid keys
+            (module names) are ``"main"``, ``"runtime"``, ``"pynative"``, ``"minddata"``. Valid value is a list
+            of ``int`` indices representing CPU cores (e.g., ``{"main": [0,1], "minddata": [6,7]}``).
+            Default: ``None`` (automatically binds core for module `"main"`). Passing an empty dict `{}`
+            behaves the same as ``None``.
 
     Raises:
-        TypeError: The parameter `enable_affinity` is not a boolean.
-        TypeError: The parameter `affinity_cpu_list` is neither a dictionary nor a ``None``.
-        ValueError: The key of parameter `affinity_cpu_list` is not a string.
-        ValueError: The key of parameter `affinity_cpu_list` is not in ``"deviceX"`` format.
-        ValueError: The parameter `affinity_cpu_list` has a value that is not a list.
-        ValueError: The element in value of parameter `affinity_cpu_list` is not a string.
-        ValueError: The element in value for parameter `affinity_cpu_list` does not match ``["cpuidX-cpuidY"]``.
-        RuntimeError: Automatically generated binding policy or customized binding policy scenario where the number
-            of CPU cores assigned to each device is less than 7.
-        RuntimeError: A custom-specified binding policy scenario where the CPU assigned to a device is not
-            available in the environment.
+        TypeError: The `enable_affinity` parameter is not a boolean.
+        TypeError: The `affinity_cpu_list` parameter is neither a list nor ``None``.
+        TypeError: An element in `affinity_cpu_list` is not a string.
+        ValueError: An element in `affinity_cpu_list` does not follow the ``["cpuidX-cpuidY"]`` format.
+        TypeError: The `module_to_cpu_dict` parameter is neither a dictionary nor ``None``.
+        TypeError: A key in `module_to_cpu_dict` is not a string.
+        TypeError: A value in `module_to_cpu_dict` is not a list.
+        ValueError: An element in `module_to_cpu_dict` values is not a non-negative integer.
+        RuntimeError: In custom core binding scenarios, the specified CPU cores for a device are unavailable
+            in the environment.
         RuntimeError: The `mindspore.runtime.set_cpu_affinity` API is called repeatedly.
 
     Examples:
@@ -124,24 +132,31 @@ def set_cpu_affinity(enable_affinity, affinity_cpu_list=None):
         >>>
         >>> import mindspore as ms
         >>> ms.set_device("Ascend", 1)
-        >>> ms.runtime.set_cpu_affinity(True, {"device0":["0-9"],"device1":["10-15","20-29"],"device2":["35-45"]})
+        >>> ms.runtime.set_cpu_affinity(True, ["10-19", "23-40"])
+        >>>
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 1)
+        >>> ms.runtime.set_cpu_affinity(True, ["10-19", "23-40"], {"main": [0,1,2,3], "runtime": [4,5,6]})
     """
+    affinity_cpu_list = _adapt_to_dict(affinity_cpu_list)
+    if affinity_cpu_list is False:
+        return
+
+    _validate_affinity_cpu_list(affinity_cpu_list)
+    _validate_module_cpu_index(module_to_cpu_dict)
+
     if RuntimeConf.get_instance().is_thread_bind_core_configured():
         raise RuntimeError("The 'mindspore.runtime.set_cpu_affinity' cannot be set repeatedly.")
-    if enable_affinity:
-        module_bind_core_policy, bind_policy_flag = _get_cpu_affinity_policy(affinity_cpu_list)
-        if not module_bind_core_policy:
-            logger.warning("set_cpu_affinity is not enabled because the environment does not meet the "
-                           "basic conditions for binding core.")
-            RuntimeConf.get_instance().set_thread_bind_core_configured()
-            return
-        if bind_policy_flag:
-            RuntimeConf.get_instance().thread_bind_core_with_policy(module_bind_core_policy)
-        else:
-            RuntimeConf.get_instance().thread_bind_core(module_bind_core_policy)
-    else:
+    if not enable_affinity:
+        RuntimeConf.get_instance().set_thread_bind_core_configured()
+        return
+    module_bind_core_strategy = _get_cpu_affinity_strategy(affinity_cpu_list, module_to_cpu_dict)
+    if not module_bind_core_strategy:
+        logger.warning("set_cpu_affinity is not enabled because the environment does not meet the "
+                       "basic conditions for binding core.")
         RuntimeConf.get_instance().set_thread_bind_core_configured()
         return
+    RuntimeConf.get_instance().thread_bind_core(module_bind_core_strategy)
 
 
 @args_type_check(thread_num=int, kernel_group_num=int)