mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/hal/__init__.py

@@ -0,0 +1,40 @@
+# Copyright 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.
+# ============================================================================
+
+"""
+The HAL encapsulates interfaces for device management, flow management, and event management.
+MindSpore abstracts the preceding modules from different backends and allows users to schedule hardware
+resources at the Python layer. Currently, these interfaces take effect only in PyNative mode.
+"""
+
+from mindspore.hal.device import is_initialized, is_available, device_count, get_device_capability,\
+                                 get_device_properties, get_device_name, get_arch_list
+from mindspore.hal.stream import Stream, synchronize, set_cur_stream, current_stream, default_stream,\
+                                 communication_stream, StreamCtx
+from mindspore.hal.event import Event
+from mindspore.hal.memory import 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
+
+__all__ = [
+    "is_initialized", "is_available", "device_count", "get_device_capability",
+    "get_device_properties", "get_device_name", "get_arch_list",
+    "Event", "communication_stream", "Stream", "synchronize", "set_cur_stream", "current_stream", "default_stream",
+    "StreamCtx", "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"
+]
+
+__all__.sort()

mindspore/hal/_ascend.py

@@ -0,0 +1,57 @@
+# Copyright 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.
+# ============================================================================
+
+"""Hal ascend interfaces."""
+from mindspore._c_expression import ascend_get_device_count, ascend_get_device_name, ascend_get_device_properties
+from mindspore import log as logger
+from ._base import _HalBase
+
+
+class _HalAscend(_HalBase):
+    """
+    Hal ascend interfaces.
+    """
+    def __init__(self):
+        super(_HalAscend, self).__init__("Ascend")
+
+    def device_count(self):
+        """
+        Return Ascend device count.
+        """
+        return ascend_get_device_count()
+
+    def get_device_capability(self, device_id):
+        """
+        Get Ascend capability of the specified device id. Not implemented for Ascend.
+        """
+        logger.warning("'get_device_capability' for Ascend is not implemented. Return None.")
+
+    def get_device_properties(self, device_id):
+        """
+        Get Ascend properties of the specified device id.
+        """
+        return ascend_get_device_properties(device_id)
+
+    def get_device_name(self, device_id):
+        """
+        Get Ascend name of the specified device id.
+        """
+        return ascend_get_device_name(device_id)
+
+    def get_arch_list(self):
+        """
+        Get the architecture list this MindSpore was compiled for. Not implemented for Ascend yet.
+        """
+        logger.warning("'get_arch_list' for Ascend is not implemented. Return None.")

mindspore/hal/_base.py

@@ -0,0 +1,57 @@
+# Copyright 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.
+# ============================================================================
+
+"""Hal base class."""
+from mindspore._c_expression import MSContext, DeviceContextManager
+
+_context_handle = MSContext.get_instance()
+_device_context_mgr = DeviceContextManager.get_instance()
+
+
+class _HalBase():
+    """
+    Hal base class. Different backends inherit from this class and wrap around hardware interfaces.
+    """
+    def __init__(self, backend=None):
+        valid_backends = ["CPU", "GPU", "Ascend"]
+        if backend not in valid_backends:
+            raise ValueError(f"For '_HalBase', the argument 'backend' must be one of "
+                             f"{valid_backends}, but got {backend}.")
+        self.backend = backend
+
+    def device_count(self):
+        """
+        Return device count of this backend.
+        """
+
+    def get_device_capability(self, device_id):
+        """
+        Get device capability of the specified device id.
+        """
+
+    def get_device_properties(self, device_id):
+        """
+        Get device properties of the specified device id.
+        """
+
+    def get_device_name(self, device_id):
+        """
+        Get device name of the specified device id.
+        """
+
+    def get_arch_list(self):
+        """
+        Get the architecture list this MindSpore was compiled for.
+        """

mindspore/hal/_cpu.py

