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

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

@@ -0,0 +1,261 @@
+# 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 assembler for Ascend device."""
+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.constant import EventConstant, TimelineLayerName, ProfilerLevel
+from mindspore.profiler.analysis.parser.timeline_event.base_event import BaseEvent
+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_creator.fwk_timeline_creator import FwkTimelineCreator
+from mindspore.profiler.analysis.parser.timeline_creator.cpu_op_timeline_creator import CpuOpTimelineCreator
+from mindspore.profiler.analysis.parser.timeline_creator.msprof_timeline_creator import MsprofTimelineCreator
+from mindspore.profiler.analysis.parser.timeline_assembly_factory.base_timeline_assembler import BaseTimelineAssembler
+from mindspore.profiler.analysis.parser.timeline_creator.scope_layer_timeline_creator import (
+    ScopeLayerTimelineCreator,
+    is_scope_data
+)
+
+
+class AscendTimelineAssembler(BaseTimelineAssembler):
+    """Assembler for Ascend device timeline."""
+
+    def __init__(self, **kwargs):
+        super().__init__()
+        self._profiler_level = kwargs.get("profiler_level")
+        self._context_mode = kwargs.get("context_mode")
+        self._init_creators()
+
+    def _init_creators(self):
+        """Initialize trace creators."""
+        self._fwk_creator = FwkTimelineCreator()
+        self._cpu_op_creator = CpuOpTimelineCreator()
+        self._msprof_creator = MsprofTimelineCreator()
+        self._scope_layer_creator = ScopeLayerTimelineCreator()
+
+    def assemble(self, data: Dict[str, Any]) -> None:
+        """Assemble Ascend timeline from input data."""
+        self._assemble_basic_events(data)
+        self._assemble_flow_events()
+        self._assemble_scope_layer_events()
+
+    def _assemble_basic_events(self, data: Dict[str, Any]) -> None:
+        """Create and add basic events from input data."""
+        self._assemble_events(self._fwk_creator, data.get("mindspore_op_list", []))
+        self._assemble_events(self._cpu_op_creator, data.get("cpu_op_lines", []))
+        self._assemble_events(self._msprof_creator, data.get("msprof_timeline", []))
+
+    def _assemble_scope_layer_events(self) -> None:
+        """Create scope layer events."""
+        scope_data = []
+
+        # Get CPU OP scope data if available
+        cpu_op_pool = self.trace_view_container.get_pool_by_name(TimelineLayerName.CPU_OP.value)
+        if cpu_op_pool:
+            for event in cpu_op_pool.get_complete_events():
+                if is_scope_data(event):
+                    scope_data.append(event)
+
+        # Get Ascend Hardware scope data
+        hardware_pool = self.trace_view_container.get_pool_by_name(TimelineLayerName.ASCEND_HARDWARE.value)
+        if hardware_pool:
+            for event in hardware_pool.get_complete_events():
+                if is_scope_data(event) or is_scope_data(event.parent):
+                    scope_data.append(event)
+
+        if scope_data:
+            self._assemble_events(self._scope_layer_creator, scope_data)
+
+    def _assemble_events(self, creator, data) -> None:
+        """Create events using creator and add to container."""
+        creator.create(data)
+        for pool in creator.get_event_pools().values():
+            self.trace_view_container.add_event_pool(pool)
+        self.trace_view_container.add_trace_events(creator.get_chrome_trace_data())
+
+    def _assemble_flow_events(self) -> None:
+        """Create and add flow events between timelines."""
+        fwk_pool = self.trace_view_container.get_pool_by_name(TimelineLayerName.MINDSPORE.value)
+        if not fwk_pool:
+            return
+
+        # Create and add fwk to fwk flows
+        fwk_to_fwk_flows = self._create_fwk_to_fwk_flow(fwk_pool)
+        self.trace_view_container.add_trace_events(fwk_to_fwk_flows)
+
+        # Create and add fwk to mstx flows
+        for mstx_name in TimelineLayerName.MSTX.value:
+            mstx_pool = self.trace_view_container.get_pool_by_name(mstx_name)
+            if mstx_pool:
+                fwk_to_mstx_flows = self._create_fwk_to_mstx_flow(mstx_pool, fwk_pool)
+                self.trace_view_container.add_trace_events(fwk_to_mstx_flows)
+
+        if self._profiler_level == ProfilerLevel.LevelNone.value:
+            return
+
+        hardware_pool = self.trace_view_container.get_pool_by_name(TimelineLayerName.ASCEND_HARDWARE.value)
+        cann_pool = self.trace_view_container.get_pool_by_name(TimelineLayerName.CANN.value)
+        if not hardware_pool or not cann_pool:
+            return
+
+        # Collect kernel launch events
+        for event in fwk_pool.get_complete_events():
+            if any(keyword in event.name for keyword in EventConstant.KERNEL_LAUNCH_KEYWORDS):
+                self.trace_view_container.kernel_launch_op_event[event.tid].append(event)
+
+        # Create and add fwk to hardware flows
+        fwk_to_hardware_flows = self._create_fwk_to_hardware_flow()
+        self.trace_view_container.add_trace_events(fwk_to_hardware_flows)
+
+    def _create_fwk_to_hardware_flow(self) -> List[Dict]:
+        """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
+        if not acl_to_npu_flow_dict:
+            logger.error("Cannot find connection between CANN layer and Ascend Hardware layer.")
+            return []
+        if not fwk_launch_op_list:
+            logger.warning("Cannot find launch op in MindSpore framework. Please verify if it's in graph mode.")
+            return []
+        if (set(acl_to_npu_flow_dict.keys()) != set(fwk_launch_op_list.keys()) and
+                self._context_mode == context.PYNATIVE_MODE):
+            logger.warning(
+                "The number of launch op threads in MindSpore framework is inconsistent with the CANN layer.")
+
+        fwk_to_npu_flows = []
+        for tid, cann_to_npu_events in acl_to_npu_flow_dict.items():
+            fwk_launch_op_sorted = sorted(fwk_launch_op_list.get(tid, []), key=lambda x: x.ts)
+            acl_to_npu_events_sorted = sorted(cann_to_npu_events.items(), key=lambda x: Decimal(x[0]))
+
+            index = 0
+            for acl_start_time, device_data_list in acl_to_npu_events_sorted:
+                acl_start_time = Decimal(acl_start_time)
+                while index < len(fwk_launch_op_sorted):
+                    fwk_launch_op = fwk_launch_op_sorted[index]
+                    if fwk_launch_op.ts > acl_start_time:
+                        break
+                    if acl_start_time <= fwk_launch_op.te:
+                        for hardware_event in device_data_list:
+                            hardware_event.parent = fwk_launch_op
+                            fwk_launch_op.children.append(hardware_event)
+                            self.trace_view_container.hardware_op_event[hardware_event.tid].append(hardware_event)
+                            fwk_to_npu_flows.extend(
+                                self._create_flow_events(
+                                    fwk_launch_op,
+                                    hardware_event,
+                                    EventConstant.MINDSPORE_NPU_FLOW_NAME,
+                                    EventConstant.MINDSPORE_NPU_FLOW_CAT
+                                )
+                            )
+                        break
+                    index += 1
+
+        return fwk_to_npu_flows
+
+    def _create_fwk_to_fwk_flow(self, framework_pool: TimelineEventPool) -> List[Dict]:
+        """Create flow events between framework events."""
+        fwk_to_fwk_flows = []
+        for flow_id, flow_pair in framework_pool.get_start_to_end_flow_pairs().items():
+            if len(flow_pair["start"]) != 1 or len(flow_pair["end"]) != 1:
+                logger.info(
+                    f"Mindspore op flow expected exactly one start and one end event with flow id {flow_id}, "
+                    f"but got {len(flow_pair['start'])} start and {len(flow_pair['end'])} end events"
+                )
+                continue
+
+            start_event = flow_pair["start"][0]
+            end_event = flow_pair["end"][0]
+            end_event.parent = start_event
+            start_event.children.append(end_event)
+
+            fwk_to_fwk_flows.extend(
+                self._create_flow_events(
+                    start_event,
+                    end_event,
+                    EventConstant.MINDSPORE_SELF_FLOW_NAME,
+                    EventConstant.MINDSPORE_SELF_FLOW_CAT,
+                    flow_id
+                )
+            )
+
+        return fwk_to_fwk_flows
+
+    def _create_fwk_to_mstx_flow(self, mstx_pool: TimelineEventPool, fwk_pool: TimelineEventPool) -> List[Dict]:
+        """Create flow events between framework and mstx events."""
+        fwk_mstx_api_event_group_by_tid = defaultdict(list)
+        for event in fwk_pool.get_complete_events():
+            if EventConstant.MSTX_KEYWORD in event.name:
+                fwk_mstx_api_event_group_by_tid[event.tid].append(event)
+
+        fwk_to_mstx_flows = []
+        mstx_event_group_by_tid = mstx_pool.complete_event
+
+        for tid, mstx_event_list in mstx_event_group_by_tid.items():
+            sorted_fwk_mstx_api_events = sorted(fwk_mstx_api_event_group_by_tid.get(tid, []), key=lambda x: x.ts)
+            sorted_mstx_events = sorted(mstx_event_list, key=lambda x: x.ts)
+
+            index = 0
+            for mstx_event in sorted_mstx_events:
+                while index < len(sorted_fwk_mstx_api_events):
+                    fwk_event = sorted_fwk_mstx_api_events[index]
+                    if mstx_event.ts < fwk_event.ts:
+                        break
+                    if mstx_event.ts <= fwk_event.te:
+                        mstx_event.parent = fwk_event
+                        fwk_event.children.append(mstx_event)
+                        fwk_to_mstx_flows.extend(
+                            self._create_flow_events(
+                                fwk_event,
+                                mstx_event,
+                                EventConstant.MSTX_FLOW_NAME,
+                                EventConstant.MSTX_FLOW_CAT,
+                            )
+                        )
+                        index += 1
+                        break
+                    index += 1
+
+        return fwk_to_mstx_flows
+
+    @staticmethod
+    def _create_flow_events(start_event: BaseEvent, end_event: BaseEvent,
+                            name: str, cat: str, flow_id: str = None) -> List[Dict]:
+        """Create flow start and end events pair."""
+        if flow_id is None:
+            flow_id = str(end_event.ts)
+
+        flow_start = FlowStartEvent({
+            "name": name,
+            "cat": cat,
+            "pid": start_event.pid,
+            "tid": start_event.tid,
+            "ts": start_event.ts,
+            "id": flow_id,
+            "bp": "e"
+        })
+        flow_end = FlowEndEvent({
+            "name": name,
+            "cat": cat,
+            "pid": end_event.pid,
+            "tid": end_event.tid,
+            "ts": end_event.ts,
+            "id": flow_id,
+            "bp": "e"
+        })
+        return [flow_start.to_trace_format(), flow_end.to_trace_format()]

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

@@ -0,0 +1,40 @@
+# 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 timeline assembly process."""
+from abc import ABC, abstractmethod
+from typing import Dict, Any
+
+from mindspore.profiler.analysis.parser.timeline_assembly_factory.trace_view_container import TraceViewContainer
+
+
+class BaseTimelineAssembler(ABC):
+    """Base class for timeline assembly.
+
+    This class defines the basic interface for timeline assembly process. It coordinates
+    different trace event pools and manages the assembly of the final timeline view.
+    """
+
+    def __init__(self):
+        """Initialize timeline assembler."""
+        self.trace_view_container = TraceViewContainer()
+
+    @abstractmethod
+    def assemble(self, data: Dict[str, Any]) -> None:
+        """Assemble timeline from input data.
+
+        Args:
+            data (Dict[str, Any]): Input data containing various timeline information.
+        """
+
+    def get_trace_view_container(self) -> TraceViewContainer:
+        """Get the trace container object."""
+        return self.trace_view_container

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

@@ -0,0 +1,84 @@
+# 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.
+# ============================================================================
+"""Container for managing trace view data and event pools."""
+from typing import Dict, List, Optional
+from collections import defaultdict
+
+from mindspore.profiler.analysis.parser.timeline_event.timeline_event_pool import TimelineEventPool
+from mindspore.profiler.analysis.parser.timeline_event.base_event import BaseEvent
+
+
+class TraceViewContainer:
+    """Container for trace view data and event pools.
+
+    This class is responsible for:
+    1. Storing and managing trace event pools by process ID
+    2. Maintaining process name mappings
+    3. Collecting and managing trace view events
+    4. Providing access to stored pools and events
+    """
+
+    def __init__(self):
+        self.event_pools: Dict[int, TimelineEventPool] = {}
+        self.name_to_pid: Dict[str, int] = {}
+        self.pid_to_name: Dict[int, str] = {}
+        self.trace_view: List[Dict] = []
+        self._kernel_launch_op_dict: Dict[int, List[BaseEvent]] = defaultdict(list)
+        self._hardware_op_event_dict: Dict[int, List[BaseEvent]] = defaultdict(list)
+
+    @property
+    def kernel_launch_op_event(self) -> Dict[int, List[BaseEvent]]:
+        """Get all kernel launch events."""
+        return self._kernel_launch_op_dict
+
+    @property
+    def hardware_op_event(self) -> Dict[int, List[BaseEvent]]:
+        """Get all hardware events."""
+        return self._hardware_op_event_dict
+
+    @kernel_launch_op_event.setter
+    def kernel_launch_op_event(self, value):
+        self._kernel_launch_op_dict = value
+
+    @hardware_op_event.setter
+    def hardware_op_event(self, value):
+        self._hardware_op_event_dict = value
+
+    def add_event_pool(self, pool: TimelineEventPool) -> None:
+        """Add event pool to container."""
+        if pool.name and pool.name in self.name_to_pid:
+            raise ValueError(f"Process name '{pool.name}' already exists.")
+        self.event_pools[pool.pid] = pool
+        if pool.name:
+            self.name_to_pid[pool.name] = pool.pid
+            self.pid_to_name[pool.pid] = pool.name
+
+    def add_trace_events(self, events: List[Dict]) -> None:
+        """Add trace view events."""
+        self.trace_view.extend(events)
+
+    def get_pool_by_pid(self, pid: int) -> Optional[TimelineEventPool]:
+        """Get event pool by process ID."""
+        return self.event_pools.get(pid)
+
+    def get_pool_by_name(self, name: str) -> Optional[TimelineEventPool]:
+        """Get event pool by process name."""
+        pid = self.name_to_pid.get(name)
+        return self.event_pools.get(pid) if pid is not None else None
+
+    def get_trace_view(self) -> List[Dict]:
+        """Get all trace view events."""
+        return self.trace_view
+
+    def get_all_pools(self) -> List[TimelineEventPool]:
+        """Get all event pools."""
+        return list(self.event_pools.values())

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

@@ -0,0 +1,44 @@
+# 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 timeline event creators."""
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any
+
+from mindspore.profiler.analysis.parser.timeline_event.timeline_event_pool import TimelineEventPool
+
+
+class BaseTimelineCreator(ABC):
+    """Base class for creating timeline event pools."""
+
+    def __init__(self):
+        self.event_pools: Dict[int, TimelineEventPool] = {}
+
+    @abstractmethod
+    def create(self, data: Any) -> None:
+        """Create timeline event pools from input data."""
+
+    def get_chrome_trace_data(self) -> List[Dict]:
+        """Get all events in chrome trace format."""
+        if not self.event_pools:
+            return []
+        chrome_trace_data = []
+        for pool in self.event_pools.values():
+            if pool:
+                chrome_trace_data.extend(pool.get_all_events_with_trace_format())
+        return chrome_trace_data
+
+    def get_event_pools(self) -> Dict[int, TimelineEventPool]:
+        """Get all timeline event pools."""
+        return self.event_pools

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_NS.value] == 0:  # Filter abnormal data
+                continue
+            if (data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.START_NS.value] ==
+                    data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.END_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}}))