mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/profiler/analysis/viewer/ascend_communication_viewer.py

@@ -17,11 +17,14 @@ import os
 import re
 from collections import defaultdict
 
-from mindspore import log as logger
+from typing import Dict
 from mindspore.profiler.analysis.viewer.base_viewer import BaseViewer
 from mindspore.profiler.common.file_manager import FileManager
 from mindspore.profiler.common.log import ProfilerLogger
 
+from mindspore import log as logger
+from mindspore.profiler.common.constant import JitLevel
+
 
 class AscendCommunicationViewer(BaseViewer):
     """Ascend communication viewer"""
@@ -51,12 +54,14 @@ class AscendCommunicationViewer(BaseViewer):
 
     def __init__(self, **kwargs):
         super().__init__()
-        self.step_list = [{"step_id": None, "start_ts": 0, "end_ts": float('inf'), "comm_ops": {}}]
+        self.step_list = []
         self.output_communication = {}
         self.output_matrix_data = {}
         self._output_path = kwargs.get("ascend_profiler_output_path")
         self._msprof_analyze_output_path = kwargs.get("msprof_analyze_output_path")
         self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
+        self._is_set_schedule = kwargs.get("is_set_schedule")
+        self._jit_level = kwargs.get("jit_level")
         ProfilerLogger.init(self._ascend_ms_dir)
         self._logger = ProfilerLogger.get_instance()
         self._communication_input_path = os.path.join(
@@ -82,6 +87,7 @@ class AscendCommunicationViewer(BaseViewer):
         """
         self._logger.info("AscendCommunicationViewer start")
         try:
+            self._init_step_list(data)
             self._generate_communication()
             self._generate_matrix()
             self._save_analyze_data()
@@ -89,6 +95,39 @@ class AscendCommunicationViewer(BaseViewer):
             self._logger.error("Failed to save ascend communication data, error: %s", e, exc_info=True)
         self._logger.info("AscendCommunicationViewer end")
 
+    def _init_step_list(self, data):
+        """
+        Init step list.
+        """
+        trace_container = data.get("trace_view_container", None)
+        if trace_container is None:
+            raise ValueError("trace view container is None")
+        step_id_to_time_dict = trace_container.get_step_id_time_dict()
+
+        if not self._is_set_schedule or self._jit_level == JitLevel.GRAPH_LEVEL or not step_id_to_time_dict:
+            self._update_default_step_list()
+        else:
+            self._update_step_list(step_id_to_time_dict)
+
+    def _update_default_step_list(self):
+        """
+        When the step dict is empty, it is set to the default value.
+        """
+        self.step_list = [{"step_id": "0", "start_ts": 0, "end_ts": float('inf'), "comm_ops": {}}]
+
+    def _update_step_list(self, step_id_to_time_dict: Dict):
+        """
+        When the step dict is not empty, set a value that contains the step id.
+        """
+        for step_id, (start_time, end_time) in step_id_to_time_dict.items():
+            step_dict = {
+                "step_id": step_id,
+                "start_ts": start_time,
+                "end_ts": end_time,
+                "comm_ops": {}
+            }
+            self.step_list.append(step_dict)
+
     def _save_analyze_data(self):
         """
         Save analyse data

mindspore/profiler/analysis/viewer/ascend_kernel_details_viewer.py

@@ -13,18 +13,21 @@
 # limitations under the License.
 # ============================================================================
 """Ascend kernel details viewer"""
-import os
 import csv
+import os
 from decimal import Decimal
 
-from mindspore import log as logger
 from mindspore.profiler.analysis.viewer.base_viewer import BaseViewer
-from mindspore.profiler.analysis.parser.timeline_assembly_factory.trace_view_container import TraceViewContainer
-from mindspore.profiler.common.constant import OpSummaryHeaders
-from mindspore.profiler.common.path_manager import PathManager
-from mindspore.profiler.common.constant import TimelineLayerName
-from mindspore.profiler.common.constant import ProfilerStepNameConstant, JitLevel, ProfilerLevel
+from mindspore.profiler.common.constant import (
+    JitLevel,
+    ProfilerLevel,
+    OpSummaryHeaders,
+    ProfilerActivity
+)
 from mindspore.profiler.common.log import ProfilerLogger
+from mindspore.profiler.common.path_manager import PathManager
+
+from mindspore import log as logger
 
 
 class AscendKernelDetailsViewer(BaseViewer):
@@ -63,6 +66,7 @@ class AscendKernelDetailsViewer(BaseViewer):
         self._is_set_schedule = kwargs.get("is_set_schedule")
         self._jit_level = kwargs.get("jit_level")
         self._profiler_level = kwargs.get("profiler_level")
+        self._activities = kwargs.get("activities")
         self.op_summary_headers = None
         self.op_summary = None
         self.trace_container = None
@@ -79,7 +83,7 @@ class AscendKernelDetailsViewer(BaseViewer):
             if self._profiler_level == ProfilerLevel.LevelNone.value:
                 return
             self._check_input_data(data)
-            self._update_kernel_name()
+            self._update_kernel_name_and_step_id()
             self._update_headers()
             self._write_data()
             self._logger.info("Kernel details saved done")
@@ -132,27 +136,38 @@ class AscendKernelDetailsViewer(BaseViewer):
                 if header not in self.LEVEL0_EXCLUDE_HEADERS
             ]
 
-        if not self._is_set_schedule or self._jit_level == JitLevel.GRAPH_LEVEL:
+        if (not self._is_set_schedule or self._jit_level == JitLevel.GRAPH_LEVEL or
+                not self.trace_container.get_step_id_time_dict()):
             self.op_summary_headers.remove(OpSummaryHeaders.STEP_ID.value)
+
         # rename headers
         self.kernel_details_headers = [
             self.RENAME_HEADERS.get(header, header)
             for header in self.op_summary_headers
         ]
 
-    def _update_kernel_name(self):
+    def _update_kernel_name_and_step_id(self):
         """
-        Update op summary op name to framework launch op name.
+        Update kernel op name to framework launch op name and step id.
         """
         self._logger.info("Update kernel name start")
-        step_id_to_time_dict = _generate_step_id_dict_by_trace_container(self.trace_container)
+
         dev_kernels = self.trace_container.hardware_op_event
+        step_id_to_time_dict = self.trace_container.get_step_id_time_dict()
+
+        # activities parameter NPU+CPU、CPU
+        if ProfilerActivity.CPU.value in self._activities:
+            self._update_kernel_detail_op_name_and_step_id(dev_kernels, step_id_to_time_dict)
+
+    def _update_kernel_detail_op_name_and_step_id(self, dev_kernels, step_id_to_time_dict):
+        """
+        Update op summary op name and step id in NPU+CPU、CPU scenes.
+        """
         _generate_hardware_op_event_step_id(dev_kernels, step_id_to_time_dict)
 
-        if not dev_kernels:
+        if not dev_kernels and self._jit_level != JitLevel.GRAPH_LEVEL:
             logger.warning(
                 "Cannot find the device kernels with MindSpore framework launch op, "
-                "Please verify if it's in graph mode."
             )
             return
 
@@ -190,7 +205,7 @@ class AscendKernelDetailsViewer(BaseViewer):
             else:
                 launch_ops[index] = f"{fwk_langch_op_name}/{dev_kernel_name}"
 
-            if step_id is None and self._is_set_schedule:
+            if step_id is None and self._is_set_schedule and self._jit_level != JitLevel.GRAPH_LEVEL:
                 self._logger.warning(
                     "Can not find step id for dev kernel %s, ts %s",
                     dev_kernel_name,
@@ -203,27 +218,10 @@ class AscendKernelDetailsViewer(BaseViewer):
         self.op_summary[OpSummaryHeaders.OP_NAME.value] = launch_ops
 
         # update op summary step id
-        if self._is_set_schedule:
-            if not self._jit_level == JitLevel.GRAPH_LEVEL:
-                self.op_summary[OpSummaryHeaders.STEP_ID.value] = step_ids
-        self._logger.info("Update kernel name done")
-
+        if self._is_set_schedule and self._jit_level != JitLevel.GRAPH_LEVEL:
+            self.op_summary[OpSummaryHeaders.STEP_ID.value] = step_ids
 
-def _generate_step_id_dict_by_trace_container(trace_container: TraceViewContainer):
-    """
-    Generate the step id to time dict.
-    """
-    # Retrieve all events from the trace container for the Mindspore timeline layer
-    events = trace_container.get_pool_by_name(TimelineLayerName.MINDSPORE.value).get_all_events()
-
-    # Filter events that contain "ProfilerStep" and create a dictionary mapping (start_ts, end_ts) to step ID
-    step_id_to_time_dict = {}
-    for event in events:
-        event_name = event.name
-        if ProfilerStepNameConstant.PROFILER_STEP in event_name:
-            step_id_to_time_dict[event.name.split("#")[-1]] = (event.ts, event.dur + event.ts)
-
-    return step_id_to_time_dict
+        self._logger.info("Update kernel name done")
 
 
 def _generate_hardware_op_event_step_id(hardware_op_events_dict: dict, step_id_to_time_dict: dict):

mindspore/profiler/analysis/viewer/ascend_memory_viewer.py

@@ -19,6 +19,7 @@ from decimal import Decimal
 from mindspore.profiler.analysis.viewer.base_viewer import BaseViewer
 from mindspore.profiler.common.file_manager import FileManager
 from mindspore.profiler.common.log import ProfilerLogger
+from mindspore.profiler.common.constant import ProfilerActivity
 
 
 class MemoryRecordBean:
@@ -167,6 +168,7 @@ class AscendMemoryViewer(BaseViewer):
         self._framework_path = kwargs.get("framework_path")
         self._msprof_profiler_output_path = kwargs.get("msprof_profile_output_path")
         self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
+        self._activities = kwargs.get("activities")
         ProfilerLogger.init(self._ascend_ms_dir)
         self._logger = ProfilerLogger.get_instance()
         self._ge_memory_record = []
@@ -222,6 +224,11 @@ class AscendMemoryViewer(BaseViewer):
 
     def _parse_ms_memory_record(self):
         """Parse mindspore memory record data"""
+
+        # No frame work data is collected when no CPU is passed in activities
+        if ProfilerActivity.CPU.value not in self._activities:
+            return
+
         memory_record_file = os.path.join(
             self._framework_path,
             f"cpu_ms_memory_record_{self._rank_id}.txt",

mindspore/profiler/analysis/viewer/ascend_op_memory_viewer.py

@@ -23,6 +23,7 @@ from abc import ABC
 from mindspore.profiler.parser.ascend_analysis.tlv_decoder import TLVDecoder
 from mindspore.profiler.common.file_manager import FileManager
 from mindspore.profiler.common.log import ProfilerLogger
+from mindspore.profiler.common.constant import ProfilerActivity
 
 
 class OpMemoryIndexEnum(Enum):
@@ -63,7 +64,7 @@ class OpMemoryEvent(BaseEvent):
     FIX_DATA_FORMAT = "<i11QI4B"
     FIX_DATA_SIZE = struct.calcsize(FIX_DATA_FORMAT)
     FREE_VALUE = 18446744073709551615  # 2^64 - 1
-    NAME_KEY = 3
+    NAME_KEY = 13
 
     def __init__(self, data: Dict):
         super().__init__(data)
@@ -192,7 +193,7 @@ class AscendOpMemoryViewer:
         "Device Type",
     ]
     DEVICE_TYPE_FMT = "NPU:{}"
-    NS_TO_US = 1024
+    NS_TO_US = 1000
     BYTES_TO_KB = 1024
     BYTES_TO_MB = 1024 * 1024
     EMPTY_VALUE = "N/A"
@@ -203,6 +204,7 @@ class AscendOpMemoryViewer:
         self._framework_path = kwargs.get("framework_path")
         self._ascend_profiler_output_path = kwargs.get("ascend_profiler_output_path")
         self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
+        self._activities = kwargs.get("activities")
         ProfilerLogger.init(self._ascend_ms_dir)
         self._logger = ProfilerLogger.get_instance()
         self._op_memory_events = None
@@ -214,7 +216,10 @@ class AscendOpMemoryViewer:
         Save step trace time data to csv file
         """
         self._logger.info("AscendOpMemoryViewer start")
-        if not self._enable_profile_memory:
+
+        # No frame work data is collected when no CPU is passed in activities
+        if ProfilerActivity.CPU.value not in self._activities or \
+                not self._enable_profile_memory:
             return
 
         try:

mindspore/profiler/analysis/viewer/ascend_step_trace_time_viewer.py

@@ -17,14 +17,19 @@ import os
 import re
 from decimal import Decimal
 from enum import Enum
-from typing import List, Any, Tuple
+from typing import List, Any, Tuple, Optional
 
 import numpy as np
 
 from mindspore import log as logger
 from mindspore.profiler.analysis.viewer.base_viewer import BaseViewer
 from mindspore.profiler.common.file_manager import FileManager
-from mindspore.profiler.common.constant import TimelineLayerName, OverlapAnalysisTidName, ProfilerLevel
+from mindspore.profiler.common.constant import (
+    TimelineLayerName,
+    OverlapAnalysisTidName,
+    ProfilerLevel,
+    ProfilerActivity
+)
 from mindspore.profiler.analysis.parser.timeline_event.msprof_event import (
     MsprofCompleteEvent,
 )
@@ -60,7 +65,7 @@ class AscendStepTraceTimeViewer(BaseViewer):
     # HCCL Send, Recv op pattern
     PP_OP_PATTERN = (
         # eg: hcom_BatchSendRecv__101_0_1
-        re.compile(r"hcom_\w+SendRecv__\d+"),
+        re.compile(r"^hcom_\w+SendRecv__\d+"),
         # eg: hcom_send__101_0_1
         re.compile(r"hcom_send__\d+"),
         # eg: hcom_receive__101_0_1
@@ -80,9 +85,10 @@ class AscendStepTraceTimeViewer(BaseViewer):
         )
         self._profiler_level = kwargs.get("profiler_level")
         self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
+        self._activities = kwargs.get("activities")
         ProfilerLogger.init(self._ascend_ms_dir)
         self._logger = ProfilerLogger.get_instance()
-        self.step_trace_time_data = {}
+        self.step_trace_time_data_list = []
         self.trace_container: TraceViewContainer = None
         self.hccl_pool: TimelineEventPool = None
         self.overlap_pool: TimelineEventPool = None
@@ -122,7 +128,8 @@ class AscendStepTraceTimeViewer(BaseViewer):
         Write step trace time data to csv file
         """
         self._logger.info("Write step trace time data start")
-        data = [[str(self.step_trace_time_data.get(header, "")) for header in self.STEP_TRACE_TIME_HEADERS]]
+        data = [[str(item.get(header, "")) for header in self.STEP_TRACE_TIME_HEADERS]
+                for item in self.step_trace_time_data_list]
         FileManager.create_csv_file(
             self._save_path,
             data,
@@ -214,29 +221,126 @@ class AscendStepTraceTimeViewer(BaseViewer):
         """
         Calculate step trace time data
         """
-        self.step_trace_time_data[StepTraceTimeHeaders.STEP.value] = "0"
-        self.step_trace_time_data[StepTraceTimeHeaders.COMPUTING.value] = np.sum(self.computing_np["dur"])
-        self.step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION.value] = np.sum(self.communication_np["dur"])
-        self.step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION_NOT_OVERLAPPED.value] = np.sum(
-            self.communication_not_overlapped_np["dur"]
-        )
-        self.step_trace_time_data[StepTraceTimeHeaders.OVERLAPPED.value] = (
-            self.step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION.value]
-            - self.step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION_NOT_OVERLAPPED.value]
-        )
-        self.step_trace_time_data[StepTraceTimeHeaders.FREE.value] = np.sum(self.free_np["dur"])
-        (
-            self.step_trace_time_data[StepTraceTimeHeaders.STAGE.value],
-            self.step_trace_time_data[StepTraceTimeHeaders.BUBBLE.value],
-        ) = self._calculate_stage_bubble()
-
-        self.step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION_NOT_OVERLAPPED_EXCLUDE_RECEIVE.value] = (
-            self.step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION_NOT_OVERLAPPED.value]
-            - self.step_trace_time_data[StepTraceTimeHeaders.BUBBLE.value]
-        )
-        self.step_trace_time_data[StepTraceTimeHeaders.PREPARING.value] = "0"
+        step_id_to_time_dict = self._init_step_dict()
+        self.generate_step_trace_time_data(step_id_to_time_dict)
+
+    def _init_step_dict(self):
+        """
+        Init step list.
+        """
+        return self.trace_container.get_step_id_time_dict() or {0: (Decimal('0'), Decimal('Infinity'))}
+
+    def generate_step_trace_time_data(self, step_id_to_time_dict):
+        """
+        Generate step trace time data
+        """
+        for step_id, (start_time, end_time) in step_id_to_time_dict.items():
+            # step id、computing time、communication time、communication not overlapped time、free time
+            computing_time = self._calculate_event_total_time_by_step(self.computing_np, start_time, end_time)
+            communication_time = self._calculate_event_total_time_by_step(self.communication_np, start_time, end_time)
+            communication_not_over_lapped_time = self._calculate_event_total_time_by_step(
+                self.communication_not_overlapped_np, start_time, end_time)
+            free_time = self._calculate_free_event_total_time_by_step(self.free_np, start_time, end_time)
+            step_trace_time_data = {StepTraceTimeHeaders.STEP.value: step_id,
+                                    StepTraceTimeHeaders.COMPUTING.value: computing_time,
+                                    StepTraceTimeHeaders.COMMUNICATION.value: communication_time,
+                                    StepTraceTimeHeaders.COMMUNICATION_NOT_OVERLAPPED.value:
+                                        communication_not_over_lapped_time,
+                                    StepTraceTimeHeaders.FREE.value: free_time}
+            # overlapped time
+            step_trace_time_data[StepTraceTimeHeaders.OVERLAPPED.value] = (
+                step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION.value]
+                - step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION_NOT_OVERLAPPED.value]
+            )
+            # stage time && bubble time
+            (
+                step_trace_time_data[StepTraceTimeHeaders.STAGE.value],
+                step_trace_time_data[StepTraceTimeHeaders.BUBBLE.value],
+            ) = self._calculate_stage_bubble(start_time, end_time)
+            # communication not overlapped time exclude receive
+            step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION_NOT_OVERLAPPED_EXCLUDE_RECEIVE.value] = (
+                step_trace_time_data[StepTraceTimeHeaders.COMMUNICATION_NOT_OVERLAPPED.value]
+                - step_trace_time_data[StepTraceTimeHeaders.BUBBLE.value]
+            )
+            step_trace_time_data[StepTraceTimeHeaders.PREPARING.value] = self._calculate_prepare_time_by_step(
+                self.computing_np, self.communication_np, start_time, step_id
+            )
+            self.step_trace_time_data_list.append(step_trace_time_data)
+
+    def _calculate_event_total_time_by_step(self, times: np.ndarray, ts: Decimal, es: Decimal) -> Decimal:
+        """
+        Calculate event total time by step.
+        """
+
+        ts_values = times['ts']
+
+        mask = (ts_values >= ts) & (ts_values <= es)
+        filtered_times = times[mask]
+
+        return Decimal(str(filtered_times['dur'].sum())).quantize(Decimal('0.000'))
+
+    def _calculate_free_event_total_time_by_step(self, times: np.ndarray, ts: Decimal, es: Decimal) -> Decimal:
+        """
+        Calculate free event total time by step, with clipping of events that exceed the time range.
+        """
+        start_times = times['ts']
+        durations = times['dur']
+        end_times = start_times + durations
+
+        # Clip start times to ts and end times to es
+        clipped_start_times = np.maximum(start_times, ts)
+        clipped_end_times = np.minimum(end_times, es)
+
+        # Calculate the clipped durations
+        clipped_durations = np.maximum(clipped_end_times - clipped_start_times, Decimal('0.000'))
 
