mindspore 2.4.1__cp39-cp39-win_amd64.whl → 2.5.0__cp39-cp39-win_amd64.whl

mindspore/hal/memory.py

@@ -18,12 +18,20 @@ from mindspore._c_expression import _memory_stats, _reset_max_mem_reserved, _res
 from mindspore import log as logger
 from .device import _check_inputs_validation, is_initialized
 
+function_memory_status = {'memory_stats': False, 'memory_reserved': False, 'max_memory_reserved': False,
+                          'empty_cache': False, 'reset_peak_memory_stats': False, 'memory_summary': False,
+                          'memory_allocated': False, 'max_memory_allocated': False,
+                          'reset_max_memory_reserved': False, 'reset_max_memory_allocated': False}
+
 
 @_check_inputs_validation
 def memory_stats(device_target=None):
     """
     Returns status information queried from the memory pool.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.memory_stats` instead.
+
     Note:
         - If `device_target` is not specified, get the device capability of the current backend set by context.
         - For the `CPU` backend, a dictionary with empty data is always returned.
@@ -49,6 +57,12 @@ def memory_stats(device_target=None):
         {<capsule object NULL at 0x7f7e8c27b030>: {'block_stream_id': 0, 'block_memory_size': 1073741824}}},
         'persistent_mem_pool_stats': {'block_unit_size': 1073741824, 'block_counts': 0, 'blocks_info': {}}}
     """
+    if not function_memory_status['memory_stats']:
+        function_memory_status['memory_stats'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.memory_stats() is deprecated."
+            " Please use mindspore.runtime.memory_stats()"
+        )
     if not is_initialized(device_target):
         logger.warning(f"Backend {device_target} is not initialized yet. Return empty dict.")
         return {}
@@ -60,6 +74,9 @@ def memory_reserved(device_target=None):
     """
     Returns the total amount of memory currently managed by the memory pool.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.memory_reserved` instead.
+
     Note:
         - If `device_target` is not specified, get the device capability of the current backend set by context.
         - For the `CPU` backend, 0 is always returned.
@@ -81,6 +98,12 @@ def memory_reserved(device_target=None):
         >>> print(ms.hal.memory_reserved())
         1073741824
     """
+    if not function_memory_status['memory_reserved']:
+        function_memory_status['memory_reserved'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.memory_reserved() is deprecated."
+            " Please use mindspore.runtime.memory_reserved()"
+        )
     return _memory_stats(device_target).get("total_reserved_memory", 0)
 
 
@@ -89,6 +112,9 @@ def max_memory_reserved(device_target=None):
     """
     Returns the peak value of the total memory managed by the memory pool since the process was started.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.max_memory_reserved` instead.
+
     Note:
         - If `device_target` is not specified, get the device capability of the current backend set by context.
         - For the `CPU` backend, 0 is always returned.
@@ -110,6 +136,12 @@ def max_memory_reserved(device_target=None):
         >>> print(ms.hal.max_memory_reserved())
         1073741824
     """
+    if not function_memory_status['max_memory_reserved']:
+        function_memory_status['max_memory_reserved'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.max_memory_reserved() is deprecated."
+            " Please use mindspore.runtime.max_memory_reserved()"
+        )
     return _memory_stats(device_target).get("max_reserved_memory", 0)
 
 
@@ -119,11 +151,16 @@ def empty_cache():
     Release all memory fragments in the memory pool, so that memory arrangement
     will be optimized.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.empty_cache` instead.
+
     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.
     """
-    logger.warning(f"The empty_cache operation is currently not supported.")
+    if not function_memory_status['empty_cache']:
+        function_memory_status['empty_cache'] = True
+        logger.warning(f"The empty_cache operation is currently not supported.")
 
 
 @_check_inputs_validation
@@ -131,6 +168,9 @@ def reset_peak_memory_stats(device_target=None):
     """
     Reset the "peak" stats tracked by memory manager.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.reset_peak_memory_stats` instead.