@@ -0,0 +1,56 @@
+# Copyright 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.
+# ============================================================================
+
+"""Hal cpu interfaces."""
+from mindspore import log as logger
+from ._base import _HalBase
+
+
+class _HalCPU(_HalBase):
+    """
+    Hal cpu interfaces.
+    """
+    def __init__(self):
+        super(_HalCPU, self).__init__("CPU")
+
+    def device_count(self):
+        """
+        Return CPU device count. Always return 1 for CPU.
+        """
+        return 1
+
+    def get_device_capability(self, device_id):
+        """
+        Get CPU capability of the specified device id. Not implemented for CPU.
+        """
+        logger.warning("'get_device_capability' for CPU is not implemented. Return None.")
+
+    def get_device_properties(self, device_id):
+        """
+        Get CPU properties of the specified device id. Not implemented for CPU.
+        """
+        logger.warning("'get_device_properties' for CPU is not implemented. Return None.")
+
+    def get_device_name(self, device_id):
+        """
+        Get CPU name of the specified device id. Always return "CPU".
+        """
+        return "CPU"
+
+    def get_arch_list(self):
+        """
+        Get the architecture list this MindSpore was compiled for. Not implemented for CPU.
+        """
+        logger.warning("'get_arch_list' for CPU is not implemented. Return None.")

mindspore/hal/_gpu.py

@@ -0,0 +1,57 @@
+# Copyright 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.
+# ============================================================================
+
+"""Hal gpu interfaces."""
+from mindspore._c_expression import gpu_get_device_count, gpu_get_device_name, gpu_get_device_capability, \
+     gpu_get_device_properties, gpu_get_arch_list
+from ._base import _HalBase
+
+
+class _HalGPU(_HalBase):
+    """
+    Hal gpu interfaces.
+    """
+    def __init__(self):
+        super(_HalGPU, self).__init__("GPU")
+
+    def device_count(self):
+        """
+        Return GPU device count.
+        """
+        return gpu_get_device_count()
+
+    def get_device_capability(self, device_id):
+        """
+        Get GPU capability of the specified device id.
+        """
+        return gpu_get_device_capability(device_id)
+
+    def get_device_properties(self, device_id):
+        """
+        Get GPU properties of the specified device id.
+        """
+        return gpu_get_device_properties(device_id)
+
+    def get_device_name(self, device_id):
+        """
+        Get GPU name of the specified device id.
+        """
+        return gpu_get_device_name(device_id)
+
+    def get_arch_list(self):
+        """
+        Get the architecture list this MindSpore was compiled for.
+        """
+        return gpu_get_arch_list()

mindspore/hal/contiguous_tensors_handle.py

