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

mindspore/profiler/envprofiling.py

@@ -17,6 +17,7 @@ import json
 import os
 import time
 from mindspore.profiler import Profiler
+from mindspore.profiler.parser.ascend_analysis.file_manager import FileManager
 from mindspore.profiler.profiling import AICORE_METRICS_DICT, DeviceSupportParam, ALWAYS_VALID_PARAM
 from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
 from mindspore.profiler.parser.integrator import DeviceTarget
@@ -65,11 +66,7 @@ def construct_profiling_options():
         if os.getenv("MS_PROFILER_RUN_CONFIG"):
             return error_config
         os.environ["MS_PROFILER_RUN_CONFIG"] = json.dumps(error_config)
-        logger.error(
-            "The format of MS_PROFILER_OPTIONS is incorrect. "
-            "The MS_PROFILER_OPTIONS parameter configuration may refer to "
-            "'https://www.mindspore.cn/mindinsight/docs/zh-CN/master/performance_profiling_ascend.html'."
-        )
+        logger.error("The format of MS_PROFILER_OPTIONS is incorrect.")
         return error_config
     conbine_options = combine_profile_options(profiling_options)
     if conbine_options.get("start"):
@@ -77,8 +74,7 @@ def construct_profiling_options():
         if not output_path:
             output_path = os.path.join(os.getcwd(), "data")
         conbine_options["output_path"] = validate_and_normalize_path(output_path)
-        if not os.path.exists(output_path):
-            os.makedirs(output_path, exist_ok=True)
+        FileManager.make_dir_safety(output_path)
         conbine_options["file_output_path"] = os.path.join(output_path, "profiler")
     return conbine_options
 
@@ -95,8 +91,8 @@ def parse_pubilc_args(options):
     if not isinstance(options.get("data_process"), bool):
         logger.warning(
             "The 'data_process' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
-            f" but got type {type(options.get('data_process'))}, it will be set to true.")
-        options["data_process"] = True
+            f" but got type {type(options.get('data_process'))}, it will be set to False.")
+        options["data_process"] = False
     if not isinstance(options.get("op_time"), bool):
         logger.warning(
             "The 'op_time' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
@@ -122,11 +118,11 @@ def parse_pubilc_args(options):
             "The 'output_path' parameter of the environment variable MS_PROFILE_OPTIONS only supports absolute path, "
             f"it will be set to '{absolute_path}'.")
         options["output_path"] = absolute_path
-    if options.get("profile_framework") not in ["memory", "time", "all", None]:
+    if options.get("profile_framework") not in ["time", "all", None]:
         logger.warning(
-            "The 'profile_framework' parameter of the environment variable MS_PROFILE_OPTIONS must be one of ['memory',"
-            " 'time', 'all', null], but got %s, it will be set to 'all'.", options.get("profile_framework"))
-        options['profile_framework'] = "all"
+            "The 'profile_framework' parameter of the environment variable MS_PROFILE_OPTIONS must be one of ["
+            " 'time', 'all', null], but got %s, it will be set to None.", options.get("profile_framework"))
+        options['profile_framework'] = None
     return options
 
 
@@ -150,8 +146,8 @@ def parse_ascend_args(options):
     if not isinstance(options.get("parallel_strategy"), bool):
         logger.warning(
             "The 'parallel_strategy' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
-            f" but got type {type(options.get('parallel_strategy'))}, it will be set to true.")
-        options["parallel_strategy"] = True
+            f" but got type {type(options.get('parallel_strategy'))}, it will be set to false.")
+        options["parallel_strategy"] = False
     if not isinstance(options.get("profile_communication"), bool):
         logger.warning(
             "The 'profile_communication' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
@@ -193,11 +189,12 @@ def combine_profile_options(profiling_options):
         "aicore_metrics": profiling_options.get("aicore_metrics", 0),
         "l2_cache": profiling_options.get("l2_cache", False),
         "sync_enable": profiling_options.get("sync_enable", True),
-        "data_process": profiling_options.get("data_process", True),
+        "data_process": profiling_options.get("data_process", False),
         "timeline_limit": profiling_options.get("timeline_limit", 500),
-        "parallel_strategy": profiling_options.get("parallel_strategy", True),
+        "parallel_strategy": profiling_options.get("parallel_strategy", False),
         'op_time': profiling_options.get("op_time", True),
-        'profile_framework': profiling_options.get("profile_framework", "all")
+        'profile_framework': profiling_options.get("profile_framework", None),
+        'with_stack': profiling_options.get("with_stack", False)
     }
     combine_options = parse_profiling_args(config_options)
     if combine_options.get("start"):
