mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0__cp39-cp39-win_amd64.whl

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

@@ -0,0 +1,90 @@
+# Copyright 2024 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.
+# ============================================================================
+"""Timeline creator for CPU operations."""
+from typing import List
+
+from mindspore import log as logger
+from mindspore.profiler.common.constant import EventConstant
+from mindspore.profiler.common.constant import TimelineLayerName
+from mindspore.profiler.analysis.parser.timeline_creator.base_timeline_creator import BaseTimelineCreator
+from mindspore.profiler.analysis.parser.timeline_event.timeline_event_pool import TimelineEventPool
+from mindspore.profiler.analysis.parser.timeline_event.cpu_op_event import CpuOpCompleteEvent
+from mindspore.profiler.analysis.parser.timeline_event.cpu_op_event import CpuOpMetaEvent
+
+
+class CpuOpTimelineCreator(BaseTimelineCreator):
+    """Create timeline event pools for CPU operations."""
+
+    def __init__(self):
+        super().__init__()
+        self.scope_data: List[CpuOpCompleteEvent] = []
+
+    def create(self, cpu_info_lines: List[str]) -> None:
+        """Create timeline event pools from CPU info lines."""
+        if not cpu_info_lines:
+            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_meta_event(pool)
+
+    def _create_base_events(self, pool: TimelineEventPool, cpu_info_lines: List[str]) -> None:
+        """Create base events from CPU info lines."""
+        for line in cpu_info_lines:
+            line = line.strip()
+            if not line:
+                continue
+
+            op_list = line.split(';')
+            if len(op_list) < 3:
+                logger.warning(f"Invalid CPU info format, expected at least 3 fields but got {len(op_list)}: {line}")
+                continue
+
+            op_full_name, op_type, time_info = op_list[0], op_list[1], op_list[-1]
+
+            for time in time_info.split():
+                time_parts = time.split(',')
+                if len(time_parts) != 3:
+                    logger.warning(f"Invalid time info format, expected 3 fields but got {len(time_parts)}: {time}")
+                    continue
+
+                start_time, dur, tid = time_parts
+                event = CpuOpCompleteEvent({
+                    'name': op_full_name,
+                    'tid': int(tid),
+                    'ts': str(start_time),
+                    'dur': str(dur),
+                    'args': {'type': op_type}
+                })
+                pool.add_event(event)
+
+    @staticmethod
+    def _create_meta_event(pool: TimelineEventPool) -> None:
+        """Create meta events for CPU operations."""
+        process_meta_name_and_args = [
+            (EventConstant.PROCESS_NAME, {"name": TimelineLayerName.CPU_OP.value}),
+            (EventConstant.PROCESS_SORT, {"sort_index": EventConstant.CPU_OP_SORT_IDX}),
+            (EventConstant.PROCESS_LABEL, {"labels": EventConstant.CPU_LABEL})
+        ]
+        for name, args in process_meta_name_and_args:
+            pool.add_event(CpuOpMetaEvent({"name": name, "tid": 0, "args": args}))
+
+        for tid in pool.get_all_tids():
+            pool.add_event(CpuOpMetaEvent({"name": EventConstant.THREAD_NAME, "tid": tid,
+                                           "args": {"name": f"Thread {tid}"}}))
+            pool.add_event(CpuOpMetaEvent({"name": EventConstant.THREAD_SORT, "tid": tid,
+                                           "args": {"sort_index": tid}}))

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

@@ -0,0 +1,76 @@
+# Copyright 2024 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.
+# ============================================================================
+"""Timeline creator for framework operations."""
+from typing import List, Dict
+
+from mindspore.profiler.common.constant import EventConstant, FileConstant, TimelineLayerName
+from mindspore.profiler.analysis.parser.timeline_event.timeline_event_pool import TimelineEventPool
+from mindspore.profiler.analysis.parser.timeline_creator.base_timeline_creator import BaseTimelineCreator
+from mindspore.profiler.analysis.parser.timeline_event.fwk_event import (
+    FwkCompleteEvent,
+    FwkInstantEvent,
+    OpRangeStructField,
+    FwkMetaEvent
+)
+
+
+class FwkTimelineCreator(BaseTimelineCreator):
+    """Create timeline event pools for framework operations."""
+
+    def create(self, fwk_tlv_data: List[Dict]) -> None:
+        """Create timeline event pools from framework TLV data."""
+        if not fwk_tlv_data:
+            return
+
+        pool = TimelineEventPool(EventConstant.MINDSPORE_PID)
+        self.event_pools[EventConstant.MINDSPORE_PID] = pool
+
+        self._create_base_events(pool, fwk_tlv_data)
+        self._create_meta_event(pool)
+
+    def _create_base_events(self, pool: TimelineEventPool, fwk_tlv_data: List[Dict]) -> None:
+        """Create base events from framework TLV data."""
+        for data in fwk_tlv_data:
+            if data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.START_TIME_NS.value] == 0:  # Filter abnormal data
+                continue
+            if (data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.START_TIME_NS.value] ==
+                    data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.END_TIME_NS.value]):  # dur == 0
+                event = FwkInstantEvent(data)
+            else:
+                event = FwkCompleteEvent(data)
+                if event.name == EventConstant.FLOW_OP:
+                    pool.add_start_event(str(event.id), event)
+                    continue
+                if event.id != EventConstant.INVALID_FLOW_ID:
+                    pool.add_end_event(str(event.id), event)
+            pool.add_event(event)
+
+    @staticmethod
+    def _create_meta_event(pool: TimelineEventPool) -> None:
+        """Create meta events for framework operations."""
+        process_meta_events = [
+            (EventConstant.PROCESS_NAME, {"name": TimelineLayerName.MINDSPORE.value}),
+            (EventConstant.PROCESS_SORT, {"sort_index": EventConstant.MINDSPORE_SORT_IDX}),
+            (EventConstant.PROCESS_LABEL, {"labels": EventConstant.CPU_LABEL})
+        ]
+
+        for name, args in process_meta_events:
+            pool.add_event(FwkMetaEvent({"name": name, "tid": 0, "args": args}))
+
+        for tid in pool.get_all_tids():
+            pool.add_event(FwkMetaEvent({"name": EventConstant.THREAD_NAME, "tid": tid,
+                                         "args": {"name": f"Thread {tid}"}}))
+            pool.add_event(FwkMetaEvent({"name": EventConstant.THREAD_SORT, "tid": tid,
+                                         "args": {"sort_index": tid}}))

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

@@ -0,0 +1,103 @@
+# Copyright 2024 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.
+# ============================================================================
+"""Timeline creator for MsProf operations."""
+from typing import List, Dict, Tuple
+
+from mindspore import log as logger
+from mindspore.profiler.common.constant import EventConstant
+from mindspore.profiler.analysis.parser.timeline_creator.base_timeline_creator import BaseTimelineCreator
+from mindspore.profiler.analysis.parser.timeline_event.timeline_event_pool import TimelineEventPool
+from mindspore.profiler.analysis.parser.timeline_event.flow_event import FlowStartEvent, FlowEndEvent
+from mindspore.profiler.analysis.parser.timeline_event.msprof_event import (
+    MsprofMetaEvent,
+    MsprofCompleteEvent,
+    MsprofInstantEvent,
+)
+
+
+class MsprofTimelineCreator(BaseTimelineCreator):
+    """Create timeline event pools for MsProf operations."""
+
+    def __init__(self):
+        super().__init__()
+        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:
+        """Create timeline event pools from MsProf timeline data."""
+        if not msprof_timeline_data:
+            return
+        self.msprof_timeline_raw_data = msprof_timeline_data
+        flow_dict, complete_event_map = self._create_base_events(msprof_timeline_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]:
+        """Create base events from MsProf timeline data."""
+        flow_dict = {}
+        complete_event_map = {}
+
+        for data in msprof_timeline_data:
+            pid = data.get("pid", 0)
+            pool = self.event_pools.get(pid)
+            if pool is None:
+                pool = TimelineEventPool(pid)
+                self.event_pools[pid] = pool
+
+            if data.get("cat") == EventConstant.HOST_TO_DEVICE_FLOW_CAT:
+                if data.get("ph") == EventConstant.START_FLOW:
+                    event = FlowStartEvent(data)
+                    flow_dict.setdefault(event.flow_id, {}).setdefault("start", event)
+                elif data.get("ph") == EventConstant.END_FLOW:
+                    event = FlowEndEvent(data)
+                    flow_dict.setdefault(event.flow_id, {}).setdefault("end", event)
+            elif data.get("ph") == EventConstant.COMPLETE_EVENT:
+                event = MsprofCompleteEvent(data)
+                complete_event_map[event.unique_id] = event
+                pool.add_event(event)
+            elif data.get("ph") == EventConstant.INSTANT_EVENT:
+                event = MsprofInstantEvent(data)
+                pool.add_event(event)
+            elif data.get("ph") == EventConstant.META_EVENT:
+                event = MsprofMetaEvent(data)
+                pool.add_event(event)
+
+        return flow_dict, complete_event_map
+
+    def _create_acl_to_npu_flow_dict(self, flow_dict: Dict, complete_event_map: Dict) -> None:
+        """Create flow events from flow dictionary."""
+        for flow in flow_dict.values():
+            flow_start = flow.get("start")
+            flow_end = flow.get("end")
+            if flow_start and flow_end:
+                hardware_event = complete_event_map.get(flow_end.unique_id)
+                if not hardware_event:
+                    logger.warning(
+                        f"Failed to find hardware event for flow end event. "
+                        f"Flow ID: {flow_end.flow_id}, Unique ID: {flow_end.unique_id}"
+                    )
+                    continue
+                (
+                    self.acl_to_npu_flow_dict.setdefault(flow_start.tid, {})
+                    .setdefault(str(flow_start.ts), [])
+                    .append(hardware_event)
+                )
+
+    def get_acl_to_npu_flow_dict(self) -> Dict[int, Dict[str, List[MsprofCompleteEvent]]]:
+        """Return the CANN to NPU flow dictionary."""
+        return self.acl_to_npu_flow_dict
+
+    def get_chrome_trace_data(self) -> List[Dict]:
+        """Return the chrome trace events."""
+        return self.msprof_timeline_raw_data

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

@@ -0,0 +1,134 @@
+# Copyright 2024 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.
+# ============================================================================
+"""Timeline creator for scope layer operations."""
+from decimal import Decimal
+from typing import List, Tuple, Optional
+
+from mindspore.profiler.common.constant import EventConstant, TimelineLayerName
+from mindspore.profiler.analysis.parser.timeline_event.fwk_event import FwkCompleteEvent
+from mindspore.profiler.analysis.parser.timeline_event.cpu_op_event import CpuOpCompleteEvent
+from mindspore.profiler.analysis.parser.timeline_event.base_event import BaseEvent, CompleteEvent
+from mindspore.profiler.analysis.parser.timeline_event.timeline_event_pool import TimelineEventPool
+from mindspore.profiler.analysis.parser.timeline_creator.base_timeline_creator import BaseTimelineCreator
+from mindspore.profiler.analysis.parser.timeline_event.msprof_event import MsprofCompleteEvent
+from mindspore.profiler.analysis.parser.timeline_event.scope_layer_event import (
+    ScopeLayerCompleteEvent,
+    ScopeLayerMetaEvent
+)
+
+
+class ScopeLayerTimelineCreator(BaseTimelineCreator):
+    """Create timeline event pools for scope layer operations."""
+
+    def create(self, event_list: List[BaseEvent]) -> None:
+        """Create timeline event pools from scope layer events."""
+        if not event_list:
+            return
+
+        pool = TimelineEventPool(EventConstant.SCOPE_LAYER_PID)
+        self.event_pools[EventConstant.SCOPE_LAYER_PID] = pool
+
+        self._create_base_events(pool, event_list)
+        self._create_meta_event(pool)
+
+    def _create_base_events(self, pool: TimelineEventPool, event_list: List[BaseEvent]) -> None:
+        """Create base events from scope layer events."""
+        event_list.sort(key=lambda x: x.ts)
+        layers = []
+
+        for event in event_list:
+            scope_data = self._parse_scope_data(event)
+            if not scope_data:
+                continue
+            scope_names, start_time, dur_time = scope_data
+            end_time = start_time + dur_time
+            if layers and start_time < layers[0].ts + layers[0].dur:
+                continue  # Skip parallel operators, keep only the first one
+
+            merge = True  # Flag to control merging of upper layers
+            for layer_depth, layer_name in enumerate(scope_names):
+                if layer_depth >= len(layers):
+                    layers.append(ScopeLayerCompleteEvent(
+                        {"name": layer_name, "tid": layer_depth, "ts": start_time, "dur": dur_time}))
+                    continue
+                if merge and layers[layer_depth].name == layer_name:
+                    layers[layer_depth].dur = end_time - layers[layer_depth].ts
+                else:
+                    pool.add_event(layers[layer_depth])
+                    layers[layer_depth] = ScopeLayerCompleteEvent(
+                        {"name": layer_name, "tid": layer_depth, "ts": start_time, "dur": dur_time})
+                    merge = False
+
+        # Add remaining layers to pool
+        for layer in layers:
+            pool.add_event(layer)
+
+    @staticmethod
+    def _parse_scope_data(event: CompleteEvent) -> Optional[Tuple[List[str], Decimal, Decimal]]:
+        """Parse scope names and timing from event.
+
+        Args:
+            event (CompleteEvent): Event to parse.
+
+        Returns:
+            Optional[Tuple[List[str], Decimal, Decimal]]: Scope names, start time and duration.
+        """
+        if hasattr(event, 'parent') and event.parent:
+            event_scope_name = event.name.split("/")[:-1]
+            parent_scope_name = event.parent.name.split("::")[-1].split("/")[:-1]
+            if event_scope_name and parent_scope_name:
+                scope_name = (
+                    parent_scope_name
+                    if len(parent_scope_name) > len(event_scope_name)
+                    else event_scope_name
+                )
+            else:
+                scope_name = event_scope_name or parent_scope_name
+        else:
+            scope_name = event.name.split("/")[:-1]
+
+        if scope_name:
+            return scope_name, event.ts, event.dur
+        return None
+
+    @staticmethod
+    def _create_meta_event(pool: TimelineEventPool) -> None:
+        """Create meta events for scope layer."""
+        process_meta_events = [
+            (EventConstant.PROCESS_NAME, {"name": TimelineLayerName.SCOPER_LAYER.value}),
+            (EventConstant.PROCESS_SORT, {"sort_index": EventConstant.SCOPE_LAYER_SORT_IDX})
+        ]
+
+        for name, args in process_meta_events:
+            pool.add_event(ScopeLayerMetaEvent({"name": name, "tid": 0, "args": args}))
+
+        for tid in pool.get_all_tids():
+            pool.add_event(ScopeLayerMetaEvent({"name": EventConstant.THREAD_NAME, "tid": tid,
+                                                "args": {"name": f"Thread {tid}"}}))
+            pool.add_event(ScopeLayerMetaEvent({"name": EventConstant.THREAD_SORT, "tid": tid,
+                                                "args": {"sort_index": tid}}))
+
+
+def is_scope_data(event: BaseEvent) -> bool:
+    """Check if event is scope data."""
+    if isinstance(event, (CpuOpCompleteEvent, MsprofCompleteEvent)):
+        scope_full_name = event.name
+        return scope_full_name and scope_full_name.startswith(EventConstant.TOP_SCOPE_NAMES)
+
+    if isinstance(event, FwkCompleteEvent):
+        scope_full_name = event.name.split("::")[-1]
+        return scope_full_name and scope_full_name.startswith(EventConstant.TOP_SCOPE_NAMES)
+
+    return False

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

