mindspore 2.5.0__cp311-cp311-win_amd64.whl → 2.6.0rc1__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

@@ -27,30 +27,25 @@ function_memory_status = {'memory_stats': False, 'memory_reserved': False, 'max_
 @_check_inputs_validation
 def memory_stats(device_target=None):
     """
-    Returns status information queried from the memory pool.
+    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:
-        - 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.
+        - 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 +67,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 +101,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']:
@@ -149,14 +135,12 @@ def max_memory_reserved(device_target=None):
 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.
+    will be optimized, this api will be deprecated and removed in future versions, 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.
+        This interface is reserved but implemented as an empty method and prompted in log mode when using.
     """
     if not function_memory_status['empty_cache']:
         function_memory_status['empty_cache'] = True
@@ -166,33 +150,26 @@ def empty_cache():
 @_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 +185,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 +242,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 +275,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.
+    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:
-        - 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.
+        - 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 +309,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 +339,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']: