mindspore 2.6.0rc1__cp39-cp39-win_amd64.whl → 2.7.0rc1__cp39-cp39-win_amd64.whl

mindspore/profiler/__init__.py

@@ -28,6 +28,7 @@ __all__ = [
     "ProfilerActivity",
     "AicoreMetrics",
     "ExportType",
+    "HostSystem",
     "DynamicProfilerMonitor",
     "mstx",
     "_ExperimentalConfig",
@@ -39,7 +40,7 @@ from mindspore.profiler.profiler import Profiler
 from mindspore.profiler.profiler import tensorboard_trace_handler
 from mindspore.profiler.schedule import Schedule as schedule
 from mindspore.profiler.envprofiler import EnvProfiler
-from mindspore.profiler.common.constant import ProfilerLevel, ProfilerActivity, AicoreMetrics, ExportType
+from mindspore.profiler.common.constant import ProfilerLevel, ProfilerActivity, AicoreMetrics, ExportType, HostSystem
 from mindspore.profiler.dynamic_profiler import DynamicProfilerMonitor
 from mindspore.profiler.experimental_config import _ExperimentalConfig
 from mindspore.profiler.profiler import Profile as profile

mindspore/profiler/analysis/parser/timeline_assembly_factory/ascend_timeline_assembler.py

@@ -17,8 +17,8 @@ from typing import List, Dict, Any
 from decimal import Decimal
 from collections import defaultdict
 
-from mindspore import context
 from mindspore import log as logger
+from mindspore.profiler.common.log import ProfilerLogger
 from mindspore.profiler.common.constant import EventConstant, TimelineLayerName, ProfilerLevel, JitLevel
 from mindspore.profiler.analysis.parser.timeline_event.base_event import BaseEvent
 from mindspore.profiler.analysis.parser.timeline_event.timeline_event_pool import TimelineEventPool
@@ -39,9 +39,10 @@ class AscendTimelineAssembler(BaseTimelineAssembler):
     def __init__(self, **kwargs):
         super().__init__()
         self._profiler_level = kwargs.get("profiler_level")
-        self._context_mode = kwargs.get("context_mode")
         self._jit_level = kwargs.get("jit_level")
         self._init_creators()
+        ProfilerLogger.init(kwargs.get("ascend_ms_dir"))
+        self._logger = ProfilerLogger.get_instance()
 
     def _init_creators(self):
         """Initialize trace creators."""
@@ -128,17 +129,16 @@ class AscendTimelineAssembler(BaseTimelineAssembler):
         """Create flow events between framework and hardware events."""
         acl_to_npu_flow_dict = self._msprof_creator.get_acl_to_npu_flow_dict()
         fwk_launch_op_list = self.trace_view_container.kernel_launch_op_event
-        # The graph mode O2 does not have the flow from CANN to hardware at each step
+        # The GE backend does not have the flow from CANN to hardware at each step
         if not acl_to_npu_flow_dict and self._jit_level != JitLevel.GRAPH_LEVEL:
             logger.error("Cannot find connection between CANN layer and Ascend Hardware layer.")
             return []
-        # The graph model O2 does not have "KernelLaunch" or "LaunchTask" keywords
+        # The GE backend does not have "KernelLaunch" or "LaunchTask" keywords
         if not fwk_launch_op_list and self._jit_level != JitLevel.GRAPH_LEVEL:
             logger.warning("Cannot find launch op in MindSpore framework.")
             return []
-        if (set(acl_to_npu_flow_dict.keys()) != set(fwk_launch_op_list.keys()) and
-                self._context_mode == context.PYNATIVE_MODE):
-            logger.warning(
+        if set(acl_to_npu_flow_dict.keys()) != set(fwk_launch_op_list.keys()):
+            self._logger.warning(
                 "The number of launch op threads in MindSpore framework is inconsistent with the CANN layer.")
 
         fwk_to_npu_flows = []

mindspore/profiler/analysis/parser/timeline_assembly_factory/base_timeline_assembler.py

@@ -1,3 +1,6 @@
+# Copyright 2025 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #

mindspore/profiler/analysis/parser/timeline_assembly_factory/trace_view_container.py

@@ -1,3 +1,6 @@
+# Copyright 2025 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
@@ -95,12 +98,15 @@ class TraceViewContainer:
         events = mindspore_pool.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 = dict(sorted(
-            (
-                event.name.split("#")[-1], (event.ts, event.dur + event.ts)
+        step_id_to_time_dict = dict(
+            sorted(
+                (
+                    (event.name.split("#")[-1], (event.ts, event.dur + event.ts))
+                    for event in events
+                    if ProfilerStepNameConstant.PROFILER_STEP in event.name
+                ),
+                key=lambda item: item[1][0]
             )
-            for event in events
-            if ProfilerStepNameConstant.PROFILER_STEP in event.name
-        ))
+        )
 
         return step_id_to_time_dict

mindspore/profiler/analysis/parser/timeline_creator/cpu_op_timeline_creator.py

@@ -31,15 +31,15 @@ class CpuOpTimelineCreator(BaseTimelineCreator):
         super().__init__()
         self.scope_data: List[CpuOpCompleteEvent] = []
 
-    def create(self, cpu_info_lines: List[str]) -> None:
+    def create(self, data: List[str]) -> None:
         """Create timeline event pools from CPU info lines."""
-        if not cpu_info_lines:
+        if not data:
             return
 
         pool = TimelineEventPool(EventConstant.CPU_OP_PID)
         self.event_pools[EventConstant.CPU_OP_PID] = pool
 
-        self._create_base_events(pool, cpu_info_lines)
+        self._create_base_events(pool, data)
         self._create_meta_event(pool)
 
     def _create_base_events(self, pool: TimelineEventPool, cpu_info_lines: List[str]) -> None:

mindspore/profiler/analysis/parser/timeline_creator/fwk_timeline_creator.py

@@ -29,15 +29,15 @@ from mindspore.profiler.analysis.parser.timeline_event.fwk_event import (
 class FwkTimelineCreator(BaseTimelineCreator):
     """Create timeline event pools for framework operations."""
 
-    def create(self, fwk_tlv_data: List[Dict]) -> None:
+    def create(self, data: List[Dict]) -> None:
         """Create timeline event pools from framework TLV data."""
-        if not fwk_tlv_data:
+        if not data:
             return
 
         pool = TimelineEventPool(EventConstant.MINDSPORE_PID)
         self.event_pools[EventConstant.MINDSPORE_PID] = pool
 
-        self._create_base_events(pool, fwk_tlv_data)
+        self._create_base_events(pool, data)
         self._create_meta_event(pool)
 
     def _create_base_events(self, pool: TimelineEventPool, fwk_tlv_data: List[Dict]) -> None:

mindspore/profiler/analysis/parser/timeline_creator/msprof_timeline_creator.py

@@ -35,12 +35,12 @@ class MsprofTimelineCreator(BaseTimelineCreator):
         self.msprof_timeline_raw_data = []
         self.acl_to_npu_flow_dict: Dict[int, Dict[str, List[MsprofCompleteEvent]]] = {}
 
-    def create(self, msprof_timeline_data: List[Dict]) -> None:
+    def create(self, data: List[Dict]) -> None:
         """Create timeline event pools from MsProf timeline data."""
-        if not msprof_timeline_data:
+        if not data:
             return
-        self.msprof_timeline_raw_data = msprof_timeline_data
-        flow_dict, complete_event_map = self._create_base_events(msprof_timeline_data)
+        self.msprof_timeline_raw_data = data
+        flow_dict, complete_event_map = self._create_base_events(data)
         self._create_acl_to_npu_flow_dict(flow_dict, complete_event_map)
 
     def _create_base_events(self, msprof_timeline_data: List[Dict]) -> Tuple[Dict, Dict]:

mindspore/profiler/analysis/parser/timeline_creator/scope_layer_timeline_creator.py

@@ -32,15 +32,15 @@ from mindspore.profiler.analysis.parser.timeline_event.scope_layer_event import
 class ScopeLayerTimelineCreator(BaseTimelineCreator):
     """Create timeline event pools for scope layer operations."""
 
-    def create(self, event_list: List[BaseEvent]) -> None:
+    def create(self, data: List[BaseEvent]) -> None:
         """Create timeline event pools from scope layer events."""
-        if not event_list:
+        if not data:
             return
 
         pool = TimelineEventPool(EventConstant.SCOPE_LAYER_PID)
         self.event_pools[EventConstant.SCOPE_LAYER_PID] = pool
 
-        self._create_base_events(pool, event_list)
+        self._create_base_events(pool, data)
         self._create_meta_event(pool)
 
     def _create_base_events(self, pool: TimelineEventPool, event_list: List[BaseEvent]) -> None:

mindspore/profiler/analysis/parser/timeline_event/fwk_event.py

@@ -110,6 +110,7 @@ class ProfilerEvent(Enum):
     PYBOOST_MALLOC_INPUT = "PyBoostMallocInput"
     PYBOOST_MALLOC_OUTPUT = "PyBoostMallocOutput"
     PYBOOST_LAUNCH_ACLLNN = "PyBoostLaunchAclnn"
+    PYBOOST_LAUNCH_ATB = "PyBoostLaunchAtb"
     # pybind api
     PYNATIVE_NEW_GRAPH = "PyNativeNewGraph"
     PYNATIVE_END_GRAPH = "PyNativeEndGraph"
@@ -179,7 +180,9 @@ class FwkProfileDataField:
             The enum value string.
         """
         try:
-            return list(enum_class)[index].value
+            # pylint: disable=protected-access
+            name = enum_class._member_names_[index]
+            return enum_class[name].value
         except IndexError:
             logger.warning(f"Invalid {enum_type} index: {index}")
             return enum_class.DEFAULT.value

mindspore/profiler/analysis/parser/timeline_event/timeline_event_pool.py

@@ -86,7 +86,8 @@ class TimelineEventPool:
             self.start_to_end_events_pairs[flow_key] = {"start": [], "end": []}
         self.start_to_end_events_pairs[flow_key]["end"].append(event)
 
-    def _get_events(self, event_dict: dict) -> List[BaseEvent]:
+    @staticmethod
+    def _get_events(event_dict: dict) -> List[BaseEvent]:
         """Helper function to get events from a dictionary."""
         events = []
         for event_list in event_dict.values():

mindspore/profiler/analysis/task_manager.py

@@ -110,8 +110,8 @@ class TaskManager:
             else workflow
         )
 
+        data = {}
         try:
-            data = {}
             for parser in parsers:
                 parser_start_time = time.perf_counter()
                 data = parser.parse(data)

mindspore/profiler/analysis/viewer/ascend_communication_viewer.py

@@ -352,7 +352,11 @@ class AscendCommunicationViewer(BaseViewer):
                 if bandwidth_msg in add_list:
                     total_bandwidth_info_dict[transport_type][bandwidth_msg] += value
                 if bandwidth_msg in dict_list:
-                    self._combine_size_distribution(value, total_bandwidth_info_dict[transport_type][bandwidth_msg])
+                    self._combine_size_distribution(
+                        value,
+                        total_bandwidth_info_dict.get(transport_type, {})
+                        .get(bandwidth_msg, defaultdict(lambda: [0, 0]))
+                    )
 
     def _compute_time_ratio(self, total_time_info_dict: dict):
         """compute time ratio"""

mindspore/profiler/analysis/viewer/ascend_integrate_viewer.py

@@ -25,7 +25,8 @@ from mindspore.profiler.common.log import ProfilerLogger
 class AscendIntegrateViewer(BaseViewer):
     """Ascend integrate viewer"""
 
-    CSV_PREFIX_NAME = ["l2_cache", "api_statistic", "op_statistic", "static_op_mem"]
+    CSV_PREFIX_NAME = ["l2_cache", "api_statistic", "op_statistic", "static_op_mem",
+                       "hbm", "nic", "roce", "pcie", "hccs"]
     AI_CPU_CSV_PATTERN = "aicpu_[0-9]*.csv"
 
     def __init__(self, **kwargs):

mindspore/profiler/analysis/viewer/ascend_op_memory_viewer.py

@@ -20,10 +20,10 @@ from enum import Enum
 from typing import Any, Dict, List
 from abc import ABC
 
-from mindspore.profiler.parser.ascend_analysis.tlv_decoder import TLVDecoder
+from mindspore.profiler.common.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
+from mindspore.profiler.common.constant import ProfilerActivity, FileConstant
 
 
 class OpMemoryIndexEnum(Enum):
@@ -68,9 +68,7 @@ class OpMemoryEvent(BaseEvent):
 
     def __init__(self, data: Dict):
         super().__init__(data)
-        self.fix_size_data = struct.unpack(
-            self.FIX_DATA_FORMAT, self._origin_data.get("fix_size_bytes")
-        )
+        self.fix_size_data = self._origin_data[FileConstant.FIX_SIZE_DATA]
 
     @property
     def device_id(self):
@@ -237,9 +235,10 @@ class AscendOpMemoryViewer:
         self._logger.info("Read fwk binary file start")
         op_name_file_path = os.path.join(self._framework_path, self.FWK_BINARY_FILE_NAME)
         raw_bin_data = FileManager.read_file_content(op_name_file_path, mode="rb")
-        self._op_memory_events = TLVDecoder.decode(
-            raw_bin_data, OpMemoryEvent, OpMemoryEvent.FIX_DATA_SIZE
+        op_memory_decode_data = TLVDecoder.decode(
+            raw_bin_data, OpMemoryEvent.FIX_DATA_FORMAT, OpMemoryEvent.FIX_DATA_SIZE
         )
+        self._op_memory_events = [OpMemoryEvent(data) for data in op_memory_decode_data]
         self._op_memory_events = sorted(self._op_memory_events, key=lambda x: x.create_at)
         self._logger.info("Read fwk binary file done, %d events", len(self._op_memory_events))
 
@@ -271,21 +270,42 @@ class AscendOpMemoryViewer:
             return []
 
         return [
-            alloc_event.owner, # "Name"
-            alloc_event.size / self.BYTES_TO_KB, # "Size(KB)"
-            alloc_event.create_at / self.NS_TO_US, # "Allocation Time(us)"
-            self.EMPTY_VALUE if free_event is None else free_event.create_at / self.NS_TO_US, # "Release Time(us)"
-            self.EMPTY_VALUE, # "Active Release Time(us)"
-            self.EMPTY_VALUE if free_event is None else (free_event.create_at - alloc_event.create_at) / self.NS_TO_US, # "Duration(us)"
-            self.EMPTY_VALUE, # "Active Duration(us)"
-            alloc_event.alloc_size / self.BYTES_TO_MB, # "Allocation Total Allocated(MB)"
-            alloc_event.used_size / self.BYTES_TO_MB, # "Allocation Total Reserved(MB)"
-            alloc_event.alloc_size / self.BYTES_TO_MB, # "Allocation Total Active(MB)"
-            self.EMPTY_VALUE if free_event is None else free_event.alloc_size / self.BYTES_TO_MB, # "Release Total Allocated(MB)"
-            self.EMPTY_VALUE if free_event is None else free_event.used_size / self.BYTES_TO_MB, # "Release Total Reserved(MB)"
-            self.EMPTY_VALUE if free_event is None else free_event.alloc_size / self.BYTES_TO_MB, # "Release Total Active(MB)"
-            alloc_event.stream_ptr, # "Stream Ptr"
-            self.DEVICE_TYPE_FMT.format(alloc_event.device_id), # "Device Type"
+            alloc_event.owner,  # "Name"
+            alloc_event.size / self.BYTES_TO_KB,  # "Size(KB)"
+            alloc_event.create_at / self.NS_TO_US,  # "Allocation Time(us)"
+            (
+                self.EMPTY_VALUE
+                if free_event is None
+                else free_event.create_at / self.NS_TO_US
+            ),  # "Release Time(us)"
+            self.EMPTY_VALUE,  # "Active Release Time(us)"
+            (
+                self.EMPTY_VALUE
+                if free_event is None
+                else (free_event.create_at - alloc_event.create_at) / self.NS_TO_US
+            ),  # "Duration(us)"
+            self.EMPTY_VALUE,  # "Active Duration(us)"
+            alloc_event.used_size
+            / self.BYTES_TO_MB,  # "Allocation Total Allocated(MB)"
+            alloc_event.alloc_size / self.BYTES_TO_MB,  # "Allocation Total Reserved(MB)"
+            alloc_event.used_size / self.BYTES_TO_MB,  # "Allocation Total Active(MB)"
+            (
+                self.EMPTY_VALUE
+                if free_event is None
+                else free_event.used_size / self.BYTES_TO_MB
+            ),  # "Release Total Allocated(MB)"
+            (
+                self.EMPTY_VALUE
+                if free_event is None
+                else free_event.alloc_size / self.BYTES_TO_MB
+            ),  # "Release Total Reserved(MB)"
+            (
+                self.EMPTY_VALUE
+                if free_event is None
+                else free_event.used_size / self.BYTES_TO_MB
+            ),  # "Release Total Active(MB)"
+            alloc_event.stream_ptr,  # "Stream Ptr"
+            self.DEVICE_TYPE_FMT.format(alloc_event.device_id),  # "Device Type"
         ]
 
     def _get_op_mem_row_data(self, event_list: List[OpMemoryEvent]):

mindspore/profiler/analysis/viewer/ascend_step_trace_time_viewer.py

@@ -260,7 +260,7 @@ class AscendStepTraceTimeViewer(BaseViewer):
             # 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.get(StepTraceTimeHeaders.BUBBLE.value, Decimal('0.000'))
             )
             step_trace_time_data[StepTraceTimeHeaders.PREPARING.value] = self._calculate_prepare_time_by_step(
                 self.computing_np, self.communication_np, start_time, step_id
@@ -355,7 +355,8 @@ class AscendStepTraceTimeViewer(BaseViewer):
             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]
+        total_hccl_time = filtered_hccl_events_np["ts"][-1] - filtered_hccl_events_np["ts"][0] + \
+                          filtered_hccl_events_np["dur"][-1]
         bubble_time = np.sum(
             filtered_hccl_events_np["dur"][
                 np.array(

mindspore/profiler/analysis/viewer/ms_minddata_viewer.py

@@ -367,11 +367,15 @@ class MindDataPiplineSummaryViewer(BaseViewer):
                 raise ProfilerRawFileException('The contents of MindData CPU utilization JSON file is wrong.')
         # Note: The CPU utilization data may have an extra entry with op_id=-1
         # Omit info for op_id=1
-        dict_opid_cpuutil = {
-            op["op_id"]: [op_sys + op_usr for op_sys, op_usr in
-                          zip(op["metrics"]["sys_utilization"], op["metrics"]["user_utilization"])]
-            for op in cpu_op_info if op and op["op_id"] != -1
-        }
+        dict_opid_cpuutil = {}
+        for op in cpu_op_info:
+            if not op or op["op_id"] == -1:
+                continue
+            cpu_utilization = []
+            for op_sys, op_usr in zip(op["metrics"]["sys_utilization"], op["metrics"]["user_utilization"]):
+                cpu_utilization.append(op_sys + op_usr)
+            dict_opid_cpuutil[op["op_id"]] = cpu_utilization
+
         # Initialize oplist_avg_cpu_pct with -1 for each pipeline op, since
         # CPU utilization data may not have information for each pipeline op
         oplist_avg_cpu_pct = [-1] * len(dict_opid_cpuutil)

mindspore/profiler/analysis/viewer/ms_operator_details_viewer.py

@@ -0,0 +1,132 @@
+# Copyright 2025 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""ms operator details viewer"""
+import os
+import struct
+from abc import ABC
+from enum import Enum
+from typing import Dict, Any
+
+from mindspore.profiler.common.file_manager import FileManager
+from mindspore.profiler.analysis.viewer.base_viewer import BaseViewer
+from mindspore.profiler.common.tlv_decoder import TLVDecoder
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+class OperatorDetailsIndexEnum(Enum):
+    """Operator details index defining."""
+
+    NAME = 0
+    INPUT_SHAPES = 1
+    INPUT_TYPE = 2
+
+
+class BaseEvent(ABC):
+    """Base class for all event types."""
+
+    def __init__(self, data: Dict):
+        if not isinstance(data, dict):
+            raise TypeError("Input data must be dict.")
+        self._origin_data = data
+
+
+class OperatorDetailsEvent(BaseEvent):
+    """Operator details event."""
+
+    FIX_DATA_FORMAT = ""
+    FIX_DATA_SIZE = struct.calcsize(FIX_DATA_FORMAT)
+
+    @property
+    def name(self):
+        """Get name."""
+        return self._origin_data.get(OperatorDetailsIndexEnum.NAME.value, "")
+
+    @property
+    def input_shapes(self):
+        """Get input_shapes."""
+        return self._origin_data.get(OperatorDetailsIndexEnum.INPUT_SHAPES.value, "")
+
+    @property
+    def input_type(self):
+        """Get input_type."""
+        return self._origin_data.get(OperatorDetailsIndexEnum.INPUT_TYPE.value, "")
+
+
+class MsOperatorDetailsViewer(BaseViewer):
+    """Viewer for MindSpore operator_details profiling data."""
+
+    FWK_BINARY_FILE_NAME = "mindspore.record_shapes"
+    _OPERATOR_DETAILS_FILE_NAME = 'operator_details.csv'
+    _COL_NAMES = ['Name', 'Input Shapes']
+
+    def __init__(self, **kwargs):
+        super().__init__()
+        self._save_path = os.path.join(
+            kwargs.get("ascend_profiler_output_path"),
+            self._OPERATOR_DETAILS_FILE_NAME
+        )
+        self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
+        self._framework_path = kwargs.get("framework_path")
+        ProfilerLogger.init(self._ascend_ms_dir)
+        self._logger = ProfilerLogger.get_instance()
+
+    def save(self, data: Dict[str, Any]) -> None:
+        """Process and save operator_details profiling data."""
+        self._logger.info("MsOperatorDetailsViewer start")
+        try:
+            file_exist = self._read_fwk_binary_file()
+            if not file_exist:
+                return
+            self._calculate_operator_details_data()
+            self._write_data()
+        except Exception as e: # pylint: disable=W0703
+            self._logger.error("Failed to save operator_details.csv: %s", e, exc_info=True)
+        self._logger.info("MsOperatorDetailsViewer end")
+
+    def _read_fwk_binary_file(self):
+        """
+        Read fwk binary file
+        """
+        self._logger.info("Read fwk binary file start")
+        fwk_file_path = os.path.join(self._framework_path, self.FWK_BINARY_FILE_NAME)
+        if not os.path.isfile(fwk_file_path):
+            self._logger.warning("Fwk binary file %s does not exist.", fwk_file_path)
+            return False
+        raw_bin_data = FileManager.read_file_content(fwk_file_path, mode="rb")
+        operator_details_decode_data = TLVDecoder.decode(
+            raw_bin_data, OperatorDetailsEvent.FIX_DATA_FORMAT, OperatorDetailsEvent.FIX_DATA_SIZE
+        )
+        self._operator_details_events = [OperatorDetailsEvent(data) for data in operator_details_decode_data]
+        self._logger.info("Read fwk binary file done, %d events", len(self._operator_details_events))
+        return True
+
+    def _calculate_operator_details_data(self):
+        """
+        Calculate operator details data
+        """
+        self._operator_details_data = [
+            [event.name, event.input_shapes]
+            for event in self._operator_details_events
+        ]
+
+    def _write_data(self) -> None:
+        """
+        Save operator statistics to a CSV file
+        """
+        if not self._operator_details_data:
+            return
+        self._logger.info("Save operator statistics start")
+        FileManager.create_csv_file(self._save_path, self._operator_details_data, self._COL_NAMES)
+        self._logger.info("Save operator statistics done")

mindspore/profiler/common/constant.py

@@ -186,6 +186,8 @@ class TimelineLayerName(Enum):
     ACC_PMU = "Acc PMU"
     SIO = "SIO"
     QOS = "QoS"
+    NIC = "NIC"
+    ROCE = "RoCE"
     OVERLAP_ANALYSIS = "Overlap Analysis"
 
 
@@ -210,3 +212,17 @@ class ExportType(Enum):
 class CannLibName:
     """CANN lib name"""
     CANN_MSPTI = "libmspti.so"
+
+
+class DynoMode:
+    """dyno mode"""
+    DYNO_DAEMON = "MSMONITOR_USE_DAEMON"
+
+
+class HostSystem(Enum):
+    """host system"""
+    CPU = "cpu"
+    MEM = "mem"
+    DISK = "disk"
+    NETWORK = "network"
+    OSRT = "osrt"