mindspore 2.6.0rc1__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/profiler/envprofiler.py

@@ -22,6 +22,7 @@ from mindspore.profiler.common.constant import (
     AicoreMetrics,
     ProfilerActivity,
     ExportType,
+    HostSystem
 )
 from mindspore.profiler.common.profiler_parameters import ProfilerParameters
 
@@ -105,8 +106,12 @@ class EnvProfiler:
         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 +130,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 +151,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,7 +58,7 @@ 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,
+            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.
         mstx (bool, optional): (Ascend only) Whether to collect light weight profiling data, collect when True.
             Default: ``False`` .
@@ -71,6 +71,38 @@ 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>`_.
+
+            - 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 +153,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 +171,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 +265,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/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,6 +131,20 @@ 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:
@@ -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(

mindspore/profiler/profiler.py

@@ -15,6 +15,7 @@
 """Profiling api file."""
 import os
 import json
+import warnings
 from typing import Optional, Dict, Callable, Any
 from sys import getsizeof
 from concurrent.futures import ProcessPoolExecutor, as_completed
@@ -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:
@@ -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`` .
@@ -492,8 +493,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):
@@ -646,6 +646,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 +662,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,6 +688,8 @@ 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,
@@ -707,8 +712,8 @@ class Profile:
             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.
         with_stack (bool, optional): (Ascend only) Whether to collect frame host call stack data
@@ -731,6 +736,9 @@ 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``.
         experimental_config (_ExperimentalConfig, optional): expandable parameters can be configured in this
               configuration item. For details, see :class:`mindspore.profiler._ExperimentalConfig` .
     Raises:
@@ -782,8 +790,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,
@@ -806,6 +814,7 @@ class Profile:
             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,
@@ -819,6 +828,7 @@ class 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()
@@ -835,9 +845,15 @@ class Profile:
             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,
         )
@@ -902,8 +918,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,
@@ -966,8 +982,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,
@@ -1031,8 +1047,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,
         ...                                     experimental_config=experimental_config) as prof: