mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0rc1__cp39-cp39-win_amd64.whl

mindspore/run_check/_check_version.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-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.
@@ -25,7 +25,7 @@ from abc import abstractmethod, ABCMeta
 from packaging import version
 import numpy as np
 from mindspore import log as logger
-from mindspore._c_expression import MSContext, ms_ctx_param
+from mindspore.log import vlog_print
 from ..version import __version__
 
 
@@ -258,7 +258,7 @@ class AscendEnvChecker(EnvChecker):
 
     def __init__(self, library_path):
         self.library_path = library_path
-        self.version = ["7.5", "7.6"]
+        self.version = ["7.6", "7.7"]
 
         # env
         self.path = os.getenv("PATH")
@@ -275,6 +275,7 @@ class AscendEnvChecker(EnvChecker):
         self.python_path_check = "opp/built-in/op_impl/ai_core/tbe"
         self.ld_lib_path_check_fwk = "/lib64"
         self.ascend_opp_path_check = "/op"
+        self.ascend_opp_kernel_path_check = "/opp_kernel"
         self.v = ""
 
     @staticmethod
@@ -286,12 +287,6 @@ 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_910b/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
@@ -347,27 +342,35 @@ class AscendEnvChecker(EnvChecker):
                 logger.warning(f"MindSpore version {mindspore_version} and \"te\" wheel package version {v} does not "
                                "match. For details, refer to the installation guidelines: "
                                "https://www.mindspore.cn/install")
-            from hccl import sys_version as hccl_version
-            v = '.'.join(hccl_version.__sys_version__.split('.')[0:2])
-            if v not in supported_version:
-                attention_warning = True
-                logger.warning(f"MindSpore version {mindspore_version} and \"hccl\" wheel package version {v} does not "
-                               "match. For details, refer to the installation guidelines: "
-                               "https://www.mindspore.cn/install")
         # DO NOT modify exception type to any other, you DO NOT know what kind of exceptions the te will throw.
         # pylint: disable=broad-except
         except Exception as e:
             logger.error(f"CheckFailed: {e}")
-            logger.error("MindSpore relies on whl packages of \"te\" and \"hccl\" in the \"latest\" "
-                         "folder of the Ascend AI software package (Ascend Data Center Solution). Please check whether"
-                         " they are installed correctly or not, refer to the match info on: "
-                         "https://www.mindspore.cn/install")
+            logger.critical("MindSpore relies on whl packages of \"te\" in the \"latest\" folder of the "
+                            "Ascend AI software package (Ascend Data Center Solution). Please check whether they are "
+                            "installed correctly or not, refer to the match info on: https://www.mindspore.cn/install")
         if attention_warning:
             warning_countdown = 3
             for i in range(warning_countdown, 0, -1):
                 logger.warning(f"Please pay attention to the above warning, countdown: {i}")
                 time.sleep(1)
 
+    def check_opp_kernel(self):
+        """
+            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 ("
+                            "Ascend Data Center Solution). Please check whether they are installed correctly or not, "
+                            "refer to the match info on: https://www.mindspore.cn/install")
+            raise Exception("Ascend opp_kernel is not installed")
+
     def set_env(self):
         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"))
@@ -396,6 +399,8 @@ class AscendEnvChecker(EnvChecker):
         # check te version after set te env
         self.check_deps_version()
 
+        self.check_opp_kernel()
+
     def _check_env(self):
         """ascend dependence path check"""
         if self.path is None or self.path_check not in self.path:
@@ -472,6 +477,7 @@ def check_version_and_env_config():
             logger.warning("Pre-Load Library libgomp.so.1 failed, which might cause TLS memory allocation failure. If "
                            "the failure occurs, please refer to the FAQ for a solution: "
                            "https://www.mindspore.cn/docs/en/master/faq/installation.html.")
+        from mindspore._c_expression import MSContext, ms_ctx_param
         MSContext.get_instance().register_check_env_callback(check_env)
         MSContext.get_instance().register_set_env_callback(set_env)
         MSContext.get_instance().set_device_target_inner(MSContext.get_instance().get_param(ms_ctx_param.device_target))
@@ -516,3 +522,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/run_check/run_check.py

@@ -47,7 +47,7 @@ def _check_mul():
 def run_check():
     """
     Provide a convenient API to check if the installation is successful or failed.
-    If the version in the check result is not what you expect, use :func:`mindspore.set_context` to set device_target
+    If the version in the check result is not as expected, use :func:`mindspore.set_context` to set device_target
     before run_check().
 
     Examples:

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, 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,\
+                                 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", "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"
+]
+
+__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

