mindspore 2.5.0__cp311-cp311-win_amd64.whl → 2.6.0__cp311-cp311-win_amd64.whl

mindspore/hal/event.py

@@ -24,41 +24,37 @@ function_event_status = {'Event': False, 'wait': False}
 
 class Event(Event_):
     r"""
-    Wrapper around a device event.
+    Wrapper around a device event, this api will be deprecated and removed in future versions, please use
+    the api :func:`mindspore.runtime.Event` instead.
 
     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.
 
-    Note:
-        - The api will be deprecated, please use the api :func:`mindspore.runtime.Event` instead.
-
     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``)
+        enable_timing (bool, optional): indicates if the event should measure time. Default ``False``.
+        blocking (bool, optional): if ``True``, `wait` will be blocking. Default ``False``.
 
     Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> start = ms.hal.Event(enable_timing=True)
-        >>> end = ms.hal.Event(enable_timing=True)
-        >>> s1 = ms.hal.Stream()
-        >>> s2 = ms.hal.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.hal.StreamCtx(s1):
-        ...     d = ops.matmul(a, b)
+        >>> import mindspore
+        >>> start = mindspore.hal.Event(enable_timing=True)
+        >>> end = mindspore.hal.Event(enable_timing=True)
+        >>> s1 = mindspore.hal.Stream()
+        >>> s2 = mindspore.hal.Stream()
+        >>> a = mindspore.tensor(mindspore.ops.ones([2, 2]), mindspore.float32)
+        >>> b = mindspore.tensor(mindspore.ops.ones([2, 2]), mindspore.float32)
+        >>> c = mindspore.tensor(mindspore.ops.ones([2, 2]), mindspore.float32)
+        >>> with mindspore.hal.StreamCtx(s1):
+        ...     d = mindspore.ops.matmul(a, b)
         ...     start.record()
         >>> c += 2
         >>> end.record()
-        >>> with ms.hal.StreamCtx(s2):
+        >>> with mindspore.hal.StreamCtx(s2):
         ...     start.synchronize()
         ...     end.synchronize()
         ...     e = c + d
-        >>> ms.hal.synchronize()
+        >>> mindspore.hal.synchronize()
         >>> print(e)
         [[5. 5.]
          [5. 5.]]
@@ -78,17 +74,14 @@ class Event(Event_):
 
     def record(self, stream=None):
         r"""
-        Records the event in a given stream.
+        Record the event in a given stream.
 
         Uses :func:`mindspore.hal.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.hal.Stream` nor a ``None``.
+                current stream will be used. Default ``None``.
         """
         if stream is None:
             stream = current_stream_()
@@ -99,33 +92,28 @@ class Event(Event_):
 
     def wait(self, stream=None):
         r"""
-        Makes all future work submitted to the given stream wait for this
+        Make all future work submitted to the given stream wait for this
         event.
 
         Use :func:`mindspore.hal.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.hal.Stream` nor a ``None``.
+                current stream will be used. Default ``None``.
 
         Examples:
-            >>> import mindspore as ms
-            >>> import numpy as np
-            >>> from mindspore import Tensor, ops
-            >>> event = ms.hal.Event()
-            >>> s1 = ms.hal.Stream()
-            >>> s2 = ms.hal.Stream()
-            >>> a = Tensor(np.ones([2, 2]), ms.float32)
-            >>> b = Tensor(np.ones([2, 2]), ms.float32)
-            >>> with ms.hal.StreamCtx(s1):
-            ...     c = ops.matmul(a, b)
+            >>> import mindspore
+            >>> event = mindspore.hal.Event()
+            >>> s1 = mindspore.hal.Stream()
+            >>> s2 = mindspore.hal.Stream()
+            >>> a = mindspore.tensor(mindspore.ops.ones([2, 2]), mindspore.float32)
+            >>> b = mindspore.tensor(mindspore.ops.ones([2, 2]), mindspore.float32)
+            >>> with mindspore.hal.StreamCtx(s1):
+            ...     c = mindspore.ops.matmul(a, b)
             ...     event.record()
             >>> event.wait()
             >>> d = c + 2
