mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

mindspore/profiler/parser/ascend_analysis/file_manager.py

@@ -0,0 +1,159 @@
+# Copyright 2023 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.
+# ============================================================================
+"""Profiler file manager"""
+import csv
+import json
+import os.path
+from typing import List
+
+from mindspore import log as logger
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+
+
+class FileManager:
+    """Profiler file manager"""
+
+    MAX_PATH_LENGTH = 4096
+    MAX_FILE_NAME_LENGTH = 255
+    DATA_FILE_AUTHORITY = 0o640
+    DATA_DIR_AUTHORITY = 0o700
+
+    @classmethod
+    def read_file_content(cls, path: str, mode: str = "r"):
+        """Read the content in the input file."""
+        if not os.access(path, os.R_OK):
+            msg = f"The file {os.path.basename(path)} is not readable!"
+            raise RuntimeError(msg)
+
+        if not os.path.isfile(path):
+            raise RuntimeError(f"The file {os.path.basename(path)} is invalid!")
+        file_size = os.path.getsize(path)
+        if file_size <= 0:
+            return ""
+        if file_size > Constant.MAX_FILE_SIZE:
+            msg = f"File too large file to read: {path}"
+            logger.warning(msg)
+            return ''
+        try:
+            with open(path, mode) as file:
+                return file.read()
+        except Exception as err:
+            raise RuntimeError(f"Failed to read file: {path}") from err
+
+    @classmethod
+    def make_dir_safety(cls, dir_path: str):
+        """Make directory with least authority"""
+        dir_path = validate_and_normalize_path(dir_path)
+
+        if os.path.exists(dir_path):
+            return
+        try:
+            os.makedirs(dir_path, mode=cls.DATA_DIR_AUTHORITY, exist_ok=True)
+        except Exception as err:
+            msg = f"Failed to make directory: {dir_path}"
+            raise RuntimeError(msg) from err
+
+    @classmethod
+    def create_json_file(cls, output_path: str, json_data: List, file_name: str) -> None:
+        """Create json file with least authority"""
+        if not json_data:
+            return
+        cls.make_dir_safety(output_path)
+        file_path = os.path.join(output_path, file_name)
+        flags = os.O_WRONLY | os.O_CREAT
+        with os.fdopen(os.open(file_path, flags, cls.DATA_FILE_AUTHORITY), 'w') as fp:
+            json.dump(json_data, fp, ensure_ascii=False)
+
+    @classmethod
+    def read_csv_file(cls, file_path: str) -> list:
+        """Read csv file and return list"""
+        if not os.path.isfile(file_path):
+            return []
+        file_size = os.path.getsize(file_path)
+        if file_size <= 0:
+            return []
+        if file_size > Constant.MAX_CSV_SIZE:
+            msg = f"The file size exceeds the preset value, please check the file: {file_path}"
+            logger.warning(msg)
+            return []
+        result_data = []
+        try:
+            with open(file_path, newline="") as csv_file:
+                reader = csv.reader(csv_file)
+                for row in reader:
+                    result_data.append(row)
+        except Exception as err:
+            raise RuntimeError(f"Failed to read the file: {file_path}") from err
+        return result_data
+
+    @classmethod
+    def create_csv_file(cls, file_path: str, data: list, headers: list = None) -> None:
+        """Create csv file and write the data"""
+        if not data:
+            return
+        try:
+            with os.fdopen(os.open(file_path, os.O_WRONLY | os.O_CREAT, 0o600),
+                           'w', newline="") as file:
+                writer = csv.writer(file)
+                if headers:
+                    writer.writerow(headers)
+                writer.writerows(data)
+        except Exception as err:
+            raise RuntimeError(f"Can't create file: {file_path}") from err
+
+    @classmethod
+    def combine_csv_file(cls, source_file_list: list, target_file_path: str, header_map: dict = None):
+        """Merge multiple CSV files into one"""
+        headers, all_data = [], []
+        for source_file in source_file_list:
+            data = cls.read_csv_file(source_file)
+            if len(data) > 1:
+                headers = data[0]
+                all_data.extend(data[1:])
+        if all_data:
+            if isinstance(header_map, dict):
+                headers = [header_map.get(header, header) for header in headers]
+            FileManager.create_csv_file(target_file_path, all_data, headers)
+
+    @classmethod
+    def get_csv_file_list_by_start_name(cls, source_path: str, start_name: str):
+        """Get all the csv files that match the name"""
+        file_list = []
+        for file_name in os.listdir(source_path):
+            if file_name.startswith(start_name) and file_name.endswith(".csv"):
+                file_list.append(os.path.join(source_path, file_name))
+        return file_list
+
+    @classmethod
+    def read_txt_file(cls, file_path: str) -> list:
+        """Read txt file and return list"""
+        if not os.path.isfile(file_path):
+            return []
+        file_size = os.path.getsize(file_path)
+        if file_size <= 0:
+            return []
+        if file_size > Constant.MAX_FILE_SIZE:
+            msg = f"The file size exceeds the preset value, please check the file: {file_path}"
+            logger.warning(msg)
+            return []
+        result_data = []
+        try:
+            with open(file_path, "r") as file:
+                for line in file.readlines():
+                    result_data.append(line.strip().split(","))
+        except Exception as err:
+            raise RuntimeError(f"Failed to read the file: {file_path}") from err
+        return result_data

mindspore/profiler/parser/ascend_analysis/function_event.py

@@ -0,0 +1,161 @@
+# Copyright 2023 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.
+# ============================================================================
+"""Function event data struct."""
+from typing import Dict, Optional
+from enum import Enum
+from decimal import Decimal
+import struct
+from abc import ABC, abstractmethod
+
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.profiler_info_parser import ProfilerInfoParser
+
+
+class BaseEvent(ABC):
+    """Base class of CANNEvent and MindSporeOpEvent"""
+
+    def __init__(self, data: Dict):
+        if not isinstance(data, dict):
+            raise TypeError("Input data must be dict.")
+        # common attributes
+        self._orig_data = data
+        self.name: str = ""
+        self.pid: int = 0
+        self.tid: int = 0
+        self.ts: Decimal = Decimal(0)
+        self.end_us: Decimal = Decimal(0)
+        self.dur: float = 0.0
+        self.args: Dict = {}
+        self.parent: Optional[BaseEvent] = None
+        self._init_params()
+
+    @abstractmethod
+    def _init_params(self):
+        err_msg = "Protected function _init_params need to be implemented."
+        raise NotImplementedError(err_msg)
+
+
+class CANNEvent(BaseEvent):
+    """Function event collected on the CANN side"""
+
+    def _init_params(self):
+        """Initialize the attribute value of CANNEvent."""
+        self.ts = Decimal(str(self._orig_data.get("ts", 0)))
+        self.pid = self._orig_data.get("pid", 0)
+        self.tid = self._orig_data.get("tid", 0)
+        self.dur = self._orig_data.get("dur", 0.0)
+        self.end_us = self.ts + Decimal(str(self.dur))
+        self.name = self._orig_data.get("name", "")
+        self.id = self._orig_data.get("id", 0)
+        self.args = self._orig_data.get("args", {})
+        self.ph = self._orig_data.get("ph")
+        self.cat = self._orig_data.get("cat")
+
+    def is_flow_start_event(self) -> bool:
+        """Determine whether the event is flow start event or not."""
+        return self._orig_data.get("cat") == Constant.HOST_TO_DEVICE and \
+               self._orig_data.get("ph") == Constant.START_FLOW
+
+    def is_flow_end_event(self) -> bool:
+        """Determine whether the event is flow end event or not."""
+        return self._orig_data.get("cat") == Constant.HOST_TO_DEVICE and \
+               self._orig_data.get("ph") == Constant.END_FLOW
+
+    def is_x_event(self) -> bool:
+        """Determine whether the event x event or not."""
+        return self._orig_data.get("ph") == "X"
+
+    def to_json(self):
+        """Cast to trace event."""
+        if self.ph == Constant.META_EVENT:
+            res = {'name': self.name, 'pid': self.pid, 'tid': self.tid,
+                   'args': self.args, 'ph': self.ph}
+            if self.cat:
+                res.update({'cat': self.cat})
+            return res
+
+        if self.ph == Constant.COMPLETE_EVENT:
+            if self.parent is not None:
+                self.args.update({'mindspore_op': self.parent.name})
+            res = {'name': self.name, 'pid': self.pid, 'tid': self.tid,
+                   'ts': str(self.ts), 'dur': self.dur, 'args': self.args, 'ph': self.ph}
+            if self.cat:
+                res.update({'cat': self.cat})
+            return res
+
+        if self.ph == Constant.START_FLOW:
+            return {"ph": self.ph, "name": self.name, "id": self.id, "pid": self.pid,
+                    "tid": self.tid, "ts": str(self.ts), "cat": self.cat}
+
+        if self.ph == Constant.END_FLOW:
+            return {"ph": self.ph, "name": self.name, "id": self.id, "pid": self.pid,
+                    "tid": self.tid, "ts": str(self.ts), "cat": self.cat, 'bp': "e"}
+        return {'name': self.name, 'pid': self.pid, 'tid': self.tid,
+                'ts': str(self.ts), 'args': self.args, 'ph': self.ph}
+
+
+class MindSporeOpEnum(Enum):
+    """MindSporeOp index enum"""
+    START_NS = 0
+    END_NS = 1
+    SEQUENCE_UNMBER = 2
+    PROCESS_ID = 3
+    START_THREAD_ID = 4
+    END_THREAD_ID = 5
+    FORWORD_THREAD_ID = 6
+    FLOW_ID = 7
+    STEP_ID = 8
+    IS_ASYNC = 9
+
+
+class MindSporeOpEvent(BaseEvent):
+    """
+    Function event collected on the mindspore frame side.
+
+    Args:
+        data(Dict): The mindspore frame side data decoded by TLVDecoder.
+    """
+    _tlv_type_dict = {
+        Constant.OP_NAME: 3, Constant.INPUT_SHAPES: 5, Constant.INPUT_DTYPES: 4,
+        Constant.CALL_STACK: 6, Constant.MODULE_HIERARCHY: 7, Constant.FLOPS: 8
+    }
+    _fix_data_format = "<3q6Q?"
+
+    def _init_params(self):
+        """Initialize the attribute value of MindSporeOpEvent."""
+        fix_size_data = struct.unpack(self._fix_data_format, self._orig_data.get(Constant.FIX_SIZE_BYTES))
+        self.pid = int(fix_size_data[MindSporeOpEnum.PROCESS_ID.value])
+        self.tid = int(fix_size_data[MindSporeOpEnum.START_THREAD_ID.value])
+        self.name = str(self._orig_data.get(self._tlv_type_dict.get(Constant.OP_NAME), ""))
+        self.ts = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.START_NS.value])
+        self.end_us = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.END_NS.value])
+        self.dur = self.end_us - self.ts
+        self.flow_id = int(fix_size_data[MindSporeOpEnum.FLOW_ID.value])
+        self.step = int(fix_size_data[MindSporeOpEnum.STEP_ID.value])
+        self.args = self.__get_args(fix_size_data)
+
+    def __get_args(self, fix_size_data) -> Dict:
+        """Get the rest information saved in args"""
+        args = {
+            Constant.SEQUENCE_UNMBER: int(fix_size_data[MindSporeOpEnum.SEQUENCE_UNMBER.value]),
+            Constant.FORWORD_THREAD_ID: int(fix_size_data[MindSporeOpEnum.FORWORD_THREAD_ID.value])}
+        for type_name, type_id in self._tlv_type_dict.items():
+            if type_name == Constant.OP_NAME or type_id not in self._orig_data.keys():
+                continue
+            if type_name in set([Constant.INPUT_SHAPES, Constant.INPUT_DTYPES, Constant.CALL_STACK]):
+                args[type_name] = self._orig_data.get(type_id).replace("|", "\r\n")
+            else:
+                args[type_name] = self._orig_data.get(type_id)
+        return args