mindspore/runtime/event.py

@@ -0,0 +1,209 @@
+# 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.
+# ============================================================================
+"""Runtime event class"""
+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}
+
+
+class Event(Event_):
+    r"""
+    Wrapper around a device event.
+
+    Device events are synchronization markers that can be used to monitor the device’s progress,
+    to accurately measure timing, and to synchronize device streams.
+
+    The underlying device events are lazily initialized when the event is first recorded.
+
+    Args:
+        enable_timing (bool, optional): indicates if the event should measure time (default: ``False``)
+        blocking (bool, optional): if ``True``, `wait` will be blocking (default: ``False``)
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> ms.set_device("Ascend", 0)
+        >>> start = ms.runtime.Event(enable_timing=True)
+        >>> end = ms.runtime.Event(enable_timing=True)
+        >>> s1 = ms.runtime.Stream()
+        >>> s2 = ms.runtime.Stream()
+        >>> a = Tensor(np.ones([2, 2]), ms.float32)
+        >>> b = Tensor(np.ones([2, 2]), ms.float32)
+        >>> c = Tensor(np.ones([2, 2]), ms.float32)
+        >>> with ms.runtime.StreamCtx(s1):
+        ...     d = ops.matmul(a, b)
+        ...     start.record()
+        >>> c += 2
+        >>> end.record()
+        >>> with ms.runtime.StreamCtx(s2):
+        ...     start.synchronize()
+        ...     end.synchronize()
+        ...     e = c + d
+        >>> ms.runtime.synchronize()
+        >>> print(e)
+        [[5. 5.]
+         [5. 5.]]
+        >>> elapsed_time = start.elapsed_time(end)
+    """
+
+    def __init__(self, enable_timing=False, blocking=False):
+        if not function_event_status['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")
+        super().__init__(enable_timing, blocking)
+
+    def record(self, stream=None):
+        r"""
+        Records the event in a given stream.
+
+        Uses :func:`mindspore.runtime.current_stream()` if no `stream` is specified. The
+        stream's device must match the event's device.
+
+        Args:
+            stream (Stream, optional): a stream to record. If this argument is ``None``,
+                current stream will be used. Default value: ``None``.
+
+        Raises:
+            TypeError: If 'stream' is neither a :class:`mindspore.runtime.Stream` nor a ``None``.
+        """
+        if stream is None:
+            stream = current_stream_()
+        if not isinstance(stream, Stream_):
+            raise TypeError(
+                f"For 'record', the argument 'stream' should be Stream,"
+                f" but got {type(stream)}."
+            )
+        super().record(stream)
+
+    def wait(self, stream=None):
+        r"""
+        Makes all future work submitted to the given stream wait for this
+        event.
+
+        Use :func:`mindspore.runtime.current_stream()` if no `stream` is specified.
+
+        Args:
+            stream (Stream, optional): a stream to record. If this argument is ``None``,
+                current stream will be used. Default value: ``None``.
+
+        Raises:
+            TypeError: If 'stream' is neither a :class:`mindspore.runtime.Stream` nor a ``None``.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> ms.set_device("Ascend", 0)
+            >>> event = ms.runtime.Event()
+            >>> s1 = ms.runtime.Stream()
+            >>> s2 = ms.runtime.Stream()
+            >>> a = Tensor(np.ones([2, 2]), ms.float32)
+            >>> b = Tensor(np.ones([2, 2]), ms.float32)
+            >>> with ms.runtime.StreamCtx(s1):
+            ...     c = ops.matmul(a, b)
+            ...     event.record()
+            >>> event.wait()
+            >>> d = c + 2
+            >>> ms.runtime.synchronize()
+            >>> print(d)
+            [[4. 4.]
+             [4. 4.]]
+        """
+        if not function_event_status['wait']:
+            function_event_status['wait'] = True
+            if not _is_supported():
+                return
+        if stream is None:
+            stream = current_stream_()
+        if not isinstance(stream, Stream_):
+            raise TypeError(
+                f"For 'wait', the argument 'stream' should be Stream,"
+                f" but got {type(stream)}."
+            )
+        super().wait(stream)
+
+    def synchronize(self):
+        r"""
+        Waits for the event to complete.
+
+        Waits until the completion of all work currently captured in this event.
+        This prevents the CPU thread from proceeding until the event completes.
+        """
+        # pylint: disable=useless-super-delegation
+        super().synchronize()
+
+    def query(self):
+        r"""
+        Checks if all work currently captured by event has completed.
+
+        Returns:
+            A boolean indicating if all work currently captured by event has completed.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> ms.set_device("Ascend", 0)
+            >>> a = Tensor(np.ones([1024, 2048]), ms.float32)
+            >>> b = Tensor(np.ones([2048, 4096]), ms.float32)
+            >>> s1 = ms.runtime.Stream()
+            >>> with ms.runtime.StreamCtx(s1):
+            ...     c = ops.matmul(a, b)
+            ...     ev = s1.record_event()
+            >>> s1.synchronize()
+            >>> assert ev.query()
+        """
+        # pylint: disable=useless-super-delegation
+        return super().query()
+
+    def elapsed_time(self, end_event):
+        r"""
+        Returns the time elapsed in milliseconds after the event was
+        recorded and before the end_event was recorded.
+
+        Args:
+            end_event (Event): end event.
+
+        Returns:
+            float, the time elapsed in milliseconds.
+
+        Raises:
+            TypeError: If 'end_event' is not a :class:`mindspore.runtime.Event`.
+        """
+        # pylint: disable=useless-super-delegation
+        if not isinstance(end_event, Event):
+            raise TypeError(
+                f"For 'elapsed_time', the argument 'end_event' should be Event,"
+                f" but got {type(end_event)}."
+            )
+        return super().elapsed_time(end_event)

mindspore/runtime/executor.py

@@ -0,0 +1,177 @@
+# 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.
+# ============================================================================
+
+"""Executor manager interfaces."""
+from mindspore._c_expression import RuntimeConf
+from mindspore.runtime.thread_bind_core import _get_cpu_affinity_policy
+from mindspore._checkparam import args_type_check
+from mindspore import _checkparam as Validator
+from mindspore import log as logger
+
+
+
+def launch_blocking():
+    """
+    Indicates that synchronizing the execution of the startup device reduces the execution performance of the program.
+
+    - In the initial state when this interface is not called, the operator executes asynchronously on the device.
+      In this case, when an error occurs in the execution of the operator,
+      it will not be possible to locate the position of the particular error script code.
+    - When this interface is called, the operator is executed in a synchronized manner on the device.
+      At this point, when an error occurs in the execution of the operator,
+      the location of the erroneous script code can be located based on the error call stack.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 1)
+        >>> ms.runtime.launch_blocking()
+    """
+    return RuntimeConf.get_instance().set_launch_blocking()
+
+
+@args_type_check(threads_num=int)
+def dispatch_threads_num(threads_num):
+    """
+    Set the threads number of runtime used.
+
+    The framework set the runtime number of threads are 5 by default.
+
+    Args:
+        threads_num (int): The threads number of runtime used.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 1)
+        >>> ms.runtime.dispatch_threads_num(6)
+    """
+    if RuntimeConf.get_instance().is_dispatch_threads_num_configured():
+        raise RuntimeError("The 'dispatch_threads_num' can not be set repeatedly.")
+
+    threads_num = Validator.check_positive_int(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):
+    """
+    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.
+
+    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
+          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
+          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,
+             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
+             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,
+             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
+             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.
+
+    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.
+        RuntimeError: The `mindspore.runtime.set_cpu_affinity` API is called repeatedly.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_device("Ascend", 1)
+        >>> ms.runtime.set_cpu_affinity(True)
+        >>>
+        >>> 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"]})
+    """
+    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:
+        RuntimeConf.get_instance().set_thread_bind_core_configured()
+        return
+
+
+@args_type_check(thread_num=int, kernel_group_num=int)
+def set_kernel_launch_group(thread_num=2, kernel_group_num=8):
+    """
+    O0 mode supports operator batch parallel delivery interface, supports enabling
+    parallel delivery, and configures parallel number.
+
+    Args:
+        thread_num (int, optional): The number of concurrent threads, generally not recommended
+            to increase. The `thread_num` and the number of threads configured by the existing interface
+            mindspore.runtime.dispatch_threads_num are independent of each other. Default value is ``2``.
+        kernel_group_num (int, optional): Total number of operator groups,
+            kernel_group_num/thread_num groups per thread. Default value is ``8``.
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.runtime.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 thread_num < 1:
+        raise ValueError(f"The value of thread_num should be at least 1, but got {thread_num}")
+
+    if kernel_group_num < 1:
+        raise ValueError(f"The value of kernel_group_num should be at least 1, but got {kernel_group_num}")
+
+    if (kernel_group_num % thread_num) != 0:
+        raise ValueError(f"Invalid parameter value, kernel_group_num: {kernel_group_num} cannot "
+                         f"be evenly divisible by thread_num: {thread_num}")
+
+    return RuntimeConf.get_instance().set_kernel_launch_group(thread_num, kernel_group_num)