@@ -0,0 +1,175 @@
+# This is the Python alloc contiguous memory handle.
+#
+# 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.
+# ============================================================================
+"""Contiguous memory handle."""
+from mindspore.common.tensor import Tensor
+from mindspore.common.api import _convert_python_data
+from mindspore.common.dtype import type_size_in_bytes
+from mindspore._c_expression import slice_by_tensor_index, slice_by_padding_shape, \
+    combine_tensor_list_contiguous as combine_tensor_list, Tensor as Tensor_
+
+
+def combine_tensor_list_contiguous(tensor_list, enable_mem_align=True):
+    r"""
+    Return a contiguous memory handle where contiguous memory has been requested and slicing functionality is provided.
+
+    Args:
+        tensor_list (list[Tensor], Tuple[Tensor]): The tensor list to be stored.
+        enable_mem_align (bool, optional): Whether to enable the memory alignment function.
+            False is not supported. Default: ``True`` .
+
+    Returns:
+            ContiguousTensorsHandle, a manager with contiguous memory.
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor
+        >>> from mindspore.hal.contiguous_tensors_handle import combine_tensor_list_contiguous
+        >>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
+        >>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
+        >>> handle = combine_tensor_list_contiguous([x, y], True)
+        >>> print(handle[0].shape)
+        [1]
+        >>> print(handle[1: 3].asnumpy())
+        [2, 3]
+        >>> print(output.slice_by_tensor_index(0, 1).asnumpy())
+        [1, 2, 3]
+    """
+    return ContiguousTensorsHandle(tensor_list, enable_mem_align)
+
+
+class ContiguousTensorsHandle:
+    r"""
+    ContiguousTensorsHandle is a handle manage continuous memory.
+
+    Args:
+        tensor_list (list[Tensor], Tuple[Tensor]): The tensor list to be stored.
+        enable_mem_align (bool, optional): Whether to enable the memory alignment function.
+            False is not supported. Default: ``True`` .
+
+    Returns:
+        ContiguousTensorsHandle, a manager with contiguous memory.
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor
+        >>> from mindspore.hal.contiguous_tensors_handle import ContiguousTensorsHandle
+        >>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
+        >>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
+        >>> handle = ContiguousTensorsHandle([x, y], True)
+        >>> print(handle[0].shape)
+        [1]
+        >>> print(handle[1: 3].asnumpy())
+        [2, 3]
+    """
+
+    def __init__(self, tensor_list, enable_mem_align=True):
+        if isinstance(tensor_list, (list, tuple)):
+            for tensor in tensor_list:
+                if not isinstance(tensor, (Tensor, Tensor_)):
+                    raise TypeError(f"input list must be [Tensor, ...].")
+            if isinstance(tensor_list, list):
+                self.tensor_list = tuple(tensor_list)
+            else:
+                self.tensor_list = tensor_list
+        else:
+            raise TypeError(f"input list must be [Tensor, ...].")
+        if not isinstance(enable_mem_align, bool):
+            raise TypeError(f"enable_mem_align must be bool.")
+        padding_sizes_pair = combine_tensor_list(self.tensor_list, enable_mem_align)
+        self.before_padding_sizes = padding_sizes_pair[0]
+        self.after_padding_sizes = padding_sizes_pair[1]
+        self.total_padding_size = sum(self.after_padding_sizes)
+        self.handle_shape = self.total_padding_size / type_size_in_bytes(self.tensor_list[0].dtype)
+        self.enable_mem_align = enable_mem_align
+
+    def __getitem__(self, item):
+        """
+        item is sliced by shape
+        :param item:
+        :return: Tensor
+        """
+        start = 0
+        end = int(self.handle_shape)
+        if isinstance(item, slice):
+            if item.start is not None:
+                start = item.start
+            if item.stop is not None:
+                end = item.stop
+            if not isinstance(start, int) or not isinstance(end, int):
+                raise TypeError(f"slice input error.")
+            if start < 0 or end > self.handle_shape or start >= end:
+                raise ValueError(f"slice input error.")
+            return _convert_python_data(slice_by_padding_shape(self.tensor_list[0], start, end))
+        if not isinstance(item, int):
+            raise TypeError(f"slice input must be "
+                            f"1.index -> int."
+                            f"2.[start: end: step] -> [int: int: int].")
+        if item < 0 or item > self.handle_shape:
+            raise ValueError(f"slice input is out of tensor_list size.")
+        return _convert_python_data(slice_by_padding_shape(self.tensor_list[0], item, item + 1))
+
+    def __str__(self):
+        list_str = "Handle total size: " + str(self.total_padding_size) + "\n"
+        index = 0
+        for tensor in self.tensor_list:
+            list_str = list_str + "Tensor[" + str(index) + "]: " + str(tensor.asnumpy()) + "\n"
+            index += 1
+        return list_str
+
+    def slice_by_tensor_index(self, start=None, end=None):
+        """
+        Return the tensor which is sliced by tensor index.
+
+        Args:
+            start(int, None): Starting position. Default：``None``.
+            end(int, None): Deadline position. Default：``None``.
+
+        Returns:
+            Tensor，is sliced by tensor index.
+
+        Raises:
+            TypeError: If `start` or `end`, is neither an 'int' nor a 'none'.
+            ValueError: If values of `start` or `end` are negative, or out of the list range, or start >= end.
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> from mindspore.hal.contiguous_tensors_handle import ContiguousTensorsHandle
+            >>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
+            >>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
+            >>> handle = ContiguousTensorsHandle([x, y], True)
+            >>> print(output.slice_by_tensor_index(0, 1).asnumpy())
+            [1, 2, 3]
+        """
+        index_start = 0
+        index_end = len(self.tensor_list)
+        if start is not None:
+            index_start = start
+            if end is None:
+                index_end = index_start + 1
+        if end is not None:
+            index_end = end
+        if not isinstance(index_start, int) or not isinstance(index_end, int):
+            raise TypeError(f"slice input error.")
+
+        if index_start < 0 or index_end > len(self.tensor_list) or index_start >= index_end:
+            raise ValueError(f"slice input error.")
+        return _convert_python_data(slice_by_tensor_index(self.tensor_list, self.before_padding_sizes,
+                                                          self.after_padding_sizes, index_start, index_end))