mindspore/profiler/parser/ascend_analysis/fwk_cann_parser.py

@@ -0,0 +1,131 @@
+# Copyright 2023 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.
+# ============================================================================
+"""The parser for integrating data from the framework side and CANN side."""
+from collections import defaultdict
+from typing import List, Tuple, Optional
+from decimal import Decimal
+
+from mindspore import log as logger
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent, MindSporeOpEvent
+from mindspore.profiler.parser.ascend_analysis.fwk_file_parser import FwkFileParser
+from mindspore.profiler.parser.ascend_analysis.trace_event_manager import TraceEventManager
+from mindspore.profiler.parser.ascend_analysis.msprof_timeline_parser import MsprofTimelineParser
+from mindspore.profiler.parser.ascend_analysis.profiler_info_parser import ProfilerInfoParser
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+
+
+class FwkCANNParser:
+    """The top-level trace view parser."""
+
+    _time_padding_diff = 1000 # ns
+
+    def __init__(self, source_path: str, msprof_data: List, rank_id: int, step_list=None):
+        source_path = validate_and_normalize_path(source_path)
+        ProfilerInfoParser.init_source_path(source_path)
+        ProfilerInfoParser.init_rank_id(rank_id)
+        fwk_parser = FwkFileParser(source_path, rank_id)
+        msprof_timeline_parser = MsprofTimelineParser(msprof_data)
+        self._fwk_data = fwk_parser.get_op_range_data(step_list)
+        self._fwk_json = fwk_parser.get_fwk_trace_data(self._fwk_data)
+        self._start_flow_to_npu_dict, self._device_most_json = msprof_timeline_parser.get_acl_to_npu_data()
+        self.rank_id: int = rank_id
+        self.kernels: List[CANNEvent] = []
+
+    def generate_trace_data(self):
+        """
+        Generate trace view json timeline file which contains framework side and
+        device side data.
+        """
+        fwk_flow_json = self.__link_msop_self()
+        device_flow_and_x_json = self.__link_msop_kernel()
+        return self._fwk_json + fwk_flow_json + self._device_most_json + device_flow_and_x_json
+
+    def __link_msop_self(self):
+        """Create flow between framework-side multi-level pipeline task."""
+        link_event_dict = defaultdict(list)
+        for op_data in self._fwk_data:
+            if op_data.name == Constant.FLOW_OP:
+                link_event_dict[op_data.flow_id].insert(0, op_data)
+            elif op_data.flow_id != Constant.INVALID_FLOW_ID:
+                link_event_dict[op_data.flow_id].append(op_data)
+        flow_json = []
+        for op_data_list in link_event_dict.values():
+            if len(op_data_list) != 2:
+                logger.info('Only alow 2 op_data have the same flow_id. but got %s', len(op_data_list))
+                continue
+            flow_json.extend(TraceEventManager.create_mindspore_to_self_flow(op_data_list[0],
+                                                                             op_data_list[1]))
+        return flow_json
+
+    def __link_msop_kernel(self) -> List:
+        """Associate the frame-side operator with the device-side kernel"""
+        trace_data_json = []
+        op_data_by_tid = defaultdict(list)
+        acl_to_npu_by_tid = {}
+        for host_data in self._fwk_data:
+            if 'KernelLaunch' in host_data.name or 'LaunchTask' in host_data.name:
+                op_data_by_tid[host_data.tid].append(host_data)
+        for (cann_op_tid, cann_op_ts), event_list in self._start_flow_to_npu_dict.items():
+            acl_to_npu_by_tid.setdefault(cann_op_tid, defaultdict(list))[cann_op_ts].extend(event_list)
+
+        if op_data_by_tid.keys() != acl_to_npu_by_tid.keys():
+            logger.warning("Failed to create link between mindspore operator and kernels.")
+
+        for device_tid in acl_to_npu_by_tid:
+            host_data_sorted = sorted(op_data_by_tid.get(device_tid, []), key=lambda x: x.ts)
+            op_idx = 0
+
+            for ts, device_data_list in sorted(acl_to_npu_by_tid.get(device_tid).items(), key=lambda x: x[0]):
+                op_idx, status = FwkCANNParser.__find_launch_op(ts, host_data_sorted, op_idx)
+
+                for device_data in device_data_list:
+                    if status:
+                        device_data.parent = host_data_sorted[op_idx]
+                        trace_data_json.extend(TraceEventManager.create_mindspore_to_npu_flow(host_data_sorted[op_idx],
+                                                                                              device_data))
+                        self.kernels.append(device_data)
+                    trace_data_json.append(device_data.to_json())
+
+        return trace_data_json
+
+    @staticmethod
+    def __find_launch_op(ts: Decimal, op_list: List[MindSporeOpEvent],
+                         left: Optional[int] = None, right: Optional[int] = None
+                         ) -> Tuple[int, bool]:
+        """
+        Searching the op_list in [left, right) range and find the operator
+        whose start time is larger than ts and end time is less than ts.
+
+        Args:
+            ts(Decimal): kernel start time
+            op_list(List): MindSporeOpEvent list
+            left & right(int): the searching index range is [left, right)
+
+        Return:
+            Tuple[int, bool]: the first element is the searched index, the second element
+                marks where the operator index is found or not.
+        """
+        left = 0 if (left is None or left < 0) else left
+        right = len(op_list) if (right is None or right < 0) else right
+        # The data in range [left, right) is considered.
+        while right > left:
+            if op_list[left].ts - FwkCANNParser._time_padding_diff > ts:
+                return left, False
+            if op_list[left].end_us < ts:
+                left += 1
+            else:
+                return left, True
+        return left, False

mindspore/profiler/parser/ascend_analysis/fwk_file_parser.py

@@ -0,0 +1,85 @@
+# Copyright 2023 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.
+# ============================================================================
+"""MindSpore framework oprange file parser"""
+
+import os
+from typing import List
+from collections import defaultdict
+
+from mindspore import log as logger
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.file_manager import FileManager
+from mindspore.profiler.parser.ascend_analysis.tlv_decoder import TLVDecoder
+from mindspore.profiler.parser.ascend_analysis.function_event import MindSporeOpEvent
+from mindspore.profiler.parser.ascend_analysis.trace_event_manager import TraceEventManager
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+
+
+class FwkFileParser:
+    """Framework-side operator file parser."""
+
+    _op_range = "FRAMEWORK/op_range_{}"
+    _op_range_struct_size = 73
+
+    def __init__(self, source_path: str, rank_id: int):
+        """
+            source_path: The path of PROF_* directory
+        """
+        self.rank_id = rank_id
+        self._op_range_path = None
+        self.__init_framework_path(source_path)
+
+    def get_op_range_data(self, step_list=None) -> List[MindSporeOpEvent]:
+        """Read and decode all the mindspore oprange data."""
+        op_range_list = []
+        if os.path.exists(self._op_range_path):
+            op_range_bytes = FileManager.read_file_content(self._op_range_path, "rb")
+            op_range_list = TLVDecoder.decode(op_range_bytes, MindSporeOpEvent, self._op_range_struct_size)
+        else:
+            logger.error("Failed to find op_range data.")
+        if step_list and isinstance(step_list, list):
+            first_step = min(op.step for op in op_range_list)
+            step_list = [step - 1 + first_step for step in step_list]
+            op_range_list = list(filter(lambda op: op.step in step_list, op_range_list))
+        return op_range_list
+
+    def get_fwk_trace_data(self, mindspore_op_data: List[MindSporeOpEvent] = None):
+        """Generate chrome trace format json data from decoded oprange data."""
+        if not mindspore_op_data:
+            mindspore_op_data = self.get_op_range_data()
+        tid_map = defaultdict(set)
+        fwk_x_event_list = []
+
+        for mindspore_op in mindspore_op_data:
+            if mindspore_op.name == Constant.FLOW_OP:
+                continue
+            tid_map[mindspore_op.pid].add(mindspore_op.tid)
+            fwk_x_event_list.append(TraceEventManager.create_x_event(mindspore_op, "cpu_op"))
+        fwk_m_event_list = []
+        for pid, tid_set in tid_map.items():
+            fwk_m_event_list.extend(TraceEventManager.create_m_event(pid, tid_set))
+        return fwk_x_event_list + fwk_m_event_list
+
+    def __init_framework_path(self, source_path: str):
+        """Init the oprange data path."""
+        source_path = validate_and_normalize_path(source_path)
+        if not os.path.exists(source_path):
+            raise FileNotFoundError("Input source_path does not exist!")
+        device_name = os.path.basename(source_path)
+        if not device_name.startswith("device") and not os.path.isdir(source_path):
+            raise RuntimeError("Input source_path is invalid!")
+        prof_path = os.path.dirname(source_path)
+        prof_root = os.path.dirname(prof_path)
+        self._op_range_path = os.path.join(prof_root, self._op_range.format(self.rank_id))

mindspore/profiler/parser/ascend_analysis/msprof_timeline_parser.py

@@ -0,0 +1,57 @@
+# Copyright 2023 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.
+# ============================================================================
+"""msprof timeline file parser"""
+from collections import defaultdict
+from typing import List
+
+from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent
+
+
+class MsprofTimelineParser:
+    """Msprof timeline file parser."""
+
+    def __init__(self, msprof_data: List):
+        self.timeline_data = msprof_data
+
+    def get_acl_to_npu_data(self):
+        """Get all the acl to npu flow events."""
+        flow_start_dict, flow_end_dict = {}, {}
+        x_event_list, other_event_json = [], []
+        for data in self.timeline_data:
+            cann_event = CANNEvent(data)
+            if cann_event.is_x_event():
+                x_event_list.append(cann_event)
+            else:
+                cann_event_json = cann_event.to_json()
+                if cann_event_json:
+                    other_event_json.append(cann_event_json)
+
+            if cann_event.is_flow_start_event():
+                flow_start_dict[cann_event.id] = (cann_event.tid, cann_event.ts)
+            elif cann_event.is_flow_end_event():
+                flow_end_dict[(cann_event.pid, cann_event.tid, cann_event.ts)] = cann_event.id
+        start_flow_to_npu_dict = defaultdict(list)
+        device_data_without_flow_json = []
+        for cann_event in x_event_list:
+            flow_id = flow_end_dict.get((cann_event.pid, cann_event.tid, cann_event.ts))
+            start_flow_info = flow_start_dict.get(flow_id)
+            if flow_id is not None and start_flow_info is not None:
+                start_flow_to_npu_dict[start_flow_info].append(cann_event)
+            else:
+                cann_event_json = cann_event.to_json()
+                if cann_event_json:
+                    device_data_without_flow_json.append(cann_event_json)
+
+        return start_flow_to_npu_dict, device_data_without_flow_json + other_event_json