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

mindspore/profiler/analysis/parser/ms_minddata_parser.py

@@ -0,0 +1,145 @@
+# 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.
+# ============================================================================
+"""mind data parser"""
+import os
+from typing import Dict, Tuple, Optional, Any, List
+from mindspore import log as logger
+from mindspore.profiler.analysis.parser.base_parser import BaseParser
+from mindspore.profiler.common.file_manager import FileManager
+from mindspore.profiler.common.constant import ProfilerActivity
+from mindspore.profiler.common.exceptions.exceptions import (
+    ProfilerPathErrorException,
+    ProfilerRawFileException
+)
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+class MindDataParser(BaseParser):
+    """
+    Parser for MindData profiling information.
+    """
+    _FILE_NAMES = {
+        'pipeline': 'pipeline_profiling_{}.json',
+        'cpu_utilization': 'minddata_cpu_utilization_{}.json',
+        'device_queue': 'device_queue_profiling_{}.txt',
+        'device_iterator': 'dataset_iterator_profiling_{}.txt'
+    }
+
+    def __init__(self, next_parser: Optional[BaseParser] = None, **kwargs):
+        super().__init__(next_parser)
+        self._device_id = kwargs.get("rank_id") if (ProfilerActivity.NPU.value in
+                                                    kwargs.get("activities")) else kwargs.get("device_id")
+        self._output_path = kwargs.get("framework_path")
+        self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
+        ProfilerLogger.init(self._ascend_ms_dir)
+        self._logger = ProfilerLogger.get_instance()
+        self._file_paths = self._setup_file_paths()
+
+    def _setup_file_paths(self) -> Dict[str, str]:
+        return {
+            key: os.path.join(self._output_path, file_name.format(self._device_id))
+            for key, file_name in self._FILE_NAMES.items()
+        }
+
+    def _parse(self, data=None) -> Dict[str, Any]:
+        if data is None:
+            data = {}
+        if not os.path.exists(self._file_paths['pipeline']):
+            logger.info(
+                "pipeline profiling file %s does not exist. Please check whether minddata profiling data should exist.",
+                self._file_paths['pipeline'])
+            return data
+        op_id_info, sample_interval = self._parse_pipeline_info_dict()
+        cpu_util_info = self._parse_cpu_util_info()
+        device_trace_info = self._parse_device_trace()
+        self._logger.info("MindDataParser parse done")
+        data.update({
+            "pipeline_info": (op_id_info, sample_interval),
+            "cpu_util_info": cpu_util_info,
+            "device_trace_info": device_trace_info,
+            "device_queue_file_found": self._device_queue_file_found
+        })
+        return data
+
+    def _parse_pipeline_info_dict(self) -> Tuple[Dict[str, Any], float]:
+        """
+        Parse the pipeline information into a dictionary.
+        Returns:
+            Tuple[Dict[str, Any], float]: A tuple containing the parsed op_info dictionary
+                                          and sampling interval.
+        Raises:
+            ProfilerRawFileException: If the format of the pipeline raw file is incorrect.
+        """
+        pipeline_info = FileManager.read_json_file(self._file_paths['pipeline'])
+        if not pipeline_info:
+            raise ProfilerRawFileException('The minddata pipeline file is empty.')
+
+        sample_interval = pipeline_info.get('sampling_interval')
+        op_info = pipeline_info.get('op_info')
+
+        if sample_interval is None or not op_info:
+            raise ProfilerRawFileException('The format of minddata pipeline raw file is wrong.')
+
+        dict_op_id_info = {
+            item['op_id']: item for item in op_info if item
+        }
+
+        if len(dict_op_id_info) != len(op_info):
+            raise ProfilerRawFileException('The content of minddata pipeline raw file is wrong.')
+
+        return dict_op_id_info, sample_interval
+
+    def _parse_cpu_util_info(self) -> Dict[str, Any]:
+        try:
+            cpu_util_info = FileManager.read_json_file(self._file_paths['cpu_utilization'])
+            if not cpu_util_info:
+                msg = f'The MindData CPU utilization file {self._file_paths["cpu_utilization"]} is empty.'
+                raise RuntimeError(msg)
+        except RuntimeError as err:
+            cpu_util_info = {}
+            logger.warning(f'Failed to read the MindData CPU utilization data. ERROR:{err}')
+        return cpu_util_info
+
+    def _parse_device_trace(self) -> List[Any]:
+        """parse the device trace data"""
+        try:
+            self._device_trace_path, self._device_queue_file_found = self._setup_device_trace()
+            device_trace = FileManager.read_txt_file(self._device_trace_path)
+            if not device_trace:
+                msg = f"The MindData trace profiling file {self._device_trace_path} is empty."
+                raise RuntimeError(msg)
+        except RuntimeError as err:
+            device_trace = []
+            logger.warning(f'Failed to read the MindData device trace data. ERROR:{err}')
+        return device_trace
+
+    def _setup_device_trace(self) -> Tuple[str, bool]:
+        """
+        Set up the device trace file path.
+        Returns:
+            Tuple[str, bool]: A tuple containing the device trace file path and a boolean
+                              indicating whether the device queue file was found.
+        Raises:
+            ProfilerPathErrorException: If no device trace file is found.
+        """
+        queue_path = self._file_paths['device_queue']
+        iterator_path = self._file_paths['device_iterator']
+
+        if os.path.exists(queue_path):
+            return queue_path, True
+        if os.path.exists(iterator_path):
+            return iterator_path, False
+
+        raise ProfilerPathErrorException('A MindData device trace profiling file cannot be found.')

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

@@ -0,0 +1,264 @@
+# 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, JitLevel
+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._jit_level = kwargs.get("jit_level")
+        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
+        # The graph mode O2 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
+        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(
+                "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,106 @@
+# 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
+from mindspore.profiler.common.constant import ProfilerStepNameConstant, TimelineLayerName
+
+
+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())
+
+    def get_step_id_time_dict(self) -> Dict:
+        """Get step id to time dict."""
+        # Retrieve all events from the trace container for the Mindspore timeline layer
+
+        mindspore_pool = self.get_pool_by_name(TimelineLayerName.MINDSPORE.value)
+        if not mindspore_pool:
+            return {}
+
+        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)
+            )
+            for event in events
+            if ProfilerStepNameConstant.PROFILER_STEP in event.name
+        ))
+
+        return step_id_to_time_dict

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