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

mindspore/profiler/profiler.py

@@ -15,18 +15,19 @@
 """Profiling api file."""
 import os
 import json
-from typing import Optional, Dict, Callable, Any
+import warnings
+from typing import Optional, Dict, Callable, Any, Iterable
 from sys import getsizeof
 from concurrent.futures import ProcessPoolExecutor, as_completed
 
 from mindspore import log as logger
-from mindspore.profiler.common.constant import ProfilerStepNameConstant, DeviceTarget
+from mindspore.profiler.common.constant import ProfilerStepNameConstant, DeviceTarget, ProfilerActivity
 from mindspore.profiler.common.profiler_context import ProfilerContext
 from mindspore.profiler.platform.npu_profiler import NPUProfilerAnalysis
 from mindspore.profiler.profiler_action_controller import ProfilerActionController
 from mindspore.profiler.experimental_config import _ExperimentalConfig
 from mindspore.profiler.profiler_interface import ProfilerInterface
-from mindspore.profiler.schedule import _default_schedule_fn, ProfilerAction, Schedule
+from mindspore.profiler.schedule import _default_schedule_fn, ProfilerAction
 from mindspore.profiler.common.record_function import RecordFunction
 from mindspore.profiler.common.path_manager import PathManager
 from mindspore.profiler.common.profiler_path_manager import ProfilerPathManager
@@ -91,8 +92,8 @@ def tensorboard_trace_handler(dir_name: str = None, worker_name: str = None,
         ...     net = Net()
         ...     # Note that the Profiler should be initialized before model.train
         ...     with mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
-        ...                                     schedule=mindspore.profiler.schedule(wait=1, warmup=1, active=2,
-        ...                                           repeat=1, skip_first=2),
+        ...                                     schedule=mindspore.profiler.schedule(wait=0, warmup=0, active=1,
+        ...                                           repeat=1, skip_first=0),
         ...                                     on_trace_ready=mindspore.profiler.tensorboard_trace_handler("./data"),
         ...                                     profile_memory=False,
         ...                                     experimental_config=experimental_config) as prof:
@@ -110,9 +111,9 @@ def tensorboard_trace_handler(dir_name: str = None, worker_name: str = None,
         logger.warning("async_mode is not bool, set by default.")
         async_mode = False
 
-    def handler_fn() -> None:
+    def handler_fn(prof_inst) -> None:
         if analyse_flag:
-            NPUProfilerAnalysis.online_analyse(async_mode=async_mode)
+            prof_inst.analyse(async_mode=async_mode)
 
     return handler_fn
 
@@ -156,8 +157,8 @@ class Profiler:
             For details, see :func:`mindspore.profiler.tensorboard_trace_handler` .
         profile_memory (bool, optional): (Ascend only) Whether to collect tensor memory data, collect when ``True`` .
             When using this parameter, `activities` must set to ``[ProfilerActivity.CPU, ProfilerActivity.NPU]``.
-            Collecting operator memory data when the graph compilation level is O2 requires collecting from the
-            first step. Default: ``False`` . The operator name currently collected by this parameter is incomplete.
+            Collecting operator memory data when GE backend requires collecting from the first step.
+            Default: ``False`` . The operator name currently collected by this parameter is incomplete.
             This issue will be resolved in later versions. It is recommended to use the environment variable
             ``MS_ALLOC_CONF`` instead.
         aic_metrics (AicoreMetrics, optional): (Ascend only) Types of AICORE performance data collected,
@@ -192,7 +193,7 @@ class Profiler:
             If set to True, only the profiler deliverables and raw performance data under the PROF_XXX directory are
             kept to save space. Default value: ``True`` .
         l2_cache (bool, optional): (Ascend only) Whether to collect l2 cache data, collect when True.
-            Default: ``False`` . The l2_cache.csv file is generated in the ASCEND_PROFILER_OUTPUT folder.In O2 mode,
+            Default: ``False`` . The l2_cache.csv file is generated in the ASCEND_PROFILER_OUTPUT folder.In GE backend,
             only wait and skip_first parameters in schedule configuration can be set to 0.
         hbm_ddr (bool, optional): (Ascend only) Whether to collect On-Chip Memory/DDR read and write rate data,
             collect when True. Default: ``False`` .
@@ -260,9 +261,10 @@ class Profiler:
         ...     # Profiler end
         ...     profiler.analyse()
     """
-    MAX_META_SIZE = 100 * 1024 * 1024  # 100MB
 
     def __init__(self, **kwargs) -> None:
+        logger.warning("'mindspore.Profiler' will be deprecated and removed in a future version. Please use the api "
+                       "'mindspore.profiler.profile' instead.")
         self._metadata: Dict[str, str] = {}
         self._prof_context: ProfilerContext = ProfilerContext()
         self._prof_context.set_params(**kwargs)
@@ -492,8 +494,7 @@ class Profiler:
             >>> import mindspore as ms
             >>> import mindspore.dataset as ds
             >>> from mindspore import context, nn, Profiler
-            >>> from mindspore.profiler import schedule, tensorboard_trace_handler, ProfilerLevel, AicoreMetrics,
-            >>> ExportType, ProfilerActivity
+            >>> from mindspore.profiler import schedule, tensorboard_trace_handler
             >>>
             >>> class Net(nn.Cell):
             ...     def __init__(self):
@@ -564,7 +565,7 @@ class Profiler:
             return
 
         add_size = getsizeof(key) + getsizeof(value)
-        if getsizeof(self._metadata) + add_size < self.MAX_META_SIZE:
+        if getsizeof(self._metadata) + add_size < ProfilerMetaData.MAX_META_SIZE:
             if key in self._metadata:
                 logger.warning(f"{key} is already saved as metadata, override it.")
             self._metadata[key] = value
@@ -595,7 +596,7 @@ class Profiler:
             return
 
         add_size = getsizeof(key) + getsizeof(value)
-        if getsizeof(self._metadata) + add_size < self.MAX_META_SIZE:
+        if getsizeof(self._metadata) + add_size < ProfilerMetaData.MAX_META_SIZE:
             try:
                 if key in self._metadata:
                     logger.warning(f"{key} is already saved as metadata, override it.")
@@ -646,6 +647,9 @@ class Profiler:
             >>>
             >>> profiler.op_analyse(op_name=["BiasAdd", "Conv2D"])
         """
+        warnings.warn(
+            "mindspore.Profiler.op_analyse is deprecated and will be removed in future versions.  "
+        )
         if self._prof_context.device_target == DeviceTarget.NPU.value:
             raise RuntimeError("The Interface 'Profiler.op_analyse()' is not supported on Ascend currently.")
 
@@ -659,9 +663,9 @@ class Profiler:
         if not op_name:
             raise TypeError(f"For 'Profiler.op_analyse()', the parameter op_name cannot be "", '' or [].")
 
-        from mindspore.profiler.parser.framework_parser import GpuFrameWorkParser
+        from mindspore.profiler.common.profiler_op_analyse import OpAnalyser
         dev_id = self._prof_context.device_id if device_id is None else device_id
-        parser = GpuFrameWorkParser(self._prof_context.framework_path, dev_id, op_name)
+        parser = OpAnalyser(self._prof_context.framework_path, dev_id, op_name)
         op_info = parser.parse()
         return op_info
 
@@ -685,44 +689,40 @@ class Profile:
     This class to enable the profiling of MindSpore neural networks.
     MindSpore users can import the mindspore.profiler.profile, initialize the profile object to start profiling,
     Use profile.start() to start the analysis, and use profile.stop() to stop collecting and analyzing the results.
+    For detailed usage, please refer to `Ascend Performance Tuning
+    <https://www.mindspore.cn/tutorials/en/master/debug/profiler.html>`_ .
     Users can visualize the results using the `MindStudio Insight
     <https://www.hiascend.com/developer/download/community/result?module=pt+sto+cann>`_ tool.
     Now, profile supports AICORE operator, AICPU operator, HostCPU operator, memory,
     correspondence, cluster, etc data analysis.
 
     Args:
-        start_profile (bool, optional): The start_profile parameter controls whether to enable or disable performance
-            data collection based on conditions. Default: ``True`` .
-        activities (list, optional): The activities to collect.
+        activities (Iterable, optional): The activities to collect.
             Default: ``[ProfilerActivity.CPU, ProfilerActivity.NPU]``.
 
             - ProfilerActivity.CPU: Collect MindSpore framework data.
             - ProfilerActivity.NPU: Collect CANN software stack and NPU data.
             - ProfilerActivity.GPU: Collect GPU data.
-        schedule (schedule, optional): Sets the action strategy for the capture, defined by the schedule class,
-            to be used with the step interface. Default: ``None``. Performance data of all steps is collected.
-            For details, see :class:`mindspore.profiler.schedule` .
-        on_trace_ready (Callable, optional): Sets the callback function to be executed when the performance data
-            is collected. Default: ``None``. It indicates that only performance data is collected, but not resolved.
-            For details, see :func:`mindspore.profiler.tensorboard_trace_handler` .
-        profile_memory (bool, optional): (Ascend only) Whether to collect tensor memory data, collect when ``True`` .
-            When using this parameter, `activities` must set to ``[ProfilerActivity.CPU, ProfilerActivity.NPU]``.
-            Collecting operator memory data when the graph compilation level is O2 requires collecting from the
-            first step. Default: ``False`` . The operator name currently collected by this parameter is incomplete.
-            This issue will be resolved in later versions. It is recommended to use the environment variable
-            ``MS_ALLOC_CONF`` instead.
         with_stack (bool, optional): (Ascend only) Whether to collect frame host call stack data
             on the Python side. This
             data is presented in the form of a flame graph in the timeline. When using this parameter, `activities` must
             include ``ProfilerActivity.CPU``. Default value: ``False`` .
-        hbm_ddr (bool, optional): (Ascend only) Whether to collect On-Chip Memory/DDR read and write rate data,
-            collect when True. Default: ``False`` .
-        pcie (bool, optional): (Ascend only) Whether to collect PCIe bandwidth data, collect when True.
-            Default: ``False`` .
+        profile_memory (bool, optional): (Ascend only) Whether to collect tensor memory data, collect when ``True`` .
+            When using this parameter, `activities` must set to ``[ProfilerActivity.CPU, ProfilerActivity.NPU]``.
+            Collecting operator memory data when GE backend requires collecting from the first step.
+            Default: ``False`` . The operator name currently collected by this parameter is incomplete.
+            This issue will be resolved in later versions. It is recommended to use the environment variable
+            ``MS_ALLOC_CONF`` instead.
         data_process (bool, optional): (Ascend/GPU) Whether to collect data to prepare performance data.
             Default value: ``False`` .
         parallel_strategy (bool, optional): (Ascend only) Whether to collect parallel policy performance data.
             Default value: ``False`` .
+        start_profile (bool, optional): The start_profile parameter controls whether to enable or disable performance
+            data collection based on conditions. Default: ``True`` .
+        hbm_ddr (bool, optional): (Ascend only) Whether to collect On-Chip Memory/DDR read and write rate data,
+            collect when True. Default: ``False`` .
+        pcie (bool, optional): (Ascend only) Whether to collect PCIe bandwidth data, collect when True.
+            Default: ``False`` .
         sync_enable (bool, optional): (GPU only) Whether the profiler collects operators in a synchronous way.
             Default: ``True`` .
 
@@ -731,6 +731,15 @@ class Profile:
               The duration of the operator is the difference between the two timestamps.
             - False: The asynchronous way. The duration of the operator is that of sending from the CPU to the GPU.
               This method can reduce the impact of adding profiler on overall training time.
+        record_shapes (bool, optional): (Ascend only) Whether to collect operator input tensor shapes data, collect
+            when ``True`` . When using this parameter, `activities` must include ``ProfilerActivity.CPU``.
+            Default: ``False``.
+        schedule (Callable, optional): Sets the action strategy for the capture, defined by the schedule class,
+            to be used with the step interface. Default: ``None``. Performance data of all steps is collected.
+            For details, see :class:`mindspore.profiler.schedule` .
+        on_trace_ready (Callable, optional): Sets the callback function to be executed when the performance data
+            is collected. Default: ``None``. It indicates that only performance data is collected, but not resolved.
+            For details, see :func:`mindspore.profiler.tensorboard_trace_handler` .
         experimental_config (_ExperimentalConfig, optional): expandable parameters can be configured in this
               configuration item. For details, see :class:`mindspore.profiler._ExperimentalConfig` .
     Raises:
@@ -782,8 +791,8 @@ class Profile:
         ...     net = Net()
         ...     # Note that the Profiler should be initialized before model.train
         ...     with mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
-        ...                                     schedule=mindspore.profiler.schedule(wait=1, warmup=1, active=2,
-        ...                                           repeat=1, skip_first=2),
+        ...                                     schedule=mindspore.profiler.schedule(wait=0, warmup=0, active=1,
+        ...                                           repeat=1, skip_first=0),
         ...                                     on_trace_ready=mindspore.profiler.
         ...                                           tensorboard_trace_handler("./data"),
         ...                                     profile_memory=False,
@@ -795,62 +804,54 @@ class Profile:
         ...             prof.step()
     """
 
-    def __init__(
-            self,
-            activities: list = None,
-            with_stack: bool = False,
-            profile_memory: bool = False,
-            data_process: bool = False,
-            parallel_strategy: bool = False,
-            start_profile: bool = True,
-            hbm_ddr: bool = False,
-            pcie: bool = False,
-            sync_enable: bool = True,
-            schedule: Schedule = None,
-            on_trace_ready: Optional[Callable[..., Any]] = None,
-            experimental_config: Optional[_ExperimentalConfig] = None,
-    ):
-        self._activities = activities
-        self._with_stack = with_stack
-        self._profile_memory = profile_memory
-        self._data_process = data_process
-        self._parallel_strategy = parallel_strategy
-        self._start_profile = start_profile
-        self._hbm_ddr = hbm_ddr
-        self._pcie = pcie
-        self._sync_enable = sync_enable
-        self._schedule = schedule
-        self._on_trace_ready = on_trace_ready
-        self._experimental_config = experimental_config or _ExperimentalConfig()
-        self._profiler = Profiler(
-            profiler_level=self._experimental_config.profiler_level,
-            activities=self._activities,
-            aic_metrics=self._experimental_config.aic_metrics,
-            with_stack=self._with_stack,
-            profile_memory=self._profile_memory,
-            data_process=self._data_process,
-            parallel_strategy=self._parallel_strategy,
-            start_profile=self._start_profile,
-            l2_cache=self._experimental_config.l2_cache,
-            hbm_ddr=self._hbm_ddr,
-            pcie=self._pcie,
-            sync_enable=self._sync_enable,
-            data_simplification=self._experimental_config.data_simplification,
-            mstx=self._experimental_config.mstx,
-            export_type=self._experimental_config.export_type,
-            schedule=self._schedule,
-            on_trace_ready=self._on_trace_ready,
-        )
-
-    def __enter__(self) -> 'Profile':
-        self._profiler.__enter__()
-        return self
-
-    def __exit__(self, exe_type, exe_val, exc_tb):
-        self._profiler.__exit__(exe_type, exe_val, exc_tb)
-
-    def __del__(self):
-        self._profiler.__del__()
+    def __init__(self,
+                 activities: Optional[Iterable[ProfilerActivity]] = None,
+                 with_stack: bool = False,
+                 profile_memory: bool = False,
+                 data_process: bool = False,
+                 parallel_strategy: bool = False,
+                 start_profile: bool = True,
+                 hbm_ddr: bool = False,
+                 pcie: bool = False,
+                 sync_enable: bool = True,
+                 record_shapes: bool = False,
+                 schedule: Optional[Callable[[int], ProfilerAction]] = None,
+                 on_trace_ready: Optional[Callable[..., Any]] = None,
+                 experimental_config: Optional[_ExperimentalConfig] = None):
+        self._metadata: Dict[str, str] = {}
+        self._prof_context: ProfilerContext = ProfilerContext()
+        kwargs = {
+            "activities": activities,
+            "with_stack": with_stack,
+            "profile_memory": profile_memory,
+            "data_process": data_process,
+            "parallel_strategy": parallel_strategy,
+            "start_profile": start_profile,
+            "hbm_ddr": hbm_ddr,
+            "pcie": pcie,
+            "sync_enable": sync_enable,
+            "record_shapes": record_shapes,
+            "schedule": schedule,
+            "on_trace_ready": on_trace_ready,
+            "experimental_config": experimental_config,
+        }
+        self._prof_context.set_params(**kwargs)
+        self._has_started: bool = False
+        if schedule and isinstance(schedule, Callable):
+            self.schedule = schedule
+            # add step markers into the trace and table view
+            self.record_steps = True
+        else:
+            if schedule:
+                logger.warning("schedule is not Callable, set by default.")
+            self.schedule = _default_schedule_fn
+            self.record_steps = False
+        self._step_rec_fn: Optional[RecordFunction] = None
+        self.step_num = 0
+        self.current_action: ProfilerAction = self.schedule(self.step_num)
+        self.action_controller = ProfilerActionController(ProfilerInterface, self._prof_context.on_trace_ready)
+        if self._prof_context.start_profile:
+            self.start()
 
     def start(self) -> None:
         """
@@ -902,8 +903,8 @@ class Profile:
             ...     net = Net()
             ...     # Note that the Profiler should be initialized before model.train
             ...     prof = mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
-            ...                                       schedule=mindspore.profiler.schedule(wait=1, warmup=1, active=2,
-            ...                                           repeat=1, skip_first=2),
+            ...                                       schedule=mindspore.profiler.schedule(wait=0, warmup=0, active=1,
+            ...                                           repeat=1, skip_first=0),
             ...                                       on_trace_ready=mindspore.profiler.
             ...                                           tensorboard_trace_handler("./data"),
             ...                                       profile_memory=False,
@@ -915,7 +916,14 @@ class Profile:
             ...         prof.step()
             ...     prof.stop()
         """
-        self._profiler.start()
+        if self._has_started:
+            logger.warning("The profile has already started. Do not turn on again in the open state.")
+            return
+        self._has_started = True
+        self.action_controller.transit_action(ProfilerAction.NONE, self.current_action)
+        if self.record_steps:
+            self._step_rec_fn = RecordFunction(ProfilerStepNameConstant.PROFILER_STEP + str(self.step_num))
+            self._step_rec_fn.start()
 
     def stop(self) -> None:
         """
@@ -966,8 +974,8 @@ class Profile:
             ...     net = Net()
             ...     # Note that the Profiler should be initialized before model.train
             ...     prof = mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
-            ...                                       schedule=mindspore.profiler.schedule(wait=1, warmup=1, active=2,
-            ...                                           repeat=1, skip_first=2),
+            ...                                       schedule=mindspore.profiler.schedule(wait=0, warmup=0, active=1,
+            ...                                           repeat=1, skip_first=0),
             ...                                       on_trace_ready=mindspore.profiler.
             ...                                           tensorboard_trace_handler("./data"),
             ...                                       profile_memory=False,
@@ -979,7 +987,13 @@ class Profile:
             ...         prof.step()
             ...     prof.stop()
         """
-        self._profiler.stop()
+        if not self._has_started:
+            logger.error("The profile has not started. Do not turn off again in the closed state.")
+            return
+        self._has_started = False
+        if self.record_steps and self._step_rec_fn:
+            self._step_rec_fn.stop()
+        self.action_controller.transit_action(self.current_action, None)
 
     def step(self) -> None:
         """
@@ -990,59 +1004,71 @@ class Profile:
             RuntimeError: If the `schedule` parameter is not set.
 
         Examples:
-        >>> import numpy as np
-        >>> import mindspore
-        >>> from mindspore import nn, context
-        >>> import mindspore.dataset as ds
-        >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, AicoreMetrics, ExportType
-        >>>
-        >>> class Net(nn.Cell):
-        ...     def __init__(self):
-        ...         super(Net, self).__init__()
-        ...         self.fc = nn.Dense(2,2)
-        ...     def construct(self, x):
-        ...         return self.fc(x)
-        >>>
-        >>> def generator():
-        ...     for i in range(2):
-        ...         yield np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32)
-        >>>
-        >>> def train(net):
-        ...     optimizer = nn.Momentum(net.trainable_params(), 1, 0.9)
-        ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
-        ...     data = ds.GeneratorDataset(generator, ["data", "label"])
-        ...     model = mindspore.train.Model(net, loss, optimizer)
-        ...     model.train(1, data)
-        >>>
-        >>> if __name__ == '__main__':
-        ...     # If the device_target is GPU, set the device_target to "GPU"
-        ...     context.set_context(mode=mindspore.GRAPH_MODE)
-        ...     mindspore.set_device("Ascend")
-        ...
-        ...     # Init Profiler
-        ...     experimental_config = mindspore.profiler._ExperimentalConfig(
-        ...                                 profiler_level=ProfilerLevel.Level0,
-        ...                                 aic_metrics=AicoreMetrics.AiCoreNone,
-        ...                                 l2_cache=False,
-        ...                                 mstx=False,
-        ...                                 data_simplification=False,
-        ...                                 export_type=[ExportType.Text])
-        ...     steps = 10
-        ...     net = Net()
-        ...     # Note that the Profiler should be initialized before model.train
-        ...     with mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
-        ...                                     schedule=mindspore.profiler.schedule(wait=1, warmup=1, active=2,
-        ...                                           repeat=1, skip_first=2),
-        ...                                     on_trace_ready=mindspore.profiler.tensorboard_trace_handler("./data"),
-        ...                                     profile_memory=False,
-        ...                                     experimental_config=experimental_config) as prof:
-        ...
-        ...         # Train Model
-        ...         for step in range(steps):
-        ...             train(net)
-        ...             prof.step()
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import nn, context
+            >>> import mindspore.dataset as ds
+            >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, AicoreMetrics, ExportType
+            >>>
+            >>> class Net(nn.Cell):
+            ...     def __init__(self):
+            ...         super(Net, self).__init__()
+            ...         self.fc = nn.Dense(2,2)
+            ...     def construct(self, x):
+            ...         return self.fc(x)
+            >>>
+            >>> def generator():
+            ...     for i in range(2):
+            ...         yield np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32)
+            >>>
+            >>> def train(net):
+            ...     optimizer = nn.Momentum(net.trainable_params(), 1, 0.9)
+            ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+            ...     data = ds.GeneratorDataset(generator, ["data", "label"])
+            ...     model = mindspore.train.Model(net, loss, optimizer)
+            ...     model.train(1, data)
+            >>>
+            >>> if __name__ == '__main__':
+            ...     # If the device_target is GPU, set the device_target to "GPU"
+            ...     context.set_context(mode=mindspore.GRAPH_MODE)
+            ...     mindspore.set_device("Ascend")
+            ...
+            ...     # Init Profiler
+            ...     experimental_config = mindspore.profiler._ExperimentalConfig(
+            ...                                 profiler_level=ProfilerLevel.Level0,
+            ...                                 aic_metrics=AicoreMetrics.AiCoreNone,
+            ...                                 l2_cache=False,
+            ...                                 mstx=False,
+            ...                                 data_simplification=False,
+            ...                                 export_type=[ExportType.Text])
+            ...     steps = 10
+            ...     net = Net()
+            ...     # Note that the Profiler should be initialized before model.train
+            ...     with mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
+            ...                                     schedule=mindspore.profiler.schedule(wait=0, warmup=0, active=1,
+            ...                                           repeat=1, skip_first=0),
+            ...                                     on_trace_ready=mindspore.profiler.
+            ...                                         tensorboard_trace_handler("./data"),
+            ...                                     profile_memory=False,
+            ...                                     experimental_config=experimental_config) as prof:
+            ...
+            ...         # Train Model
+            ...         for step in range(steps):
+            ...             train(net)
+            ...             prof.step()
         """
-        self._profiler.step()
+        if not self._has_started:
+            logger.error("profile is stopped, step takes no effect!")
+            return
+        if self.record_steps and self._step_rec_fn:
+            self._step_rec_fn.stop()
+        prev_action = self.current_action
+        self.step_num += 1
+        self.current_action = self.schedule(self.step_num)
+        self.action_controller.transit_action(prev_action, self.current_action)
+        if self.record_steps:
+            self._step_rec_fn = RecordFunction(ProfilerStepNameConstant.PROFILER_STEP + str(self.step_num))
+            self._step_rec_fn.start()
 
     def add_metadata(self, key: str, value: str):
         """
@@ -1059,8 +1085,18 @@ class Profile:
             ...     # Call Profiler add_metadata
             ...     prof.add_metadata("test_key", "test_value")
         """
+        if not isinstance(key, str) or not isinstance(value, str):
+            logger.warning("The key and value of metadata must be string. Skip this metadata.")
+            return
 
-        self._profiler.add_metadata(key, value)
+        add_size = getsizeof(key) + getsizeof(value)
+        if getsizeof(self._metadata) + add_size < ProfilerMetaData.MAX_META_SIZE:
+            if key in self._metadata:
+                logger.warning(f"{key} is already saved as metadata, override it.")
+            self._metadata[key] = value
+            ProfilerMetaData.set_metadata(self._metadata)
+        else:
+            logger.warning("Too many metadata added. Skip this metadata")
 
     def add_metadata_json(self, key: str, value: str):
         """
@@ -1078,7 +1114,35 @@ class Profile:
             ...     # Call Profiler add_metadata_json
             ...     prof.add_metadata_json("test_key", json.dumps({"key1": 1, "key2": 2}))
         """
-        self._profiler.add_metadata_json(key, value)
+        if not isinstance(key, str) or not isinstance(value, str):
+            logger.warning("The key and value of metadata must be string. Skip this metadata.")
+            return
+
+        add_size = getsizeof(key) + getsizeof(value)
+        if getsizeof(self._metadata) + add_size < ProfilerMetaData.MAX_META_SIZE:
+            try:
+                if key in self._metadata:
+                    logger.warning(f"{key} is already saved as metadata, override it.")
+                self._metadata[key] = json.loads(value)
+                ProfilerMetaData.set_metadata(self._metadata)
+            except ValueError:
+                logger.warning("The metadata value must be json format string. Skip this metadata")
+        else:
+            logger.warning("Too many metadata added. Skip this metadata")
+
+    def __enter__(self) -> 'Profile':
+        if not self._has_started:
+            self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        if self._has_started:
+            self.stop()
+
+    def __del__(self):
+        if self._has_started:
+            self.stop()
+            logger.warning("profile is stopped at the end of the program.")
 
 
 def analyse(profiler_path: str, max_process_number: int = os.cpu_count() // 2, pretty=False, step_list=None,