-            >>> ms.hal.synchronize()
+            >>> mindspore.hal.synchronize()
             >>> print(d)
             [[4. 4.]
              [4. 4.]]
@@ -144,7 +132,7 @@ class Event(Event_):
 
     def synchronize(self):
         r"""
-        Waits for the event to complete.
+        Wait 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.
@@ -154,20 +142,18 @@ class Event(Event_):
 
     def query(self):
         r"""
-        Checks if all work currently captured by event has completed.
+        Check if all work currently captured by event has completed.
 
         Returns:
             A boolean indicating if all work currently captured by event has completed.
 
         Examples:
-            >>> import mindspore as ms
-            >>> import numpy as np
-            >>> from mindspore import Tensor, ops
-            >>> a = Tensor(np.ones([1024, 2048]), ms.float32)
-            >>> b = Tensor(np.ones([2048, 4096]), ms.float32)
-            >>> s1 = ms.hal.Stream()
-            >>> with ms.hal.StreamCtx(s1):
-            ...     c = ops.matmul(a, b)
+            >>> import mindspore
+            >>> a = mindspore.tensor(mindspore.ops.ones([1024, 2048]), mindspore.float32)
+            >>> b = mindspore.tensor(mindspore.ops.ones([2048, 4096]), mindspore.float32)
+            >>> s1 = mindspore.hal.Stream()
+            >>> with mindspore.hal.StreamCtx(s1):
+            ...     c = mindspore.ops.matmul(a, b)
             ...     ev = s1.record_event()
             >>> s1.synchronize()
             >>> assert ev.query()
@@ -177,7 +163,7 @@ class Event(Event_):
 
     def elapsed_time(self, end_event):
         r"""
-        Returns the time elapsed in milliseconds after the event was
+        Return the time elapsed in milliseconds after the event was
         recorded and before the end_event was recorded.
 
         Args:
@@ -185,9 +171,6 @@ class Event(Event_):
 
         Returns:
             float, the time elapsed in milliseconds.
-
-        Raises:
-            TypeError: If 'end_event' is not a :class:`mindspore.hal.Event`.
         """
         # pylint: disable=useless-super-delegation
         if not isinstance(end_event, Event):

mindspore/hal/memory.py

@@ -14,43 +14,42 @@
 # ============================================================================
 
 """Hardware memory interfaces."""
-from mindspore._c_expression import _memory_stats, _reset_max_mem_reserved, _reset_max_mem_allocated
+from mindspore._c_expression import _memory_stats, _reset_max_mem_reserved, _reset_max_mem_allocated, _empty_cache, \
+    DeviceContextManager
 from mindspore import log as logger
+import mindspore as ms
 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}
+_device_context_mgr = DeviceContextManager.get_instance()
 
 
 @_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.
+    Returns status information queried from the memory pool, this api will be deprecated and removed in future
+    versions, 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.
+        - For the `CPU` device, a dictionary with empty data is always returned.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
-            Default value: ``None``.
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
         dict, the queried memory information.
 
     Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> a = Tensor(np.ones([1, 2]), ms.float32)
-        >>> b = Tensor(np.ones([1, 2]), ms.float32)
-        >>> c = ops.add(a, b).asnumpy()
-        >>> print(ms.hal.memory_stats())
+        >>> import mindspore
+        >>> a = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> b = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> c = mindspore.ops.add(a, b).asnumpy()
+        >>> print(mindspore.hal.memory_stats())
         {'total_reserved_memory': 1073741824, 'total_allocated_memory': 1024, 'total_idle_memory': 1073740800,
         'total_eager_free_memory': 0, 'max_reserved_memory': 1073741824, 'max_allocated_memory': 1536,
         'common_mem_pool_stats': {'block_unit_size': 1073741824, 'block_counts': 1, 'blocks_info':
@@ -72,30 +71,25 @@ def memory_stats(device_target=None):
 @_check_inputs_validation
 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.
+    Returns the total amount of memory currently managed by the memory pool, this api will be deprecated and removed in
+    future versions, 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.
+        - For the `CPU` device, 0 is always returned.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
-            Default value: ``None``.
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
         int, in Byte.
 
     Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> a = Tensor(np.ones([1, 2]), ms.float32)
-        >>> b = Tensor(np.ones([1, 2]), ms.float32)
-        >>> c = ops.add(a, b).asnumpy()
-        >>> print(ms.hal.memory_reserved())
+        >>> import mindspore
+        >>> a = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> b = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> c = mindspore.ops.add(a, b).asnumpy()
+        >>> print(mindspore.hal.memory_reserved())
         1073741824
     """
     if not function_memory_status['memory_reserved']:
@@ -111,29 +105,25 @@ def memory_reserved(device_target=None):
 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.
+    This api will be deprecated and removed in future versions, please use
+    the api :func:`mindspore.runtime.max_memory_reserved` instead.
 
     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.
+        - For the `CPU` device, 0 is always returned.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
-            Default value: ``None``.
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
         int, in Byte.
 
     Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> a = Tensor(np.ones([1, 2]), ms.float32)
-        >>> b = Tensor(np.ones([1, 2]), ms.float32)
-        >>> c = ops.add(a, b).asnumpy()
-        >>> print(ms.hal.max_memory_reserved())
+        >>> import mindspore
+        >>> a = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> b = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> c = mindspore.ops.add(a, b).asnumpy()
+        >>> print(mindspore.hal.max_memory_reserved())
         1073741824
     """
     if not function_memory_status['max_memory_reserved']:
@@ -145,54 +135,60 @@ def max_memory_reserved(device_target=None):
     return _memory_stats(device_target).get("max_reserved_memory", 0)
 
 
+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()
+
 @_check_inputs_validation
 def empty_cache():
     """
-    Release all memory fragments in the memory pool, so that memory arrangement
-    will be optimized.
+    Empty cache in the memory pool, this api will be deprecated and removed in future versions.
+    Please use the api :func:`mindspore.runtime.empty_cache` instead.
 
     Note:
-        - The api will be deprecated, please use the api :func:`mindspore.runtime.empty_cache` instead.
+        - Empty cache help reduce the fragmentation of device memory.
+        - Support Atlas A2 series products.
 
-    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.
+    Supported Platforms:
+        ``Ascend``
     """
     if not function_memory_status['empty_cache']:
         function_memory_status['empty_cache'] = True
-        logger.warning(f"The empty_cache operation is currently not supported.")
+    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_cache(device_target)
 
 
 @_check_inputs_validation
 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.
+    Reset the "peak" stats tracked by memory manager, this api will be deprecated and removed in future versions.
+    Please use the api :func:`mindspore.runtime.reset_peak_memory_stats` instead.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
-            Default value: ``None``.
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> a = Tensor(np.ones([1, 2]), ms.float32)
-        >>> b = Tensor(np.ones([1, 2]), ms.float32)
-        >>> c = ops.add(a, b).asnumpy()
-        >>> print(ms.hal.max_memory_reserved())
+        >>> import mindspore
+        >>> a = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> b = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> c = mindspore.ops.add(a, b).asnumpy()
+        >>> print(mindspore.hal.max_memory_reserved())
         1073741824
-        >>> print(ms.hal.max_memory_allocated())
+        >>> print(mindspore.hal.max_memory_allocated())
         1536
-        >>> ms.hal.reset_peak_memory_stats()
-        >>> print(ms.hal.max_memory_reserved())
+        >>> mindspore.hal.reset_peak_memory_stats()
+        >>> print(mindspore.hal.max_memory_reserved())
         0
-        >>> print(ms.hal.max_memory_allocated())
+        >>> print(mindspore.hal.max_memory_allocated())
         0
     """
     if not function_memory_status['reset_peak_memory_stats']:
@@ -208,17 +204,12 @@ def reset_peak_memory_stats(device_target=None):
 @_check_inputs_validation
 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.
+    Returns readable memory pool status information, this api will be deprecated and removed in future versions.
+    Please use the api :func:`mindspore.runtime.memory_summary` instead.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
-            Default value: ``None``.
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
         str, readable memory pool status information in tabular form.
@@ -270,30 +261,25 @@ def memory_summary(device_target=None):
 @_check_inputs_validation
 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.
+    Returns the actual memory size currently occupied by Tensor, this api will be deprecated and removed in future
+    versions, 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.
+        - For the `CPU` device, 0 is always returned.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
-            Default value: ``None``.
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
         int, in Byte.
 
     Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> a = Tensor(np.ones([1, 2]), ms.float32)
-        >>> b = Tensor(np.ones([1, 2]), ms.float32)
-        >>> c = ops.add(a, b).asnumpy()
-        >>> print(ms.hal.memory_allocated())
+        >>> import mindspore
+        >>> a = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> b = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> c = mindspore.ops.add(a, b).asnumpy()
+        >>> print(mindspore.hal.memory_allocated())
         1024
     """
     if not function_memory_status['memory_allocated']:
@@ -308,30 +294,26 @@ def memory_allocated(device_target=None):
 @_check_inputs_validation
 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.
+    Return the peak memory size of the memory pool actually occupied by Tensor since the process was started.
+    This api will be deprecated and removed in future versions, 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.
+        - For the `CPU` device, 0 is always returned.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
-            Default value: ``None``.
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Returns:
         int, in Byte.
 
     Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> a = Tensor(np.ones([1, 2]), ms.float32)
-        >>> b = Tensor(np.ones([1, 2]), ms.float32)
-        >>> c = ops.add(a, b).asnumpy()
-        >>> print(ms.hal.max_memory_allocated())
+        >>> import mindspore
+        >>> a = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> b = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> c = mindspore.ops.add(a, b).asnumpy()
+        >>> print(mindspore.hal.max_memory_allocated())
         1536
     """
     if not function_memory_status['max_memory_allocated']:
@@ -346,29 +328,22 @@ def max_memory_allocated(device_target=None):
 @_check_inputs_validation
 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.
+    Reset the peak memory size managed by the memory pool, this api will be deprecated and removed in future versions.
+    Please use the api :func:`mindspore.runtime.reset_max_memory_reserved` instead.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
-            Default value: ``None``.
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> a = Tensor(np.ones([1, 2]), ms.float32)
-        >>> b = Tensor(np.ones([1, 2]), ms.float32)
-        >>> c = ops.add(a, b).asnumpy()
-        >>> print(ms.hal.max_memory_reserved())
+        >>> import mindspore
+        >>> a = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> b = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> c = mindspore.ops.add(a, b).asnumpy()
+        >>> print(mindspore.hal.max_memory_reserved())
         1073741824
-        >>> ms.hal.reset_max_memory_reserved()
-        >>> print(ms.hal.max_memory_reserved())
+        >>> mindspore.hal.reset_max_memory_reserved()
+        >>> print(mindspore.hal.max_memory_reserved())
         0
     """
     if not function_memory_status['reset_max_memory_reserved']:
@@ -383,29 +358,22 @@ def reset_max_memory_reserved(device_target=None):
 @_check_inputs_validation
 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.
+    Reset the peak memory size of the memory pool actually occupied by Tensor, this api will be deprecated and removed
+    in future versions, please use the api :func:`mindspore.runtime.reset_max_memory_allocated` instead.
 
     Args:
-        device_target (str, optional): The device name of backend, should be one of "CPU", "GPU" and "Ascend".
-            Default value: ``None``.
+        device_target (str, optional): The target device specified, should be one of ``"CPU"`` , ``"GPU"`` and
+            ``"Ascend"`` . Default ``None`` , represents the current device set by context.
 
     Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> a = Tensor(np.ones([1, 2]), ms.float32)
-        >>> b = Tensor(np.ones([1, 2]), ms.float32)
-        >>> c = ops.add(a, b).asnumpy()
-        >>> print(ms.hal.max_memory_allocated())
+        >>> import mindspore
+        >>> a = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> b = mindspore.tensor(mindspore.ops.ones([1, 2]), mindspore.float32)
+        >>> c = mindspore.ops.add(a, b).asnumpy()
+        >>> print(mindspore.hal.max_memory_allocated())
         1536
-        >>> ms.hal.reset_max_memory_allocated()
-        >>> print(ms.hal.max_memory_allocated())
+        >>> mindspore.hal.reset_max_memory_allocated()
+        >>> print(mindspore.hal.max_memory_allocated())
         0
     """
     if not function_memory_status['reset_max_memory_allocated']: