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

mindspore/profiler/envprofiler.py

@@ -16,12 +16,15 @@
 import os
 import json
 from mindspore import log as logger
-from mindspore.profiler.profiler import Profiler
+from mindspore.profiler.profiler import Profile
+from mindspore.profiler.experimental_config import _ExperimentalConfig
+from mindspore.profiler import tensorboard_trace_handler
 from mindspore.profiler.common.constant import (
     ProfilerLevel,
     AicoreMetrics,
     ProfilerActivity,
     ExportType,
+    HostSystem
 )
 from mindspore.profiler.common.profiler_parameters import ProfilerParameters
 
@@ -46,8 +49,31 @@ class EnvProfiler:
 
         params = cls._convert_options_to_profiler_params(options)
         logger.info(f"params: {params}")
-        if params["start_profile"]:
-            cls.profiler = Profiler(**params)
+        if params["start"]:
+            experimental_config = _ExperimentalConfig(profiler_level=params.get("profiler_level"),
+                                                      aic_metrics=params.get("aic_metrics"),
+                                                      l2_cache=params.get("l2_cache"),
+                                                      mstx=params.get("mstx"),
+                                                      data_simplification=params.get("data_simplification"),
+                                                      export_type=params.get("export_type"),
+                                                      mstx_domain_include=params.get("mstx_domain_include"),
+                                                      mstx_domain_exclude=params.get("mstx_domain_exclude"),
+                                                      sys_io=params.get("sys_io"),
+                                                      sys_interconnection=params.get("sys_interconnection"),
+                                                      host_sys=params.get("host_sys"))
+            cls.profiler = Profile(activities=params.get("activities"),
+                                   with_stack=params.get("with_stack"),
+                                   profile_memory=params.get("profile_memory"),
+                                   data_process=params.get("data_process"),
+                                   parallel_strategy=params.get("parallel_strategy"),
+                                   start_profile=params.get("start_profile"),
+                                   hbm_ddr=params.get("hbm_ddr"),
+                                   pcie=params.get("pcie"),
+                                   sync_enable=params.get("sync_enable"),
+                                   record_shapes=params.get("record_shapes"),
+                                   on_trace_ready=tensorboard_trace_handler(params.get("output_path")),
+                                   experimental_config=experimental_config)
+            cls.profiler.start()
             logger.info("Profiler init success.")
 
     def analyse(self):
@@ -58,7 +84,7 @@ class EnvProfiler:
         if not self.profiler:
             logger.info("Profiler is not initialized, skip analyse.")
             return
-        self.profiler.analyse()
+        self.profiler.stop()
         logger.info("analyse end")
 
     @classmethod
@@ -100,13 +126,17 @@ class EnvProfiler:
             params["output_path"] = options["output_path"]
 
         # if start is not set, default is False
-        params["start_profile"] = options.get("start", False)
+        params["start"] = options.get("start", False)
 
         for param, (_, default_value) in ProfilerParameters.PARAMS.items():
             if param in options and param not in cls.NOT_SUPPORTED_PARAMS:
                 if param == "activities" and isinstance(options[param], list):
-                    params[param] = cls._convert_activities_to_list(
-                        options[param], default_value
+                    params[param] = cls._convert_enums_to_list(
+                        options[param], default_value, ProfilerActivity
+                    )
+                elif param == "host_sys" and isinstance(options[param], list):
+                    params[param] = cls._convert_enums_to_list(
+                        options[param], default_value, HostSystem
                     )
                 elif param == "aic_metrics":
                     params[param] = cls._convert_option_to_enum_value(
@@ -125,15 +155,15 @@ class EnvProfiler:
         return params
 
     @classmethod
-    def _convert_activities_to_list(cls, activities, default_value):
+    def _convert_enums_to_list(cls, values, default_value, enum_class):
         """
-        Convert the activities to the list.
+        Convert the enums to the list.
         """
         res = []
-        for activity in activities:
+        for value in values:
             res.append(
                 cls._convert_option_to_enum_value(
-                    ProfilerActivity, activity, default_value
+                    enum_class, value, default_value
                 )
             )
         # remove duplicate
@@ -146,7 +176,7 @@ class EnvProfiler:
         """
         res = []
         for export_type in export_types:
-            if export_type != "text" and export_type != "db":
+            if export_type not in ("text", "db"):
                 logger.warning(
                     f"The value '{export_type}' of parameter '{ExportType.__name__}' is invalid, "
                     f"use default value '{default_value}' instead."

mindspore/profiler/experimental_config.py

@@ -14,10 +14,10 @@
 # ============================================================================
 """Experimental config file."""
 
-from mindspore.profiler.common.constant import ProfilerLevel, AicoreMetrics
-
 __all__ = ["_ExperimentalConfig"]
 
+from mindspore.profiler.common.constant import ProfilerLevel, AicoreMetrics
+
 
 class _ExperimentalConfig:
     r"""
@@ -58,8 +58,8 @@ class _ExperimentalConfig:
             - AicoreMetrics.MemoryAccess: Statistics on storage access bandwidth and storage capacity of main
               storage and l2 cache etc.
         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,
-            only wait and skip_first parameters in schedule configuration can be set to 0.
+            Default: ``False`` . The l2_cache.csv file is generated in the ASCEND_PROFILER_OUTPUT folder. In GE backend,
+            only support :class:`mindspore.profiler.schedule` configuration wait and skip_first parameter is 0.
         mstx (bool, optional): (Ascend only) Whether to collect light weight profiling data, collect when True.
             Default: ``False`` .
         data_simplification (bool, optional): (Ascend only) Whether to remove FRAMEWORK data and other redundant data.
@@ -71,6 +71,53 @@ class _ExperimentalConfig:
 
             - ExportType.Text: Export text type data.
             - ExportType.Db: Export db type data.
+        mstx_domain_include (list, optional): (Ascend only) Set the set of enabled domain names when the mstx switch
+                  is turned on. The name must be of str type. Default value: ``[]``, indicating that this parameter
+                  is not used to control the domain. This parameter is mutually exclusive with the mstx_domain_exclude
+                  parameter and cannot be set. simultaneously. If both are set, only the mstx_domain_include parameter
+                  takes effect.
+        mstx_domain_exclude (list, optional): (Ascend only) Set the set of domain names that are not enabled when the
+                  mstx switch is turned on. The name must be of str type. Default value: ``[]``, indicating that this
+                  parameter is not used to control the domain.
+        sys_io (bool, optional): (Ascend only) Whether to collect NIC and RoCE data. Default: ``False``.
+        sys_interconnection (bool, optional): (Ascend only) Whether to collect system interconnection data, including
+            HCCS data, PCIe data, and Stars Chip Trans. Default: ``False``.
+        host_sys (list, optional): Collect the data of system call classes on the host side.
+            Default: ``[]``, indicating that system class data on the host side is not collected.
+            You need to set `start_profile` of :class:`mindspore.profiler.profile` to ``False``.When collecting DISK or
+            OSRT data, it is necessary to install the iotop, perf, and ltrace third-party tools in advance.
+            For detailed steps, please refer to `Installing Third-party Tools
+            <https://www.hiascend.com/document/detail/zh/mindstudio/80RC1/T&ITools/Profiling/atlasprofiling_16_0136.
+            html>`_ .
+            After the third-party tool is successfully installed, user permissions need to be configured.
+            For detailed steps, please refer to `Configure User Permissions
+            <https://www.hiascend.com/document/detail/zh/mindstudio/80RC1/T&ITools/Profiling/atlasprofiling_16_0137.
+            html>`_ .
+            Note that in step 3 of configuring user permissions, the content in the msprof_data_collection.sh
+            script needs to be replaced with `msprof_data_collection.sh
+            <https://gitee.com/mindspore/mindspore/blob/master/docs/api/api_python/mindspore/script/
+            msprof_data_collection.sh>`_.
+
+            Final deliverables by `MindStudio Insight
+            <https://www.hiascend.com/developer/download/community/result?module=pt+sto+cann>`_
+            tool visualizes the analysis results.
+            For detailed analysis, please refer to `host-side CPU data analysis
+            <https://www.hiascend.com/document/detail/zh/mindstudio/80RC1/T&ITools/Profiling/
+            atlasprofiling_16_0106.html>`_, `host-side MEM data analysis
+            <https://www.hiascend.com/document/detail/zh/mindstudio/80RC1/T&ITools/Profiling/
+            atlasprofiling_16_0107.html>`_, `host-side DISK data analysis
+            <https://www.hiascend.com/document/detail/zh/mindstudio/80RC1/T&ITools/Profiling/
+            atlasprofiling_16_0108.html>`_, `host-side NETWORK data analysis
+            <https://www.hiascend.com/document/detail/zh/mindstudio/80RC1/T&ITools/Profiling/
+            atlasprofiling_16_0109.html>`_, `host-side OSRT data analysis
+            <https://www.hiascend.com/document/detail/zh/mindstudio/80RC1/T&ITools/Profiling/
+            atlasprofiling_16_0110.html>`_.
+
+            - HostSystem.CPU: Collect the CPU utilization at the process level.
+            - HostSystem.MEM: Collect the memory utilization at the process level.
+            - HostSystem.DISK: Collect the disk I/O utilization at the process level.
+            - HostSystem.NETWORK: Collect the network I/O utilization at the system level.
+            - HostSystem.OSRT: Collect system call stack data at the system level.
 
     Raises:
         RuntimeError: When the version of CANN does not match the version of MindSpore,
@@ -121,8 +168,8 @@ class _ExperimentalConfig:
         ...     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:
@@ -139,38 +186,76 @@ class _ExperimentalConfig:
                  l2_cache: bool = False,
                  mstx: bool = False,
                  data_simplification: bool = True,
-                 export_type: list = None):
+                 export_type: list = None,
+                 mstx_domain_include: list = None,
+                 mstx_domain_exclude: list = None,
+                 sys_io: bool = False,
+                 sys_interconnection: bool = False,
+                 host_sys: list = None
+                 ):
         self._profiler_level = profiler_level
         self._aic_metrics = aic_metrics
         self._l2_cache = l2_cache
         self._mstx = mstx
         self._data_simplification = data_simplification
         self._export_type = export_type
+        self._mstx_domain_include = mstx_domain_include
+        self._mstx_domain_exclude = mstx_domain_exclude
+        self._sys_io = sys_io
+        self._sys_interconnection = sys_interconnection
+        self._host_sys = host_sys
 
     @property
     def profiler_level(self) -> ProfilerLevel:
+        """Get profiler_level."""
         return self._profiler_level
 
     @property
     def aic_metrics(self) -> AicoreMetrics:
+        """Get aic_metrics."""
         return self._aic_metrics
 
     @property
     def l2_cache(self) -> bool:
+        """Get l2_cache."""
         return self._l2_cache
 
     @property
     def mstx(self) -> bool:
+        """Get mstx."""
         return self._mstx
 
     @property
     def data_simplification(self) -> bool:
+        """Get data_simplification."""
         return self._data_simplification
 
     @property
     def export_type(self) -> list:
+        """Get export_type."""
         return self._export_type
 
+    @property
+    def mstx_domain_include(self) -> list:
+        return self._mstx_domain_include
+
+    @property
+    def mstx_domain_exclude(self) -> list:
+        return self._mstx_domain_exclude
+
+    @property
+    def sys_io(self) -> bool:
+        return self._sys_io
+
+    @property
+    def sys_interconnection(self) -> bool:
+        return self._sys_interconnection
+
+    @property
+    def host_sys(self) -> list:
+        """Get host_sys."""
+        return self._host_sys
+
     # Setters
     @profiler_level.setter
     def profiler_level(self, value: ProfilerLevel):
@@ -195,3 +280,23 @@ class _ExperimentalConfig:
     @export_type.setter
     def export_type(self, value: list):
         self._export_type = value
+
+    @mstx_domain_include.setter
+    def mstx_domain_include(self, value: list):
+        self._mstx_domain_include = value
+
+    @mstx_domain_exclude.setter
+    def mstx_domain_exclude(self, value: list):
+        self._mstx_domain_exclude = value
+
+    @sys_io.setter
+    def sys_io(self, value: bool):
+        self._sys_io = value
+
+    @sys_interconnection.setter
+    def sys_interconnection(self, value: bool):
+        self._sys_interconnection = value
+
+    @host_sys.setter
+    def host_sys(self, value: list):
+        self._host_sys = value

mindspore/profiler/mstx.py

@@ -39,7 +39,7 @@ class Mstx:
     )
 
     @staticmethod
-    def mark(message: str, stream: mindspore.runtime.Stream = None) -> None:
+    def mark(message: str, stream: mindspore.runtime.Stream = None, domain: str = "default") -> None:
         """Add a marker point in profiling.
 
         Args:
@@ -47,6 +47,7 @@ class Mstx:
             stream (:class:`~.runtime.Stream`, optional): NPU stream for async execution, expected type:
                 mindspore.runtime.Stream. Default: ``None``, which means only marking on host side without
                 marking on device stream.
+            domain (str, optional): Domain name. Default: ``default``.
 
         Examples:
             >>> import numpy as np
@@ -77,6 +78,7 @@ class Mstx:
             ...     model = ms.train.Model(net, loss, optimizer)
             ...     # Add marker before training
             ...     mstx.mark("train start", stream)
+            ...     mstx.mark("train start", stream, "domain_name")
             ...     model.train(1, data)
             ...     # Add marker after training
             ...     mstx.mark("train end", stream)
@@ -112,19 +114,24 @@ class Mstx:
         if not message or not isinstance(message, str):
             logging.warning("Invalid message for mstx.mark func. Please input valid message string.")
             return
+        if not isinstance(domain, str) or domain == "":
+            logging.warning(
+                "Invalid domain name for mstx.mark func. Please input str and can not be empty."
+            )
+            return
         if stream:
             if isinstance(stream, Stream):
                 device_stream = stream.device_stream()
-                Mstx.NPU_PROFILER.mstx_mark(message, device_stream)
+                Mstx.NPU_PROFILER.mstx_mark(message, device_stream, domain)
             else:
                 logging.warning(
                     f"Invalid stream for mstx.mark func. Expected mindspore.runtime.Stream but got {type(stream)}.",
                 )
         else:
-            Mstx.NPU_PROFILER.mstx_mark(message)
+            Mstx.NPU_PROFILER.mstx_mark(message, None, domain)
 
     @staticmethod
-    def range_start(message: str, stream: mindspore.runtime.Stream = None) -> int:
+    def range_start(message: str, stream: mindspore.runtime.Stream = None, domain: str = "default") -> int:
         """Start a profiling range.
 
         Args:
@@ -132,6 +139,7 @@ class Mstx:
             stream (:class:`~.runtime.Stream`, optional): NPU stream for async execution, expected type:
                 mindspore.runtime.Stream. Default: ``None``, which means only starting mstx range on
                 host side without starting on device stream.
+            domain (str, optional): Domain name. Default: ``default``.
 
         Returns:
             int, range ID for range_end.
@@ -165,9 +173,11 @@ class Mstx:
             ...     model = ms.train.Model(net, loss, optimizer)
             ...     # Start profiling range
             ...     range_id = mstx.range_start("training process", stream)
+            ...     range_id2 = mstx.range_start("training process", stream, "domain_name")
             ...     model.train(1, data)
             ...     # End profiling range
             ...     mstx.range_end(range_id)
+            ...     mstx.range_end(range_id2, "domain_name")
             >>>
             >>> if __name__ == '__main__':
             ...     # Note: mstx only supports Ascend device and cannot be used in mindspore.nn.Cell.construct
@@ -201,10 +211,15 @@ class Mstx:
             logging.warning("Invalid message for mstx.range_start func. Please input valid message string.")
             return 0
         # pylint: disable=no-else-return
+        if not isinstance(domain, str) or domain == "":
+            logging.warning(
+                "Invalid domain name for mstx.range_start func. Please input str and can not be empty."
+            )
+            return 0
         if stream:
             if isinstance(stream, Stream):
                 device_stream = stream.device_stream()
-                return Mstx.NPU_PROFILER.mstx_range_start(message, device_stream)
+                return Mstx.NPU_PROFILER.mstx_range_start(message, device_stream, domain)
             else:
                 logging.warning(
                     f"Invalid stream for mstx.range_start func. "
@@ -212,20 +227,21 @@ class Mstx:
                 )
                 return 0
         else:
-            return Mstx.NPU_PROFILER.mstx_range_start(message)
+            return Mstx.NPU_PROFILER.mstx_range_start(message, None, domain)
 
     @staticmethod
-    def range_end(range_id: int) -> None:
+    def range_end(range_id: int, domain: str = "default") -> None:
         """End a profiling range.
 
         Args:
             range_id (int): Range ID from range_start.
+            domain (str, optional): Domain name. Default: ``default``.
 
         Examples:
             >>> # Please refer to the example in range_start
-            >>> # range_id = mstx.range_start("training process", stream)
+            >>> # range_id = mstx.range_start("training process", stream, "domain_name")
             >>> # model.train(1, data)
-            >>> # mstx.range_end(range_id)
+            >>> # mstx.range_end(range_id, "domain_name")
         """
         if not Mstx.enable or range_id == 0:
             return
@@ -234,9 +250,14 @@ class Mstx:
         if not Mstx.NPU_PROFILER:
             logging.warning("Invalid npu profiler for mstx, please check.")
             return
-        if not isinstance(range_id, int):
+        if not isinstance(range_id, int) or range_id < 0:
+            logging.warning(
+                "Invalid range_id for mstx.range_end func. Please input return value from mstx.range_start."
+            )
+            return
+        if not isinstance(domain, str) or domain == "":
             logging.warning(
-                "Invalid message for mstx.range_start func. Please input return value from mstx.range_start."
+                "Invalid domain name for mstx.range_end func. Please input str and can not be empty."
             )
             return
-        Mstx.NPU_PROFILER.mstx_range_end(range_id)
+        Mstx.NPU_PROFILER.mstx_range_end(range_id, domain)

mindspore/profiler/platform/__init__.py

@@ -13,9 +13,8 @@
 # limitations under the License.
 # ============================================================================
 """Platform profiler"""
+__all__ = ["CpuProfiler", "GpuProfiler", "NpuProfiler"]
+
 from .cpu_profiler import CpuProfiler
 from .gpu_profiler import GpuProfiler
 from .npu_profiler import NpuProfiler
-
-
-__all__ = ["CpuProfiler", "GpuProfiler", "NpuProfiler"]

mindspore/profiler/platform/cpu_profiler.py

@@ -16,10 +16,11 @@
 import mindspore._c_expression as c_expression
 
 from mindspore.profiler.common.registry import PROFILERS
-from mindspore.profiler.common.constant import DeviceTarget, ProfilerActivity
+from mindspore.profiler.common.constant import DeviceTarget, ProfilerActivity, AnalysisMode
 from mindspore.profiler.common.util import print_msg_with_pid
 from mindspore.profiler.common.profiler_context import ProfilerContext
 from mindspore.profiler.common.profiler_path_manager import ProfilerPathManager
+from mindspore.profiler.common.process_pool import MultiProcessPool
 from mindspore.profiler.platform.base_profiler import BaseProfiler
 from mindspore.profiler.analysis.time_converter import TimeConverter
 from mindspore.profiler.analysis.task_manager import TaskManager
@@ -68,7 +69,7 @@ class CpuProfiler(BaseProfiler):
         if ProfilerContext().device_target_set != {DeviceTarget.CPU.value}:
             return
         self._logger.info("CpuProfiler analyse.")
-        CPUProfilerAnalysis.online_analyse()
+        CPUProfilerAnalysis.online_analyse(**kwargs)
 
     def finalize(self) -> None:
         """Finalize profiling data."""
@@ -81,12 +82,17 @@ class CPUProfilerAnalysis:
     """
 
     @classmethod
-    def online_analyse(cls):
+    def online_analyse(cls, async_mode: bool = False):
         """
         Online analysis for CPU
         """
         cls._pre_analyse_online()
-        cls._run_tasks(**ProfilerContext().to_dict())
+        if async_mode:
+            ProfilerContext().mode = AnalysisMode.ASYNC_MODE.value
+            MultiProcessPool().add_async_job(cls._run_tasks, **ProfilerContext().to_dict())
+        else:
+            ProfilerContext().mode = AnalysisMode.SYNC_MODE.value
+            cls._run_tasks(**ProfilerContext().to_dict())
 
     @classmethod
     def _pre_analyse_online(cls):

mindspore/profiler/platform/npu_profiler.py

@@ -18,7 +18,6 @@ import glob
 import json
 from typing import List, Optional
 
-from mindspore import context
 from mindspore import log as logger
 import mindspore._c_dataengine as cde
 import mindspore._c_expression as c_expression
@@ -55,6 +54,7 @@ from mindspore.profiler.analysis.viewer.ms_minddata_viewer import (
     MindDataPipelineRawViewer,
     MindDataPiplineSummaryViewer,
 )
+from mindspore.profiler.analysis.viewer.ms_operator_details_viewer import MsOperatorDetailsViewer
 from mindspore.profiler.common.util import print_msg_with_pid
 from mindspore.profiler.common.log import ProfilerLogger
 from mindspore.profiler.mstx import Mstx
@@ -86,11 +86,6 @@ class NpuProfiler(BaseProfiler):
 
         # record original profiler params
         self._prof_info.profiler_parameters = self._prof_ctx.original_params
-        self._prof_info.ms_profiler_info = {
-            "context_mode": context.get_context("mode"),
-            "rank_id": self._prof_ctx.rank_id,
-            "device_id": self._prof_ctx.device_id,
-        }
 
         # initialize minddata profiler
         if self._prof_ctx.data_process:
@@ -136,13 +131,27 @@ class NpuProfiler(BaseProfiler):
             self._md_profiler.stop()
             self._md_profiler.save(self._prof_ctx.framework_path)
 
+        if ProfilerActivity.NPU in self._prof_ctx.activities:
+            prof_dir = glob.glob(os.path.join(self._prof_ctx.ascend_ms_dir, "PROF_*"))
+            if not prof_dir:
+                logger.error(f"No PROF_* directory found in {self._prof_ctx.ascend_ms_dir}")
+                return
+
+            self._prof_ctx.msprof_profile_path = prof_dir[0]
+            self._prof_ctx.device_id = self._prof_ctx.msprof_profile_device_path.split("_")[-1]
+
+        self._prof_info.ms_profiler_info = {
+            "rank_id": self._prof_ctx.rank_id,
+            "device_id": self._prof_ctx.device_id,
+        }
+
         self._prof_info.save(self._prof_ctx.ascend_ms_dir, self._prof_ctx.rank_id)
 
     def analyse(self, **kwargs) -> None:
         """Analyse the profiling data."""
         self._logger.info("NpuProfiler analyse.")
 
-        NPUProfilerAnalysis.online_analyse()
+        NPUProfilerAnalysis.online_analyse(async_mode=kwargs.get('async_mode'))
 
     def finalize(self) -> None:
         """Finalize profiling data."""
@@ -189,12 +198,6 @@ class NPUProfilerAnalysis:
         """
         prof_ctx = ProfilerContext()
         if ProfilerActivity.NPU in prof_ctx.activities:
-            prof_dir = glob.glob(os.path.join(prof_ctx.ascend_ms_dir, "PROF_*"))
-            if not prof_dir:
-                logger.error(f"No PROF_* directory found in {prof_ctx.ascend_ms_dir}")
-                return
-
-            prof_ctx.msprof_profile_path = prof_dir[0]
             ProfilerPathManager().clean_analysis_cache()
             ProfilerPathManager().create_output_path()
             ProfilerInfo().load_time_parameters(
@@ -224,7 +227,6 @@ class NPUProfilerAnalysis:
         prof_ctx.set_params()
         prof_ctx.load_offline_profiler_params(prof_info.profiler_parameters)
         prof_ctx.jit_level = prof_info.jit_level
-        prof_ctx.context_mode = prof_info.context_mode
 
         if ProfilerActivity.NPU in prof_ctx.activities:
             prof_dir = glob.glob(os.path.join(ascend_ms_dir, "PROF_*"))
@@ -274,18 +276,20 @@ class NPUProfilerAnalysis:
         task_mgr = TaskManager()
         activities = kwargs.get("activities", [])
         export_type = kwargs.get("export_type", [])
+        record_shapes = kwargs.get("record_shapes", False)
         enable_data_process = kwargs.get("data_process", False)
 
         # CANN flow parser
         cann_flow_parsers = []
 
         if export_type == [ExportType.Db.value]:
-            cann_flow_parsers.append(
-                AscendMsprofParser(**kwargs)
-            )
-            task_mgr.create_flow(
-                *cann_flow_parsers, flow_name="cann_flow", show_process=True
-            )
+            if ProfilerActivity.NPU.value in activities:
+                cann_flow_parsers.append(
+                    AscendMsprofParser(**kwargs)
+                )
+                task_mgr.create_flow(
+                    *cann_flow_parsers, flow_name="cann_flow", show_process=True
+                )
             return task_mgr
 
         if ProfilerActivity.NPU.value in activities:
@@ -301,6 +305,12 @@ class NPUProfilerAnalysis:
                     MsDatasetViewer(**kwargs).save
                 )
             )
+            if record_shapes:
+                cann_flow_parsers.append(
+                    FrameworkCannRelationParser(**kwargs).register_post_hook(
+                        MsOperatorDetailsViewer(**kwargs).save
+                    )
+                )
 
         if ProfilerActivity.NPU.value in activities:
             cann_flow_parsers.append(