@@ -250,7 +247,8 @@ def profiler_check_env():
              sync_enable=config.get("sync_enable", False),
              op_time=config.get("op_time", False),
              timeline_limit=config.get("timeline_limit", 500),
-             profile_framework=config.get("profile_framework", "all"))
+             profile_framework=config.get("profile_framework", None),
+             with_stack=config.get("with_stack", False))
 
 
 profiler_check_env()

mindspore/profiler/parser/ascend_analysis/constant.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Constant value for ascend profiling parser."""
+import os
 
 
 class Constant:
@@ -25,6 +26,7 @@ class Constant:
     COMPLETE_EVENT = 'X'
     FLOW_OP = "flow"
     INVALID_FLOW_ID = 18446744073709551615
+    DEFAULT_PROCESS_NUMBER = os.cpu_count() // 2
 
     # file authority
     MAX_FILE_SIZE = 1024 * 1024 * 1024 * 10
@@ -44,6 +46,7 @@ class Constant:
     MODULE_HIERARCHY = "Module Hierarchy"
     FLOPS = "flops"
     NAME = "name"
+    CUSTOM_INFO = "custom_info"
 
     # trace constant
     PROCESS_NAME = "process_name"
@@ -51,3 +54,18 @@ class Constant:
     PROCESS_SORT = "process_sort_index"
     THREAD_NAME = "thread_name"
     THREAD_SORT = "thread_sort_index"
+
+    # dir name
+    FRAMEWORK_DIR = "FRAMEWORK"
+    PROFILER_DIR = "profiler"
+    TOP_SCOPE_NAMES = ('Default', 'Gradients', 'recompute_Default')
+
+    # the index of modules of timeline
+    MINDSPORE = 1
+    CPU_OP = 2
+    CANN = 3
+    SCOPE_LAYLER = 4
+    ASCEND_HARDWARE = 5
+    HCCL = 6
+    OVERLAP = 7
+    OTHERWISE = 8

mindspore/profiler/parser/ascend_analysis/file_manager.py

@@ -16,11 +16,12 @@
 import csv
 import json
 import os.path
-from typing import List
+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:
@@ -67,15 +68,35 @@ class FileManager:
             raise RuntimeError(msg) from err
 
     @classmethod
-    def create_json_file(cls, output_path: str, json_data: List, file_name: str) -> None:
+    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
+        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)
+            json.dump(json_data, fp, ensure_ascii=False, indent=indent)
 
     @classmethod
     def read_csv_file(cls, file_path: str) -> list:

mindspore/profiler/parser/ascend_analysis/function_event.py

@@ -35,7 +35,7 @@ class BaseEvent(ABC):
         self.pid: int = 0
         self.tid: int = 0
         self.ts: Decimal = Decimal(0)
-        self.end_us: Decimal = Decimal(0)
+        self.te: Decimal = Decimal(0)
         self.dur: float = 0.0
         self.args: Dict = {}
         self.parent: Optional[BaseEvent] = None
@@ -56,7 +56,7 @@ class CANNEvent(BaseEvent):
         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.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", {})
@@ -75,16 +75,32 @@ class CANNEvent(BaseEvent):
 
     def is_x_event(self) -> bool:
         """Determine whether the event x event or not."""
-        return self._orig_data.get("ph") == "X"
+        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:
-            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.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:
@@ -102,8 +118,7 @@ class CANNEvent(BaseEvent):
         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}
+        return None
 
 
 class MindSporeOpEnum(Enum):
@@ -117,7 +132,8 @@ class MindSporeOpEnum(Enum):
     FORWORD_THREAD_ID = 6
     FLOW_ID = 7
     STEP_ID = 8
-    IS_ASYNC = 9
+    LEVEL = 9
+    IS_ASYNC = 10
 
 
 class MindSporeOpEvent(BaseEvent):
@@ -129,24 +145,27 @@ class MindSporeOpEvent(BaseEvent):
     """
     _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.CALL_STACK: 6, Constant.MODULE_HIERARCHY: 7, Constant.FLOPS: 8,
+        Constant.CUSTOM_INFO: 9
     }
-    _fix_data_format = "<3q6Q?"
+    _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 = int(fix_size_data[MindSporeOpEnum.PROCESS_ID.value])
+        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])
-        self.end_us = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.END_NS.value])
-        self.dur = self.end_us - self.ts
+        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.args = self.__get_args(fix_size_data)
+        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:
+    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]),
@@ -156,6 +175,11 @@ class MindSporeOpEvent(BaseEvent):
                 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