+
     Note:
         If `device_target` is not specified, get the device capability of the current backend set by context.
 
@@ -155,6 +195,12 @@ def reset_peak_memory_stats(device_target=None):
         >>> print(ms.hal.max_memory_allocated())
         0
     """
+    if not function_memory_status['reset_peak_memory_stats']:
+        function_memory_status['reset_peak_memory_stats'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.reset_peak_memory_stats() is deprecated."
+            " Please use mindspore.runtime.reset_peak_memory_stats()"
+        )
     _reset_max_mem_reserved(device_target)
     _reset_max_mem_allocated(device_target)
 
@@ -164,6 +210,9 @@ def memory_summary(device_target=None):
     """
     Returns readable memory pool status information.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.memory_summary` instead.
+
     Note:
         If `device_target` is not specified, get the device capability of the current backend set by context.
 
@@ -174,6 +223,12 @@ def memory_summary(device_target=None):
     Returns:
         str, readable memory pool status information in tabular form.
     """
+    if not function_memory_status['memory_summary']:
+        function_memory_status['memory_summary'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.memory_summary() is deprecated."
+            " Please use mindspore.runtime.memory_summary()"
+        )
     stats = _memory_stats(device_target)
 
     def _format_size(sz, pref_sz):
@@ -189,7 +244,7 @@ def memory_summary(device_target=None):
 
     metrics_to_display = [
         ("total_reserved_memory", "Reserved memory", _format_size),
-        ("total_allocatd_memory", "Allocated memory", _format_size),
+        ("total_allocated_memory", "Allocated memory", _format_size),
         ("total_idle_memory", "Idle memory", _format_size),
         ("total_eager_free_memory", "Eager free memory", _format_size),
         ("max_reserved_memory", "Max reserved memory", _format_size),
@@ -217,6 +272,9 @@ def memory_allocated(device_target=None):
     """
     Returns the actual memory size currently occupied by Tensor.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.memory_allocated` instead.
+
     Note:
         - If `device_target` is not specified, get the device capability of the current backend set by context.
         - For the `CPU` backend, 0 is always returned.
@@ -238,7 +296,13 @@ def memory_allocated(device_target=None):
         >>> print(ms.hal.memory_allocated())
         1024
     """
-    return _memory_stats(device_target).get("total_allocatd_memory", 0)
+    if not function_memory_status['memory_allocated']:
+        function_memory_status['memory_allocated'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.memory_allocated() is deprecated."
+            " Please use mindspore.runtime.memory_allocated()"
+        )
+    return _memory_stats(device_target).get("total_allocated_memory", 0)
 
 
 @_check_inputs_validation
@@ -246,6 +310,9 @@ def max_memory_allocated(device_target=None):
     """
     Returns the peak memory size of the memory pool actually occupied by Tensor since the process was started.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.max_memory_allocated` instead.
+
     Note:
         - If `device_target` is not specified, get the device capability of the current backend set by context.
         - For the `CPU` backend, 0 is always returned.
@@ -267,6 +334,12 @@ def max_memory_allocated(device_target=None):
         >>> print(ms.hal.max_memory_allocated())
         1536
     """
+    if not function_memory_status['max_memory_allocated']:
+        function_memory_status['max_memory_allocated'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.max_memory_allocated() is deprecated."
+            " Please use mindspore.runtime.max_memory_allocated()"
+        )
     return _memory_stats(device_target).get("max_allocated_memory", 0)
 
 
@@ -275,6 +348,9 @@ def reset_max_memory_reserved(device_target=None):
     """
     Reset the peak memory size managed by the memory pool.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.reset_max_memory_reserved` instead.
+
     Note:
         If `device_target` is not specified, get the device capability of the current backend set by context.
 
@@ -295,6 +371,12 @@ def reset_max_memory_reserved(device_target=None):
         >>> print(ms.hal.max_memory_reserved())
         0
     """
+    if not function_memory_status['reset_max_memory_reserved']:
+        function_memory_status['reset_max_memory_reserved'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.reset_max_memory_reserved() is deprecated."
+            " Please use mindspore.runtime.reset_max_memory_reserved()"
+        )
     _reset_max_mem_reserved(device_target)
 
 
@@ -303,6 +385,9 @@ def reset_max_memory_allocated(device_target=None):
     """
     Reset the peak memory size of the memory pool actually occupied by Tensor.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.reset_max_memory_allocated` instead.
+
     Note:
         If `device_target` is not specified, get the device capability of the current backend set by context.
 
@@ -323,4 +408,10 @@ def reset_max_memory_allocated(device_target=None):
         >>> print(ms.hal.max_memory_allocated())
         0
     """
+    if not function_memory_status['reset_max_memory_allocated']:
+        function_memory_status['reset_max_memory_allocated'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.reset_max_memory_allocated() is deprecated."
+            " Please use mindspore.runtime.reset_max_memory_allocated()"
+        )
     _reset_max_mem_allocated(device_target)

mindspore/hal/stream.py

@@ -21,8 +21,13 @@ from mindspore._c_expression import default_stream as default_stream_
 from mindspore._c_expression import communication_stream as communication_stream_
 
 from mindspore import _checkparam as Validator
+from mindspore import log as logger
 from .event import Event
 
+function_stream_status = {'record_event': False, 'wait_event': False, 'wait_stream': False,
+                          'query': False, 'synchronize': False, 'set_cur_stream': False,
+                          'current_stream': False, 'default_stream': False,
+                          'communication_stream': False, 'StreamCtx': False}
 
 class Stream(Stream_):
     r"""
@@ -31,13 +36,15 @@ class Stream(Stream_):
     A device stream is a linear sequence of execution that belongs to a specific device,
     independent from other streams.
 
-    For a quick start of using Stream, please refer to `Illustration of stream management <https://www.mindspore.cn/docs/en/master/api_python/samples/hal/stream_manager.html>`_ .
+    Note:
+        - The api will be deprecated, please use the api :class:`mindspore.runtime.Stream`.
 
     Args:
         priority (int, optional): priority of the stream, lower numbers represent higher priorities.
             By default, streams have priority ``0``.
         kwargs (dict): keyword arguments.
     """
+
     def __init__(self, priority=0, **kwargs):
         self.init_finished = False
         if 'stream' in kwargs and kwargs['stream'] is not None:
@@ -84,6 +91,12 @@ class Stream(Stream_):
              [5. 5. 5.]
              [5. 5. 5.]]
         """
+        if not function_stream_status['record_event']:
+            function_stream_status['record_event'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.Stream().record_event() is deprecated."
+                " Please use mindspore.runtime.Stream().record_event()"
+            )
         if event is None:
             event = Event()
         if not isinstance(event, Event):
@@ -121,6 +134,12 @@ class Stream(Stream_):
              [5. 5. 5.]
              [5. 5. 5.]]
         """
+        if not function_stream_status['wait_event']:
+            function_stream_status['wait_event'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.current_stream().wait_event(event) is deprecated."
+                " Please use mindspore.runtime.current_stream().wait_event(event)"
+            )
         if not isinstance(event, Event):
             raise TypeError(f"For 'wait_event', the argument 'event' should be Event,"
                             f" but got {type(event)}.")
@@ -156,6 +175,12 @@ class Stream(Stream_):
             >>> print(d)
             [[4. 4.]]
         """
+        if not function_stream_status['wait_stream']:
+            function_stream_status['wait_stream'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.Stream() is deprecated."
+                " Please use mindspore.runtime.Stream()"
+            )
         if not isinstance(stream, Stream):
             raise TypeError(f"For 'wait_stream', the argument 'stream' should be Stream,"
                             f" but got {type(stream)}.")
@@ -199,6 +224,12 @@ class Stream(Stream_):
             >>> s1.synchronize()
             >>> assert s1.query()
         """
+        if not function_stream_status['query']:
+            function_stream_status['query'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.Stream() is deprecated."
+                " Please use mindspore.runtime.Stream()"
+            )
         # pylint: disable=useless-super-delegation
         return super().query()
 
@@ -221,6 +252,9 @@ def synchronize():
     r"""
     Synchronize all streams on current device.(Each MindSpore process only occupies one device)
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.synchronize` instead.
+
     Examples:
         >>> import mindspore as ms
         >>> import numpy as np
@@ -233,6 +267,12 @@ def synchronize():
         >>> ms.hal.synchronize()
         >>> assert s1.query()
     """
+    if not function_stream_status['synchronize']:
+        function_stream_status['synchronize'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.synchronize() is deprecated."
+            " Please use mindspore.runtime.synchronize()"
+        )
     synchronize_()
 
 
@@ -241,6 +281,9 @@ def set_cur_stream(stream):
     Sets the current stream.This is a wrapper API to set the stream.
     Usage of this function is discouraged in favor of the ``stream`` context manager.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.set_cur_stream` instead.
+
     Args:
         stream (Stream): selected stream. This function is a no-op
             if this argument is ``None``.
@@ -257,6 +300,12 @@ def set_cur_stream(stream):
         >>> assert ms.hal.current_stream() == s1
         >>> ms.hal.set_cur_stream(ms.hal.default_stream())
     """
+    if not function_stream_status['set_cur_stream']:
+        function_stream_status['set_cur_stream'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.Stream() is deprecated."
+            " Please use mindspore.runtime.Stream()"
+        )
     if stream is None:
         return
     if not isinstance(stream, Stream):
@@ -269,6 +318,9 @@ def current_stream():
     r"""
     Return current stream used on this device.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.current_stream` instead.
+
     Returns:
         stream (Stream), current stream.
 
@@ -277,6 +329,12 @@ def current_stream():
         >>> cur_stream = ms.hal.current_stream()
         >>> assert cur_stream == ms.hal.default_stream()
     """
+    if not function_stream_status['current_stream']:
+        function_stream_status['current_stream'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.current_stream() is deprecated."
+            " Please use mindspore.runtime.current_stream()"
+        )
     return Stream(stream=current_stream_())
 
 
@@ -284,6 +342,9 @@ def default_stream():
     r"""
     Return default stream on this device.
 
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.default_stream` instead.
+
     Returns:
         stream (Stream), default stream.
 
@@ -292,22 +353,36 @@ def default_stream():
         >>> cur_stream = ms.hal.current_stream()
         >>> assert cur_stream == ms.hal.default_stream()
     """
+    if not function_stream_status['default_stream']:
+        function_stream_status['default_stream'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.default_stream() is deprecated."
+            " Please use mindspore.runtime.default_stream()"
+        )
     return Stream(stream=default_stream_())
 
 
 def communication_stream():
     r"""
-    Return default stream on this device.
+    Return communication stream on this device.
+
+    Note:
+        - The api will be deprecated, please use the api :func:`mindspore.runtime.communication_stream` instead.
 
     Returns:
-        stream (Stream), default stream.
+        stream (Stream), communication stream.
 
-    TODO
     Examples:
         >>> import mindspore as ms
-        >>> cur_stream = ms.hal.current_stream()
-        >>> assert cur_stream == ms.hal.default_stream()
+        >>> ms.hal.communication_stream()
+        Stream(device_name=Ascend, device_id:0, stream id:1)
     """
+    if not function_stream_status['communication_stream']:
+        function_stream_status['communication_stream'] = True
+        logger.warning(
+            "WARN_DEPRECATED: The usage of mindspore.hal.communication_stream() is deprecated."
+            " Please use mindspore.runtime.communication_stream()"
+        )
     return Stream(stream=communication_stream_())
 
 
@@ -315,6 +390,9 @@ class StreamCtx():
     r"""
     Context-manager that selects a given stream.
 
+    Note:
+        - The api will be deprecated, please use the api :class:`mindspore.runtime.StreamCtx`.
+
     All kernels queued within its context will be enqueued on a selected
     stream.
 
@@ -336,7 +414,14 @@ class StreamCtx():
         >>> ms.hal.synchronize()
         >>> assert s1.query()
     """
+
     def __init__(self, ctx_stream):
+        if not function_stream_status['StreamCtx']:
+            function_stream_status['StreamCtx'] = True
+            logger.warning(
+                "WARN_DEPRECATED: The usage of mindspore.hal.StreamCtx(s1) is deprecated."
+                " Please use mindspore.runtime.StreamCtx(s1)"
+            )
         if ctx_stream is not None and not isinstance(ctx_stream, Stream):
             raise TypeError(f"For 'StreamCtx', the argument 'ctx_stream' should be Stream,"
                             f" but got {type(ctx_stream)}.")

mindspore/include/api/context.h

@@ -27,7 +27,6 @@ namespace mindspore {
 enum DelegateMode {
   kNoDelegate = 0,
   kCoreML = 1,
-  kNNAPI = 2,
 };
 
 enum DeviceType {
@@ -236,7 +235,7 @@ std::string DeviceInfoContext::GetProviderDevice() const { return CharToString(G
 void DeviceInfoContext::SetProviderDevice(const std::string &device) { SetProviderDevice(StringToChar(device)); }
 
 /// \brief Derived from DeviceInfoContext, The configuration of the model running auto on the Host Devices, include
-/// CPU/GPU/NPU/Ascend310/Ascend910. This option is only valid for MindSpore Lite.
+/// CPU/GPU/NPU/Ascend. This option is only valid for MindSpore Lite.
 class MS_API AutoDeviceInfo : public DeviceInfoContext {
  public:
   /// \brief Get the type of this DeviceInfoContext.

mindspore/include/dataset/constants.h

@@ -108,8 +108,8 @@ enum class DATASET_API ManualOffloadMode {
 enum class DATASET_API MapTargetDevice {
   kCpu = 0,     ///< CPU Device.
   kGpu,         ///< Gpu Device.
-  kAscend310,   ///< Ascend310 Device.
-  kAscend910B,  ///< Ascend910B Device.
+  kAscend310,   ///<
+  kAscend910B,  ///<
   kInvalid = 100
 };
 

mindspore/log.py

@@ -26,6 +26,7 @@ from logging.handlers import RotatingFileHandler
 import traceback
 import threading
 import platform
+from datetime import datetime
 
 if platform.system() != "Windows":
     import fcntl
@@ -225,6 +226,17 @@ def critical(msg, *args, **kwargs):
     _get_logger().critical(msg, *args, **kwargs)
 
 
+def vlog_print(level, module, file, line, message):
+    '''Read environment variable VLOG_v and print to log'''
+    if os.environ.get("VLOG_v") == level:
+        now = datetime.now()
+        formatted_time = now.strftime("%Y-%m-%d-%H:%M:%S.%f")[:-3] + f".{now.microsecond // 1000}"
+        path = 'mindspore' + file.split("mindspore")[-1]
+        pid = os.getpid()
+        thread_id = threading.get_ident()
+        print(f"[V{level}] {module}({pid},{thread_id},python):{formatted_time} [{path}:{line}] {message}", flush=True)
+
+
 def get_level():
     """
     Get the logger level.

mindspore/mindrecord/__init__.py

@@ -39,5 +39,5 @@ from .config import *
 
 __all__ = ['FileWriter', 'FileReader', 'MindPage',
            'Cifar10ToMR', 'Cifar100ToMR', 'CsvToMR', 'ImageNetToMR', 'MnistToMR', 'TFRecordToMR',
-           'set_enc_key', 'set_enc_mode', 'set_dec_mode', 'set_hash_mode',
+           'set_enc_key', 'set_enc_mode', 'set_dec_mode',
            'SUCCESS', 'FAILED']