mindspore 2.7.0rc1__cp311-cp311-win_amd64.whl → 2.7.1__cp311-cp311-win_amd64.whl

mindspore/profiler/profiler.py

@@ -16,18 +16,18 @@
 import os
 import json
 import warnings
-from typing import Optional, Dict, Callable, Any
+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
@@ -111,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
 
@@ -261,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)
@@ -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.")
@@ -696,38 +697,32 @@ class Profile:
     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` .
+        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`` .
         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.
-        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`` .
         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`` .
 
@@ -739,6 +734,12 @@ class Profile:
         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:
@@ -803,70 +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,
-            record_shapes: bool = False,
-            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._record_shapes = record_shapes
-        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,
-            record_shapes=self._record_shapes,
-            data_simplification=self._experimental_config.data_simplification,
-            mstx=self._experimental_config.mstx,
-            mstx_domain_include=self._experimental_config.mstx_domain_include,
-            mstx_domain_exclude=self._experimental_config.mstx_domain_exclude,
-            export_type=self._experimental_config.export_type,
-            sys_io=self._experimental_config.sys_io,
-            sys_interconnection=self._experimental_config.sys_interconnection,
-            host_sys=self._experimental_config.host_sys,
-            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:
         """
@@ -931,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:
         """
@@ -995,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:
         """
@@ -1006,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=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()
+            >>> 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):
         """
@@ -1075,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):
         """
@@ -1094,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,

mindspore/profiler/profiler_action_controller.py

@@ -56,7 +56,7 @@ class ProfilerActionController:
         This method is called when the trace is ready to notify the callback function.
         """
         if self.on_trace_ready:
-            self.on_trace_ready()
+            self.on_trace_ready(self.prof_interface)
 
     def transit_action(self, prev_action: ProfilerAction, current_action: ProfilerAction) -> None:
         """

mindspore/profiler/profiler_interface.py

@@ -76,14 +76,14 @@ class ProfilerInterface:
         logger.info("ProfilerInterface stop")
 
     @classmethod
-    def analyse(cls):
+    def analyse(cls, **kwargs):
         """ProfilerInterface analyse"""
         if not cls.is_initialized:
             logger.warning("ProfilerInterface analyse failed, profiler has not been initialized.")
             return
 
         for profiler in cls.platform_profilers_set:
-            profiler.analyse()
+            profiler.analyse(**kwargs)
 
         logger.info("ProfilerInterface analyse")
 

mindspore/rewrite/symbol_tree/symbol_tree.py

@@ -1503,7 +1503,7 @@ class SymbolTree(Observer, Observable, NodeManager):
         """
         # ast.Constant can be check without eval
         if isinstance(ast_node, ast.Constant):
-            return True, bool(ast.value)
+            return True, bool(ast_node.value)
         # Get the module where the code of ast_node is located
         file_path = inspect.getfile(type(self.get_origin_network()))
         module = None