@@ -0,0 +1,233 @@
+# Copyright 2024 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.
+# ============================================================================
+"""Base class for all event types."""
+from decimal import Decimal
+from typing import Dict
+from abc import ABC, abstractmethod
+
+from mindspore.profiler.common.constant import EventConstant
+
+
+class BaseEvent(ABC):
+    """Base class for all event types."""
+
+    def __init__(self, data: Dict):
+        """Initialize base event with data dictionary."""
+        if not isinstance(data, dict):
+            raise TypeError("Input data must be dict.")
+        self._origin_data = data
+
+    @property
+    def ph(self) -> str:
+        """Get event phase."""
+        raise NotImplementedError
+
+    @property
+    def origin_data(self) -> Dict:
+        """Get original event data."""
+        return self._origin_data
+
+    @property
+    def pid(self) -> int:
+        """Get process ID."""
+        return int(self._origin_data.get("pid", 0))
+
+    @property
+    def tid(self) -> int:
+        """Get thread ID."""
+        return int(self._origin_data.get("tid", 0))
+
+    @property
+    def name(self) -> str:
+        """Get event name."""
+        return self._origin_data.get("name", "")
+
+    @abstractmethod
+    def to_trace_format(self) -> dict:
+        """Convert event to Chrome trace format."""
+        raise NotImplementedError
+
+
+class MetaEvent(BaseEvent):
+    """Metadata event class."""
+
+    @property
+    def ph(self) -> str:
+        """Get event phase (M for metadata)."""
+        return EventConstant.META_EVENT
+
+    @property
+    def args(self) -> dict:
+        """Get event arguments."""
+        return self._origin_data.get("args", {})
+
+    def to_trace_format(self) -> dict:
+        """Convert metadata event to Chrome trace format."""
+        return {
+            "ph": self.ph,
+            "name": self.name,
+            "pid": self.pid,
+            "tid": self.tid,
+            "args": self.args
+        }
+
+
+class CompleteEvent(BaseEvent):
+    """Complete event class."""
+
+    @property
+    def ph(self) -> str:
+        """Get event phase (X for complete)."""
+        return EventConstant.COMPLETE_EVENT
+
+    @property
+    def ts(self) -> Decimal:
+        """Get event start timestamp."""
+        return Decimal(self._origin_data.get("ts", 0))
+
+    @property
+    def dur(self) -> Decimal:
+        """Get event duration."""
+        return Decimal(self._origin_data.get("dur", 0))
+
+    @property
+    def cat(self) -> str:
+        """Get event category."""
+        return str(self._origin_data.get("cat", ""))
+
+    @property
+    def args(self) -> dict:
+        """Get event arguments."""
+        return self._origin_data.get("args", {})
+
+    @property
+    def unique_id(self) -> str:
+        """Get unique id"""
+        return f"{self.pid}-{self.tid}-{self.ts}"
+
+    def to_trace_format(self) -> dict:
+        """Convert complete event to Chrome trace format."""
+        return {
+            "ph": self.ph,
+            "name": self.name,
+            "pid": self.pid,
+            "tid": self.tid,
+            "ts": str(self.ts),
+            "dur": str(self.dur),
+            "cat": self.cat,
+            "args": self.args
+        }
+
+
+class InstantEvent(BaseEvent):
+    """Instant event class."""
+
+    @property
+    def ph(self) -> str:
+        """Get event phase (i for instant)."""
+        return EventConstant.INSTANT_EVENT
+
+    @property
+    def ts(self) -> Decimal:
+        """Get event timestamp."""
+        return Decimal(self._origin_data.get("ts", 0))
+
+    @property
+    def args(self) -> dict:
+        """Get event arguments."""
+        return self._origin_data.get("args", {})
+
+    def to_trace_format(self) -> dict:
+        """Convert instant event to Chrome trace format."""
+        return {
+            "name": self.name,
+            "ph": self.ph,
+            "ts": str(self.ts),
+            "pid": self.pid,
+            "tid": self.tid,
+            "args": self.args
+        }
+
+
+class CounterEvent(BaseEvent):
+    """Counter event class."""
+
+    @property
+    def ph(self) -> str:
+        """Get event phase (C for counter)."""
+        return EventConstant.COUNTER_EVENT
+
+    @property
+    def ts(self) -> Decimal:
+        """Get event timestamp."""
+        return Decimal(self._origin_data.get("ts", 0))
+
+    @property
+    def args(self) -> dict:
+        """Get event arguments."""
+        return self._origin_data.get("args", {})
+
+    def to_trace_format(self) -> dict:
+        """Convert counter event to Chrome trace format."""
+        return {
+            "name": self.name,
+            "ph": self.ph,
+            "ts": str(self.ts),
+            "pid": self.pid,
+            "tid": self.tid,
+            "args": self.args
+        }
+
+
+class FlowEvent(BaseEvent):
+    """Flow event class."""
+
+    @property
+    def ph(self) -> str:
+        """Get event phase (s/t/f for flow start/step/end)."""
+        raise NotImplementedError
+
+    @property
+    def flow_id(self) -> str:
+        """Get flow identifier."""
+        return self._origin_data.get("id", "")
+
+    @property
+    def ts(self) -> Decimal:
+        """Get event timestamp."""
+        return Decimal(self._origin_data.get("ts", 0))
+
+    @property
+    def cat(self) -> str:
+        """Get event category."""
+        return str(self._origin_data.get("cat", ""))
+
+    @property
+    def unique_id(self) -> str:
+        """Get unique id"""
+        return f"{self.pid}-{self.tid}-{self.ts}"
+
+    def to_trace_format(self) -> dict:
+        """Convert flow event to Chrome trace format."""
+        return {
+            "name": self.name,
+            "bp": "e",
+            "ph": self.ph,
+            "ts": str(self.ts),
+            "pid": self.pid,
+            "tid": self.tid,
+            "id": self.flow_id,
+            "cat": self.cat
+        }

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

