mindspore 2.6.0rc1__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

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)
@@ -164,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}")
 
@@ -175,3 +193,27 @@ 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):
+    """
+    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.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.runtime.set_kernel_launch_capture(enable_capture_graph=True)
+    """
+    if RuntimeConf.get_instance().is_kernel_launch_group_configured():
+        raise RuntimeError("The kernel launch group and kernel launch capture can not be set together")
+
+    return RuntimeConf.get_instance().set_kernel_launch_capture(enable_capture_graph)

mindspore/runtime/memory.py

@@ -14,9 +14,9 @@
 # ============================================================================
 
 """Memory interfaces."""
-
+import os
 from mindspore._c_expression import RuntimeConf, DeviceManagerConf, _memory_stats, \
-    _reset_max_mem_reserved, _reset_max_mem_allocated, DeviceContextManager
+    _reset_max_mem_reserved, _reset_max_mem_allocated, DeviceContextManager, _empty_cache, _memory_replay
 from mindspore import _checkparam as Validator
 from mindspore._checkparam import args_type_check
 from mindspore import log as logger
@@ -50,6 +50,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``
@@ -97,18 +98,9 @@ def _check_memory_conf_valid(memory_size):
                          "It must be a string ending with 'GB', in addition to that, it must contain "
                          "only numbers or decimal points, such as \"5GB\" or \"3.5GB\", but got {}."
                          .format(memory_size))
-    if memory_size == "0GB" or memory_size == "0.0GB":
+    if memory_size in ["0GB", "0.0GB"]:
         raise ValueError("The memory value should not be \"0GB\".")
 
-def _is_initialized(device_target):
-    """
-    Returns whether specified backend is initialized.
-    """
-    _device_context = _device_context_mgr.get_device_context(device_target)
-    if _device_context is None:
-        return False
-    return _device_context.initialized()
-
 def memory_stats():
     """
     Returns status information queried from the memory pool.
@@ -138,9 +130,6 @@ def memory_stats():
         'persistent_mem_pool_stats': {'block_unit_size': 1073741824, 'block_counts': 0, 'blocks_info': {}}}
     """
     device_target = ms.context.get_context("device_target")
-    if not _is_initialized(device_target):
-        logger.warning(f"Backend {device_target} is not initialized yet. Return empty dict.")
-        return {}
     return _memory_stats(device_target)
 
 
@@ -169,9 +158,6 @@ def memory_reserved():
         1073741824
     """
     device_target = ms.context.get_context("device_target")
-    if not _is_initialized(device_target):
-        logger.warning(f"Backend {device_target} is not initialized yet. Return 0.")
-        return 0
     return _memory_stats(device_target).get("total_reserved_memory", 0)
 
 
@@ -200,22 +186,23 @@ def max_memory_reserved():
         1073741824
     """
     device_target = ms.context.get_context("device_target")
-    if not _is_initialized(device_target):
-        logger.warning(f"Backend {device_target} is not initialized yet. Return 0.")
-        return 0
     return _memory_stats(device_target).get("max_reserved_memory", 0)
 
 
 def empty_cache():
     """
-    Release all memory fragments in the memory pool, so that memory arrangement
-    will be optimized.
+    Empty cache in the memory pool.
 
     Note:
-        Currently, the MindSpore memory pool does not have the function of releasing memory fragments.
-        This interface is reserved but implemented as an empty method and prompted in log mode when using.
+        - Empty cache help reduce the fragmentation of device memory.
+        - Support Atlas A2 series products.
+
+    Supported Platforms:
+        ``Ascend``
     """
-    logger.warning(f"The empty_cache operation is currently not supported.")
+    device_target = ms.context.get_context("device_target")
+    release_size = _empty_cache(device_target)
+    logger.info(f"The empty_cache operation is executed successfully, release size: {release_size}.")
 
 
 def reset_peak_memory_stats():
@@ -322,9 +309,6 @@ def memory_allocated():
         1024
     """
     device_target = ms.context.get_context("device_target")
-    if not _is_initialized(device_target):
-        logger.warning(f"Backend {device_target} is not initialized yet. Return 0.")
-        return 0
     return _memory_stats(device_target).get("total_allocated_memory", 0)
 
 
@@ -353,9 +337,6 @@ def max_memory_allocated():
         1536
     """
     device_target = ms.context.get_context("device_target")
-    if not _is_initialized(device_target):
-        logger.warning(f"Backend {device_target} is not initialized yet. Return 0.")
-        return 0
     return _memory_stats(device_target).get("max_allocated_memory", 0)
 
 
@@ -407,3 +388,21 @@ def reset_max_memory_allocated():
     """
     device_target = ms.context.get_context("device_target")
     _reset_max_mem_allocated(device_target)
+
+
+def memory_replay(file_path):
+    """
+    Replay the memory operation based on the application and release order of
+    memory_block.csv.
+
+    Args:
+        file_path (str): The path of memory_block.csv.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.runtime.memory_replay("/data/memory_block.csv")
+    """
+    _memory_replay(os.path.realpath(file_path))