-    def _calculate_stage_bubble(self) -> Tuple[Decimal, Decimal]:
+        return Decimal(sum(clipped_durations)).quantize(Decimal('0.000'))
+
+    def _calculate_event_first_time_by_step(self, times: np.ndarray, ts: Decimal) -> Optional[Decimal]:
+        """
+        Calculate event first time by step.
+        """
+
+        idx = np.searchsorted(times['ts'], ts)
+
+        if idx >= len(times):
+            return None
+
+        return Decimal(str(times['ts'][idx])).quantize(Decimal('0.000'))
+
+    def _calculate_prepare_time_by_step(self, computing_np: np.ndarray, communication_np: np.ndarray,
+                                        ts: Decimal, step_id: int) -> Decimal:
+        """
+        calculate prepare time
+        """
+
+        # No frame work data is collected when no CPU is passed in activities
+        if ProfilerActivity.CPU.value not in self._activities:
+            return Decimal('0.000')
+
+        step_computing_first_time = self._calculate_event_first_time_by_step(computing_np, ts)
+        step_communication_first_time = self._calculate_event_first_time_by_step(communication_np, ts)
+
+        if step_computing_first_time and step_communication_first_time:
+            step_first_device_task_time = min(step_computing_first_time, step_communication_first_time)
+        else:
+            step_first_device_task_time = step_computing_first_time or step_communication_first_time
+
+        if step_first_device_task_time:
+            if ts == Decimal("0"):  # When Profiler.step() is not used
+                fmk_api_events = self.trace_container.get_pool_by_name(
+                    TimelineLayerName.MINDSPORE.value
+                ).get_complete_events()
+                step_host_start_time = min(event.ts for event in fmk_api_events)
+            else:
+                step_host_start_time = ts
+            step_prepare_time = step_first_device_task_time - step_host_start_time
+            return step_prepare_time.quantize(Decimal('0.000'))
+
+        logger.warning(f"Failed to find device task in step {step_id}, set prepare time to 0")
+        return Decimal('0.000')
+
+    def _calculate_stage_bubble(self, ts: Decimal, es: Decimal) -> Tuple[Decimal, Decimal]:
         """
         Calculate stage and bubble time
         """
