mindspore 2.4.0__cp310-cp310-macosx_10_15_x86_64.whl

mindspore/profiler/parser/ascend_analysis/file_manager.py

@@ -0,0 +1,180 @@
+# 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, Dict, Optional
+
+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
+from mindspore.profiler.parser.ascend_analysis.path_manager import PathManager
+
+
+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 read_json_file(cls, file_path: str) -> Optional[Dict]:
+        """Read json file and return dict data"""
+        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 {}
+        try:
+            PathManager.check_directory_path_readable(file_path)
+            with open(file_path, 'r', encoding='utf-8') as json_file:
+                data = json.load(json_file)
+                return data
+        except Exception as err:
+            raise RuntimeError(f"Failed to read the file: {file_path}") from err
+
+    @classmethod
+    def create_json_file(cls, output_path: str, json_data: List, file_name: str, indent: int = None) -> 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 | os.O_TRUNC
+        with os.fdopen(os.open(file_path, flags, cls.DATA_FILE_AUTHORITY), 'w') as fp:
+            json.dump(json_data, fp, ensure_ascii=False, indent=indent)
+
+    @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,185 @@
+# 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.te: 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.te = 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") == Constant.COMPLETE_EVENT
+
+    def get_sort_index(self):
+        """get the process sort index"""
+        if self.args.get('name', '') == 'Ascend Hardware':
+            return Constant.ASCEND_HARDWARE
+        if self.args.get('name', '') == 'CANN':
+            return Constant.CANN
+        if self.args.get('name', '') == 'HCCL':
+            return Constant.HCCL
+        if self.args.get('name', '') == 'Overlap Analysis':
+            return Constant.OVERLAP
+        return Constant.OTHERWISE
+
+    def to_json(self):
+        """Cast to trace event."""
+        if self.ph == Constant.META_EVENT:
+            if self.name == Constant.PROCESS_NAME:
+                return [{'name': self.name, 'pid': self.pid, 'tid': self.tid,
+                         'args': self.args, 'ph': self.ph},
+                        {'name': Constant.PROCESS_SORT, 'pid': self.pid, 'tid': self.tid,
+                         'args': {'sort_index': self.get_sort_index()}, 'ph': self.ph}]
+            if self.name == Constant.PROCESS_SORT:
+                return None
+            return {'name': self.name, 'pid': self.pid, 'tid': self.tid,
+                    'args': self.args, 'ph': self.ph}
+
+        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 None
+
+
+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
+    LEVEL = 9
+    IS_ASYNC = 10
+
+
+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,
+        Constant.CUSTOM_INFO: 9
+    }
+    _fix_data_format = "<3q6Qb?"
+
+    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 = Constant.MINDSPORE
+        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])  # unit is us
+        self.te = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.END_NS.value])  # unit is us
+        self.dur = self.te - self.ts
+        self.flow_id = int(fix_size_data[MindSporeOpEnum.FLOW_ID.value])
+        self.step = int(fix_size_data[MindSporeOpEnum.STEP_ID.value])
+        self.level = int(fix_size_data[MindSporeOpEnum.LEVEL.value])
+        self.custom_info = ""
+        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")
+            elif type_name == Constant.CUSTOM_INFO and self._orig_data.get(type_id):
+                pairs = self._orig_data.get(type_id).split(';')
+                custom_info = {pair.split(':')[0]: pair.split(':')[1] for pair in pairs}
+                args[type_name] = custom_info
+                self.custom_info = custom_info.__str__()
+            else:
+                args[type_name] = self._orig_data.get(type_id)
+        return args

mindspore/profiler/parser/ascend_analysis/fwk_cann_parser.py

@@ -0,0 +1,136 @@
+# 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.profiler_info import ProfilerInfo
+
+
+class FwkCANNParser:
+    """The top-level trace view parser."""
+
+    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)
+        self._fwk_data = fwk_parser.get_op_range_data(step_list)
+        self._fwk_json, self._link_event_dict, self._fwk_launch_op = fwk_parser.get_fwk_trace_data(self._fwk_data)
+
+        msprof_timeline_parser = MsprofTimelineParser(msprof_data)
+        self._start_flow_to_npu_dict, self._device_mostly_json, self.scope_data_without_flow \
+            = msprof_timeline_parser.get_acl_to_npu_data()
+        self.scope_data_with_flow = []
+        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_mostly_json + device_flow_and_x_json
+
+    def __link_msop_self(self):
+        """Create flow between framework-side multi-level pipeline task."""
+        flow_json = []
+        for op_data_list in self._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):
+        """Associate the frame-side operator with the device-side kernel"""
+        trace_data_json = []
+        acl_to_npu_by_tid = {}
+        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 self._fwk_launch_op and acl_to_npu_by_tid and self._fwk_launch_op.keys() != acl_to_npu_by_tid.keys():
+            logger.warning("Failed to create link between mindspore operator and kernels.")
+        is_not_O2 = bool(ProfilerInfo.get_profiler_info().get(ProfilerInfo.JIT_LEVEL, "") != "O2")
+        for device_tid in acl_to_npu_by_tid:
+            host_data_sorted = sorted(self._fwk_launch_op.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)
+                if not status and is_not_O2:
+                    logger.warning("There are %s device ops have no flows were found. The CANN ts is %s.",
+                                   len(device_data_list), ts)
+
+                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(device_data.parent,
+                                                                                              device_data))
+                        self.kernels.append(device_data)
+
+                    scope_layer = MsprofTimelineParser.parse_ascend_hardware_scope(device_data)
+
+                    if scope_layer is not None:
+                        self.scope_data_with_flow.append(scope_layer)
+
+                    event_json = device_data.to_json()
+                    if event_json and isinstance(event_json, list):
+                        trace_data_json.extend(event_json)
+                    elif event_json and isinstance(event_json, dict):
+                        trace_data_json.append(event_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 > ts:
+                return left, False
+            if op_list[left].te < ts:
+                left += 1
+            else:
+                return left, True
+        return left, False

mindspore/profiler/parser/ascend_analysis/fwk_file_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.
+# ============================================================================
+"""MindSpore framework oprange file parser"""
+
+import os
+import stat
+import csv
+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 = 74
+
+    def __init__(self, source_path: str, rank_id: int):
+        """
+            source_path: The path of PROF_* directory
+        """
+        self.rank_id = rank_id
+        self._prof_root = None
+        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.warning("Failed to find op_range data. skip parse host profiler 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 = []
+        link_event_dict = defaultdict(list)
+        fwk_launch_op = defaultdict(list)
+        dataset_op_data = []
+
+        for mindspore_op in mindspore_op_data:
+            if mindspore_op.name == Constant.FLOW_OP:
+                link_event_dict[mindspore_op.flow_id].insert(0, mindspore_op)
+                continue
+            if mindspore_op.flow_id != Constant.INVALID_FLOW_ID:
+                link_event_dict[mindspore_op.flow_id].append(mindspore_op)
+
+            if 'KernelLaunch' in mindspore_op.name or 'LaunchTask' in mindspore_op.name:
+                fwk_launch_op[mindspore_op.tid].append(mindspore_op)
+
+            if mindspore_op.name.split('::')[0] == 'Dataset':
+                dataset_op_data.append(mindspore_op)
+
+            tid_map[mindspore_op.pid].add(mindspore_op.tid)
+            if mindspore_op.dur > 0:
+                fwk_x_event_list.append(TraceEventManager.create_x_event(mindspore_op, "cpu_op"))
+            else:
+                fwk_x_event_list.append(TraceEventManager.create_i_event(mindspore_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, pid))
+
+        self.calculate_dataset_item(dataset_op_data)
+
+        return fwk_x_event_list + fwk_m_event_list, link_event_dict, fwk_launch_op
+
+    def calculate_dataset_item(self, dataset_op_data: List[MindSporeOpEvent]):
+        """
+        Get the summary data of dataset op by parsing the dataset_op_data.
+        """
+        self._prof_root = validate_and_normalize_path(self._prof_root)
+        dataset_file = os.path.join(self._prof_root, f'dataset_{self.rank_id}.csv')
+        summary_data = defaultdict(list)
+        for op_data in dataset_op_data:
+            _, event, stage = op_data.name.split('::')
+            key = event + '::' + stage + '::' + op_data.custom_info
+            summary_data[key].append(op_data.dur)
+
+        flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+        modes = stat.S_IWUSR | stat.S_IRUSR
+        with os.fdopen(os.open(dataset_file, flags, modes), 'w', newline='') as fw:
+            csv_writer = csv.writer(fw)
+            csv_writer.writerow(['Operation', 'Stage', 'Occurrences', 'Avg. time (us)', 'Custom Info'])
+            for k, v in summary_data.items():
+                event, stage, custom_info = k.split('::')
+                count = len(v)
+                average_execution = round(float(sum(v) / count), 2)
+                csv_writer.writerow([event, stage, count, average_execution, custom_info])
+        os.chmod(dataset_file, modes)
+
+    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!")
+        self._prof_root = os.path.dirname(os.path.dirname(source_path))
+        self._op_range_path = os.path.join(self._prof_root, self._op_range.format(self.rank_id))