@@ -24,23 +24,25 @@ from mindspore.profiler.parser.ascend_analysis.fwk_file_parser import FwkFilePar
 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
+from mindspore.profiler.parser.profiler_info import ProfilerInfo
 
 
 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._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] = []
 
@@ -51,18 +53,12 @@ class FwkCANNParser:
         """
         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
+        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."""
-        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():
+        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
@@ -70,34 +66,43 @@ class FwkCANNParser:
                                                                              op_data_list[1]))
         return flow_json
 
-    def __link_msop_kernel(self) -> List:
+    def __link_msop_kernel(self):
         """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():
+        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(op_data_by_tid.get(device_tid, []), key=lambda x: x.ts)
+            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(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)
-                    trace_data_json.append(device_data.to_json())
+
+                    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
 
@@ -122,9 +127,9 @@ class FwkCANNParser:
         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:
+            if op_list[left].ts > ts:
                 return left, False
-            if op_list[left].end_us < ts:
+            if op_list[left].te < ts:
                 left += 1
             else:
                 return left, True

mindspore/profiler/parser/ascend_analysis/fwk_file_parser.py

@@ -15,6 +15,8 @@
 """MindSpore framework oprange file parser"""
 
 import os
+import stat
+import csv
 from typing import List
 from collections import defaultdict
 
@@ -31,15 +33,16 @@ class FwkFileParser:
     """Framework-side operator file parser."""
 
     _op_range = "FRAMEWORK/op_range_{}"
-    _op_range_struct_size = 73
+    _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)
+        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."""
@@ -48,7 +51,7 @@ class FwkFileParser:
             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.")
+            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]
@@ -61,18 +64,62 @@ class FwkFileParser:
             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)
-            fwk_x_event_list.append(TraceEventManager.create_x_event(mindspore_op, "cpu_op"))
+            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))
-        return fwk_x_event_list + fwk_m_event_list
+            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):
+    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):
@@ -80,6 +127,5 @@ class FwkFileParser:
         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))
+        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))

mindspore/profiler/parser/ascend_analysis/msprof_timeline_parser.py

@@ -16,7 +16,8 @@
 from collections import defaultdict
 from typing import List
 
-from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent, MindSporeOpEvent, BaseEvent
 
 
 class MsprofTimelineParser:
@@ -34,24 +35,70 @@ class MsprofTimelineParser:
             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)
+                event_json = cann_event.to_json()
+                if event_json and isinstance(event_json, list):
+                    other_event_json.extend(event_json)
+                elif event_json and isinstance(event_json, dict):
+                    other_event_json.append(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 = []
+        scope_data_without_flow = []
         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)
+                event_json = cann_event.to_json()
+                if event_json and isinstance(event_json, list):
+                    device_data_without_flow_json.extend(event_json)
+                elif event_json and isinstance(event_json, dict):
+                    device_data_without_flow_json.append(event_json)
+
+                scope_layer = self.parse_ascend_hardware_scope(cann_event)
+                if scope_layer is not None:
+                    scope_data_without_flow.append(scope_layer)
+
+        return start_flow_to_npu_dict, device_data_without_flow_json + other_event_json, scope_data_without_flow
+
+    @staticmethod
+    def parse_ascend_hardware_scope(cann_event: BaseEvent):
+        """
+        parse ascend hardware scope
+        """
+        scope_from_flow_start = MsprofTimelineParser.get_scope_layer(cann_event.parent)
+        scope = MsprofTimelineParser.get_scope_layer(cann_event)
+
+        if scope and scope_from_flow_start:
+            scope = scope_from_flow_start if len(scope_from_flow_start) > len(scope) else scope
+        elif not scope and not scope_from_flow_start:
+            return None
+        else:
+            scope = scope_from_flow_start if scope_from_flow_start else scope
+
+        return (scope, cann_event.ts, cann_event.te)
+
+    @staticmethod
+    def get_scope_layer(event: BaseEvent):
+        """
+        get the scope of device op
+        """
+
+        if event is None:
+            return None
+
+        full_scope_name = None
+        if isinstance(event, MindSporeOpEvent):
+            full_scope_name = event.name.split('::')[-1]
+        elif isinstance(event, CANNEvent):
+            full_scope_name = event.name
 
-        return start_flow_to_npu_dict, device_data_without_flow_json + other_event_json
+        if full_scope_name and full_scope_name.startswith(Constant.TOP_SCOPE_NAMES):
+            return full_scope_name.split('/')[:-1]
+        return None