@@ -244,13 +348,20 @@ class AscendStepTraceTimeViewer(BaseViewer):
             logger.info("HCCL events is empty, skip calculate stage and bubble")
             return Decimal(0), Decimal(0)
 
-        total_hccl_time = self.hccl_events_np["ts"][-1] - self.hccl_events_np["ts"][0]
+        mask = (self.hccl_events_np["ts"] >= ts) & (self.hccl_events_np["ts"] <= es)
+        filtered_hccl_events_np = self.hccl_events_np[mask]
+
+        if filtered_hccl_events_np.size == 0:
+            logger.info("No HCCL events in the given time range, skip calculate stage and bubble")
+            return Decimal(0), Decimal(0)
+
+        total_hccl_time = filtered_hccl_events_np["ts"][-1] - filtered_hccl_events_np["ts"][0]
         bubble_time = np.sum(
-            self.hccl_events_np["dur"][
+            filtered_hccl_events_np["dur"][
                 np.array(
                     [
                         self._is_send_recv_op(name)
-                        for name in self.hccl_events_np["name"]
+                        for name in filtered_hccl_events_np["name"]
                     ]
                 )
             ]

mindspore/profiler/analysis/viewer/ms_dataset_viewer.py

@@ -18,13 +18,12 @@ from collections import defaultdict
 from typing import List, Dict, Any
 
 from mindspore import log as logger
-from mindspore.profiler.common.constant import FileConstant, EventConstant
+from mindspore.profiler.common.constant import FileConstant
 from mindspore.profiler.common.file_manager import FileManager
 from mindspore.profiler.analysis.viewer.base_viewer import BaseViewer
 from mindspore.profiler.analysis.parser.timeline_event.fwk_event import (
     FwkCompleteEvent,
     OpRangeStructField,
-    FwkArgsDecoder
 )
 from mindspore.profiler.common.log import ProfilerLogger
 
@@ -69,10 +68,10 @@ class MsDatasetViewer(BaseViewer):
         """Calculate statistics for dataset operations."""
         dataset_op_data = []
         for data in fwk_tlv_data:
-            if (data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.START_NS.value] <
-                    data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.END_NS.value]):  # dur > 0
-                name = data.get(FwkArgsDecoder.TLV_TYPES.get(EventConstant.OP_NAME), "")
-                if name.split('::')[0] == self._DATASET_OP_PREFIX:
+            if (data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.START_TIME_NS.value] <
+                    data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.END_TIME_NS.value]):  # dur > 0
+                name = data.get(OpRangeStructField.MODULE_GRAPH.value, "")
+                if name == self._DATASET_OP_PREFIX:
                     dataset_op_data.append(FwkCompleteEvent(data))
 
         dataset_op_stats = defaultdict(list)

mindspore/profiler/common/ascend_msprof_exporter.py

@@ -38,6 +38,7 @@ class AscendMsprofExporter:
         self._msprof_profile_output_path = kwargs.get("msprof_profile_output_path")
         self._msprof_profile_path = kwargs.get("msprof_profile_path")
         self._step_list = kwargs.get("step_list")
+        self._export_type = kwargs.get("export_type")
         self._msprof_tool = MsprofCmdTool(self._msprof_profile_path)
 
     def export(self) -> None:
@@ -47,7 +48,7 @@ class AscendMsprofExporter:
             self._single_export(self._step_list)
         else:
             self._all_export()
-        self._msprof_tool.run_ms_analyze_cmd()
+        self._msprof_tool.run_ms_analyze_cmd(self._export_type)
 
     def _single_export(self, step_list: Optional[List[int]]) -> None:
         """Perform single export for each model and iteration.
@@ -63,11 +64,11 @@ class AscendMsprofExporter:
             model_iteration_dict = {self._DEFAULT_MODEL_ID: step_list}
 
         for model_id, iter_list in model_iteration_dict.items():
-            self._msprof_tool.run_ms_py_export_cmd(model_id, iter_list)
+            self._msprof_tool.run_ms_py_export_cmd(model_id, iter_list, self._export_type)
 
     def _all_export(self) -> None:
         """Perform all-export for all data."""
-        self._msprof_tool.run_ms_export_cmd()
+        self._msprof_tool.run_ms_export_cmd(self._export_type)
 
     def _check_drv_version(self) -> bool:
         """Check if the driver version supports all-export.