@@ -0,0 +1,47 @@
+# Copyright 2024 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.
+# ============================================================================"""
+"""CPU event class."""
+from decimal import Decimal
+
+from mindspore.profiler.common.constant import TimeConstant, EventConstant
+from mindspore.profiler.analysis.parser.timeline_event.base_event import CompleteEvent, MetaEvent
+
+
+class CpuOpCompleteEvent(CompleteEvent):
+    """CPU Complete(X) event class for representing CPU operations."""
+
+    @property
+    def ts(self) -> Decimal:
+        """Get timestamp in microseconds, converting from nanoseconds."""
+        return (Decimal(self._origin_data.get("ts", 0)) * Decimal(TimeConstant.NS_TO_US)).quantize(Decimal('0.000'))
+
+    @property
+    def dur(self) -> Decimal:
+        """Get duration in microseconds, converting from milliseconds."""
+        return (Decimal(self._origin_data.get("dur", 0)) * Decimal(TimeConstant.MS_TO_US)).quantize(Decimal('0.000'))
+
+    @property
+    def pid(self) -> int:
+        """Get CPU operation process ID."""
+        return int(EventConstant.CPU_OP_PID)
+
+
+class CpuOpMetaEvent(MetaEvent):
+    """CPU Meta(M) event class for CPU operation metadata."""
+
+    @property
+    def pid(self) -> int:
+        """Get CPU operation process ID."""
+        return int(EventConstant.CPU_OP_PID)