@@ -99,7 +100,7 @@ class AscendMsprofExporter:
         """
         try:
             # step1: run msprof command
-            self._msprof_tool.run_ms_export_cmd()
+            self._msprof_tool.run_ms_export_cmd(self._export_type)
             step_trace_file = glob.glob(
                 os.path.join(
                     self._msprof_profile_output_path, self._STEP_TRACE_FILE_PATTERN

mindspore/profiler/common/constant.py

@@ -51,6 +51,7 @@ class AicoreMetrics(Enum):
     MemoryUB = "MemoryUB"
     ResourceConflictRatio = "ResourceConflictRatio"
     L2Cache = "L2Cache"
+    MemoryAccess = "MemoryAccess"
     AiCoreNone = "None"
 
 
@@ -137,6 +138,7 @@ class EventConstant:
     TOP_SCOPE_NAMES = ('Default', 'Gradients', 'recompute_Default')
     KERNEL_LAUNCH_KEYWORDS = ("KernelLaunch", "LaunchTask")
     MSTX_KEYWORD = "Mstx"
+    STACK_EVENT_CAT = "python_function"
 
     FLOW_OP = "flow"
     INVALID_FLOW_ID = 18446744073709551615
@@ -198,3 +200,13 @@ class JitLevel:
     KBK_LEVEL = "O0"
     KBK_DVM_LEVEL = "O1"
     GRAPH_LEVEL = "O2"
+
+
+class ExportType(Enum):
+    Db = "db"
+    Text = "text"
+
+
+class CannLibName:
+    """CANN lib name"""
+    CANN_MSPTI = "libmspti.so"