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

mindspore/profiler/parser/base_timeline_generator.py

@@ -91,7 +91,7 @@ class BaseTimelineGenerator:
     _framework_dir = "FRAMEWORK"
     _op_range_name = "op_range_{}"
 
-    __col_names__ = ['op_name', 'stream_id', 'start_time', 'duration']
+    _col_names = ['op_name', 'stream_id', 'start_time', 'duration']
 
     def __init__(self, device_target, model):
         self._tid_dict = {
@@ -149,7 +149,8 @@ class BaseTimelineGenerator:
         """Get process and thread config."""
         device_process_label = self._get_device_process_label()
         return [
-            {"name": "process_labels", "ph": "M", "pid": self._device_id, "args": {"labels": device_process_label}},
+            {"name": "process_labels", "ph": "M", "pid": f'2{self._device_id}',
+             "args": {"labels": device_process_label}},
             {"name": "process_labels", "ph": "M", "pid": self._AI_CPU_PID, "args": {"labels": self._aicpu_op_label}},
             {"name": "process_labels", "ph": "M", "pid": self._COMMUNICATION_OP_PID,
              "args": {"labels": "Communication Op"}},
@@ -160,7 +161,7 @@ class BaseTimelineGenerator:
             {"name": "process_labels", "ph": "M", "pid": self._OP_GPU_ACTIVITY_PID,
              "args": {"labels": "Activity Op"}},
 
-            {"name": "process_sort_index", "ph": "M", "pid": self._device_id, "args": {"sort_index": 0}},
+            {"name": "process_sort_index", "ph": "M", "pid": f'2{self._device_id}', "args": {"sort_index": 2}},
             {"name": "process_sort_index", "ph": "M", "pid": self._AI_CPU_PID, "args": {"sort_index": 10}},
             {"name": "process_sort_index", "ph": "M", "pid": self._COMMUNICATION_OP_PID, "args": {"sort_index": 20}},
             {"name": "process_sort_index", "ph": "M", "pid": self._HOST_CPU_PID, "args": {"sort_index": 30}},
@@ -176,9 +177,9 @@ class BaseTimelineGenerator:
              "args": {"name": "Merged Communication Op"}},
             {"name": "thread_name", "ph": "M", "pid": self._OP_OVERLAP_PID, "tid": self._FREE_TIME_TID,
              "args": {"name": "Free Time"}},
-            {"name": "thread_name", "ph": "M", "pid": self._device_id, "tid": self._STEPS_TID,
+            {"name": "thread_name", "ph": "M", "pid": f'2{self._device_id}', "tid": self._STEPS_TID,
              "args": {"name": "Steps"}},
-            {"name": "thread_name", "ph": "M", "pid": self._device_id, "tid": self._SINGLE_TID,
+            {"name": "thread_name", "ph": "M", "pid": f'2{self._device_id}', "tid": self._SINGLE_TID,
              "args": {"name": "Ops"}},
 
             {"name": "thread_sort_index", "ph": "M", "pid": self._OP_OVERLAP_PID, "tid": self._MERGED_COMPUTATION_TID,
@@ -189,19 +190,19 @@ class BaseTimelineGenerator:
              "args": {"sort_index": self._MERGED_COMMUNICATION_TID}},
             {"name": "thread_sort_index", "ph": "M", "pid": self._OP_OVERLAP_PID, "tid": self._FREE_TIME_TID,
              "args": {"sort_index": self._FREE_TIME_TID}},
-            {"name": "thread_sort_index", "ph": "M", "pid": self._device_id, "tid": self._STEPS_TID,
+            {"name": "thread_sort_index", "ph": "M", "pid": f'2{self._device_id}', "tid": self._STEPS_TID,
              "args": {"sort_index": self._STEPS_SORT_INDEX}},
         ]
 
-    def write_timeline(self, size_limit=SIZE_LIMIT_DEFAULT):
+    def write_timeline(self):
         """Load data according to the parsed profiling files."""
         # Write timeline to file.
         logger.info('Writing timeline file...')
-        timeline_meta = self.write_timeline_to_json_by_limitation(size_limit)
+        timeline_meta = self.write_timeline_to_json_by_limitation()
         logger.info('Finished file writing!')
         return timeline_meta
 
-    def write_timeline_to_json_by_limitation(self, size_limit):
+    def write_timeline_to_json_by_limitation(self):
         """Write timeline to json by limitation."""
         display_file_path = os.path.join(
             self._profiling_dir,
@@ -210,22 +211,15 @@ class BaseTimelineGenerator:
         display_file_path = validate_and_normalize_path(display_file_path)
 
         try:
+            timeline_data = self.get_thread_label_name()
+            for data in self._timeline_meta:
+                timeline_data.append(data)
+                if "scope_level" in data.keys():
+                    self._max_scope_name_num = max(
+                        self._max_scope_name_num, data["scope_level"] + 1)
+
             with os.fdopen(os.open(display_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as json_file:
-                json_file.write('[')
-                for _, item in enumerate(self._timeline_meta):
-                    item_json = json.dumps([item], indent=self.indent)
-                    item_json = item_json.lstrip('[').rstrip('\n]')
-                    json_file.write(item_json)
-                    if "scope_level" in item.keys():
-                        self._max_scope_name_num = max(
-                            self._max_scope_name_num, item["scope_level"] + 1)
-                    file_size = os.path.getsize(display_file_path)
-                    json_file.write(',')
-                    if file_size > size_limit:
-                        break
-                label_name_json = json.dumps(self.get_thread_label_name(), indent=self.indent)
-                label_name_json = label_name_json.lstrip('[')
-                json_file.write(label_name_json)
+                json.dump(timeline_data, json_file, indent=self.indent)
                 os.chmod(display_file_path, stat.S_IREAD | stat.S_IWRITE)
             return self._timeline_meta
         except (IOError, OSError) as err:
@@ -317,7 +311,7 @@ class BaseTimelineGenerator:
         """Update format meta data which control the display arrange and map the thread name."""
         thread_name_meta_data = {
             "name": "thread_name",
-            "pid": int(self._device_id),
+            "pid": int(f'2{self._device_id}'),
             "tid": 100000,
             "ts": 0,
             "ph": "M",

mindspore/profiler/parser/cpu_gpu_timeline_generator.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """The integrator for integrating parsed profiling files."""
+import json
 import os
 import csv
 
@@ -23,6 +24,7 @@ from mindspore.profiler.parser.container import TimelineContainer
 from mindspore.profiler.parser.base_timeline_generator import BaseTimelineGenerator
 from mindspore.profiler.parser.integrator import DeviceTarget
 from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.gpu_analysis.fwk_file_parser import GPUFwkFileParser
 
 
 class GpuTimelineGenerator(BaseTimelineGenerator):
@@ -65,10 +67,6 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
             if len(timeline) == 4:
                 self._update_num_of_streams(timeline, stream_count_dict)
 
-        # Add format thread meta data.
-        self._format_meta_data_list.extend(self._timeline_meta)
-        self._timeline_meta = self._format_meta_data_list
-
         # Update timeline summary info
         self._timeline_summary['num_of_streams'] += len(stream_count_dict)
 
@@ -109,6 +107,26 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
             logger.warning('No step trace data exists.')
             return False
 
+    def parse_fwk_data(self):
+        """
+        Get framework op range trace data
+        """
+
+        fwk_parser = GPUFwkFileParser(self._profiling_dir, self._device_id)
+        fwk_data = fwk_parser.get_op_range_data()
+        self._fwk_json = fwk_parser.get_fwk_trace_data(fwk_data)
+
+    def write_fwk_timeline(self):
+        display_file_path = os.path.join(self._profiling_dir, self._display_filename)
+        timeline_data = self._fwk_json
+        if os.path.exists(display_file_path):
+            with os.fdopen(os.open(display_file_path, os.O_RDONLY, 0o600), 'r') as fr:
+                device_data = fr.read()
+            timeline_data.extend(json.loads(device_data))
+
+        with os.fdopen(os.open(display_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as fw:
+            json.dump(timeline_data, fw)
+
     def _get_and_validate_path(self, file_name):
         """Generate op or activity file path from file name, and validate this path."""
         file_path = os.path.join(
@@ -133,9 +151,9 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
         timeline_dict['tid'] = op_meta.stream_id
         timeline_dict['ts'] = (op_meta.start_time - min_cycle_counter) / factor
         dur = op_meta.duration
-        timeline_dict['dur'] = dur
+        timeline_dict['dur'] = dur  # unit is us
         if op_meta.pid is None:
-            timeline_dict['pid'] = int(self._device_id)
+            timeline_dict['pid'] = int(f'2{self._device_id}')
         else:
             timeline_dict['pid'] = op_meta.pid
         if op_meta.stream_id == "Scope Name":
@@ -555,17 +573,12 @@ class CpuTimelineGenerator(GpuTimelineGenerator):
             if len(timeline) == 4:
                 self._update_num_of_streams(timeline, stream_count_dict)
 
-        # Add format thread meta data.
-        self._format_meta_data_list.extend(self._timeline_meta)
-        self._timeline_meta = self._format_meta_data_list
-
         # Update timeline summary info
         self._timeline_summary['num_of_streams'] += len(stream_count_dict.keys())
 
     def load_cpu_op_data(self):
         """Load cpu operator data from file"""
-        op_file_path = self._get_and_validate_path(
-            self._output_op_execute_time_file_path)
+        op_file_path = self._get_and_validate_path(self._output_op_execute_time_file_path)
         timeline_list = []
         if not os.path.exists(op_file_path):
             logger.info("No cpu operator info.")

mindspore/profiler/parser/framework_parser.py

@@ -13,30 +13,17 @@
 # limitations under the License.
 # ============================================================================
 """The parser for parsing framework files."""
-import csv
 import glob
 import json
 import os
 import stat
-import re
-import struct
 from collections import defaultdict
 from collections import namedtuple
-from pathlib import Path
-from typing import List
 
 import numpy as np
-from mindspore import log as logger
-from mindspore.profiler.common.exceptions.exceptions import ProfilerDirNotFoundException
-from mindspore.profiler.common.exceptions.exceptions import ProfilerFileNotFoundException
-from mindspore.profiler.common.exceptions.exceptions import ProfilerParamValueErrorException
-from mindspore.profiler.common.struct_type import StructType
-from mindspore.profiler.common.util import combine_stream_task_id
 from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
-from mindspore.profiler.parser.framework_enum import MSPROF_MIX_DATA_STRING
-from mindspore.profiler.parser.framework_enum import VmDataType, VmFormat, FileDataType, MSPROF_DIFFERENCE
+from mindspore.profiler.parser.framework_enum import FileDataType
 from mindspore.profiler.parser.framework_struct import TASK_DESC_STRUCT, TENSOR_DATA_STRUCT, STEP_INFO_STRUCT
-from mindspore.profiler.parser.profiler_info import ProfilerInfo
 
 FILE_DATA_STRUCT_DICT = {
     FileDataType.STEP_INFO.value: STEP_INFO_STRUCT,
@@ -60,383 +47,6 @@ COL_NAMES = [
 OpData = namedtuple('OpData', field_names=COL_NAMES)
 
 
-class FrameworkParser:
-    """
-    The parser for parsing framework files.
-
-    Args:
-        profiling_path (str): The profiling path which should contain CANN profiling data.
-        rank_id (str): The rank ID.
-        output_path (str): The directory of the parsed file. Default: `./`.
-    """
-    _regex_framework = r'Framework\.(?P<data_type>.+)\.(?P<device_id>\d).+'
-    _host_regex_framework = r'Framework\.(?P<data_type>.+)\.+'
-    _match_framework_file = r'Framework*[0-9]'
-    _graph_attr_name = [
-        'input_format', 'input_data_type', 'input_shape', 'output_format',
-        'output_data_type', 'output_shape'
-    ]
-    output_file_format = 'framework_raw_{rank_id}.csv'
-
-    def __init__(self, profiling_path, rank_id, output_path='./'):
-        self._profiling_path = profiling_path
-        self._output_path = output_path
-        self._rank_id = rank_id
-
-        self._hash_dict = {}
-        self._task_id_full_op_name_dict = {}
-        self._point_info = {}
-
-    @property
-    def save_path(self):
-        """
-        The property of save path.
-
-        Returns:
-            str, the save path.
-        """
-        return os.path.realpath(os.path.join(self._output_path, self.output_file_format.format(rank_id=self._rank_id)))
-
-    @property
-    def point_info(self):
-        """
-        The property of the framework point information.
-
-        Returns:
-            dict, the framework point information, key is tag, value is op name.
-        """
-        # Note: In the multi-subgraph or multi-tag scenario, op name is overwritten.
-        return self._point_info
-
-    @staticmethod
-    def _check_output_path(path):
-        if not os.path.exists(path) or not os.path.isdir(path):
-            raise ProfilerDirNotFoundException(path)
-
-    @staticmethod
-    def _parse_hash_dic(framework_path_dict):
-        """Parse the hash dic files, and return a hash value map op name dict."""
-        hash_op_dict = {}
-        for path in framework_path_dict[FileDataType.HASH_DIC.value]:
-            with open(path, 'r') as file:
-                for hash_str in file:
-                    hash_value, op_name = hash_str.strip().split(':')
-                    hash_op_dict[hash_value] = op_name
-        return hash_op_dict
-
-    @staticmethod
-    def _special_process_tensor_data(item_binary_data, data_type, tensor_num):
-        """The tensor data depends tensor num, so need to special process."""
-        start = 0
-        op_attr_struct = data_type[0]
-        op_attr_size = StructType.sizeof(op_attr_struct)
-        unpack_data = []
-
-        for _ in range(tensor_num):
-            buffer = item_binary_data[start:start + op_attr_size]
-            values = struct.unpack(StructType.format(op_attr_struct), buffer)
-            one_data = dict(
-                tensorType=values[0],
-                format=values[1],
-                dataType=values[2],
-                shape=list(filter(lambda x: x != 0, values[3:]))
-            )
-            unpack_data.append(one_data)
-            start += op_attr_size
-
-        return unpack_data
-
-    @staticmethod
-    def _special_process_tensor_num(item_binary_data, data_type):
-        """The memory of tensorNum is aligned, so here need to special process"""
-        cursor = 0
-        tensor_num_struct = data_type[0]
-        size = StructType.sizeof(tensor_num_struct)
-        unpack_data = struct.unpack(tensor_num_struct.value, item_binary_data[cursor:cursor + size])[0]
-        return unpack_data
-
-    @staticmethod
-    def _construct_task_id_full_op_name_dict(task_desc_info):
-        """The task desc info is a list[task_desc], task_desc is a dict, key is same as TASK_DESC_STRUCT."""
-        task_id_full_op_name = {}
-        for task_desc in task_desc_info:
-            task_id = combine_stream_task_id(task_desc['streamId'], task_desc['taskId'])
-            task_id_full_op_name[task_id] = task_desc['opName']
-        return task_id_full_op_name
-
-    @staticmethod
-    def _construct_point_info(task_id_full_op_name_dict, step_point_data):
-        """step_point_data is a list[step_data], step data is a dict, key is same as STEP_INFO_STRUCT."""
-        point_info = {}
-        for step_point in step_point_data:
-            task_id = combine_stream_task_id(step_point['streamId'], step_point['taskId'])
-            tag = step_point['tag']
-            full_op_name = task_id_full_op_name_dict[task_id]
-            point_info[tag] = full_op_name
-        return point_info
-
-    @staticmethod
-    def _get_vm_data_type(msprof_data_type):
-        """Get the mapped vm data type of msprof."""
-        if msprof_data_type >= MSPROF_DIFFERENCE:
-            return msprof_data_type - MSPROF_DIFFERENCE
-        return msprof_data_type
-
-    @staticmethod
-    def _get_vm_op_format(msprof_op_format):
-        """Get the mapped op format type of msprof."""
-        if msprof_op_format >= MSPROF_DIFFERENCE:
-            return msprof_op_format - MSPROF_DIFFERENCE
-        return msprof_op_format
-
-    @staticmethod
-    def _construct_task_id_op_attr_dict(prof_tensor_data):
-        """prof_tensor_data is a list[tensor_data], tensor_data is a dict, key is same as TENSOR_DATA_STRUCT."""
-        task_id_op_attr_dict = defaultdict(list)
-        for tensor_data in prof_tensor_data:
-            task_id = combine_stream_task_id(tensor_data['streamId'], tensor_data['taskId'])
-            for tensor_attr in tensor_data['tensorData']:
-                tensor_type = 'input' if tensor_attr['tensorType'] == 0 else 'output'
-                tensor_format = VmFormat.get_format_name(FrameworkParser._get_vm_data_type(tensor_attr['format']))
-                op_attr = dict(
-                    tensor_type=tensor_type,
-                    format=tensor_format,
-                    data_type=VmDataType.get_data_type_name(FrameworkParser._get_vm_op_format(tensor_attr['dataType'])),
-                    shape=tensor_attr['shape']
-                )
-                task_id_op_attr_dict[task_id].append(op_attr)
-
-        for task_id, op_attrs in task_id_op_attr_dict.items():
-            input_count = 0
-            output_count = 0
-            new_op_attr = {}
-            for op_attr in op_attrs:
-                if op_attr['tensor_type'] == 'input':
-                    op_attr.pop('tensor_type')
-                    new_op_attr[f'input_{input_count}'] = op_attr
-                    input_count += 1
-                else:
-                    op_attr.pop('tensor_type')
-                    new_op_attr[f'output_{output_count}'] = op_attr
-                    output_count += 1
-            task_id_op_attr_dict[task_id] = new_op_attr
-
-        return task_id_op_attr_dict
-
-    @staticmethod
-    def _write_framework_to_file(all_op_data: List[OpData], output_file):
-        with os.fdopen(os.open(output_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as file_handler:
-            csv_writer = csv.writer(file_handler)
-            csv_writer.writerow(COL_NAMES)
-            csv_writer.writerows(all_op_data)
-        os.chmod(output_file, stat.S_IREAD | stat.S_IWRITE)
-
-    @staticmethod
-    def _get_subgraph_name(full_op_name):
-        """
-        Get subgraph name.
-
-        Args:
-            full_op_name (str): The full operator name.
-
-        Returns:
-            str, the subgraph name.
-        """
-        subgraph_name = full_op_name.split('/', 1)[0]
-        if subgraph_name in ['Default', 'Gradients']:
-            return subgraph_name
-        return None
-
-    def check_op_name(self, op_name, is_prefix=True):
-        """
-        Check whether the operator name exists.
-
-        Args:
-            op_name (str): The operator name or operator name prefix.
-            is_prefix (bool): `True` if the op_name is prefix, else `False`.
-                Default: ``True``.
-
-        Returns:
-            bool, `True` if the operator name does exist in framework file, else
-            `False`.
-        """
-        if not op_name:
-            raise ProfilerParamValueErrorException('The op_name should exist.')
-        for full_op_name in self._task_id_full_op_name_dict.values():
-            if full_op_name:
-                if is_prefix and full_op_name.startswith(op_name):
-                    return True
-                if not is_prefix and op_name == full_op_name:
-                    return True
-        return False
-
-    def to_task_id_full_op_name_dict(self):
-        """
-        Get the task id and full operator name dict.
-
-        Returns:
-            dict, the task id and full operator name dict.
-        """
-        return self._task_id_full_op_name_dict
-
-    def parse(self):
-        """Parse the framework files."""
-        framework_path_dict = self._search_file(self._profiling_path)
-        self._hash_dict = self._parse_hash_dic(framework_path_dict)
-
-        all_file_data = self._parse_binary_data(framework_path_dict)
-        task_id_full_op_name_dict = self._construct_task_id_full_op_name_dict(
-            all_file_data[FileDataType.TASK_DESC_INFO.value])
-        point_info = self._construct_point_info(task_id_full_op_name_dict, all_file_data[FileDataType.STEP_INFO.value])
-        task_id_op_attr_dict = self._construct_task_id_op_attr_dict(all_file_data[FileDataType.TENSOR_DATA_INFO.value])
-
-        self._point_info = point_info
-        self._task_id_full_op_name_dict = task_id_full_op_name_dict
-
-        all_op_data = self._construct_op_data_to_file(all_file_data[FileDataType.TASK_DESC_INFO.value],
-                                                      task_id_op_attr_dict)
-
-        self._write_framework_to_file(all_op_data, output_file=self.save_path)
-
-    def _search_file(self, profiling_path):
-        """
-        Search all framework files in raw profiling path.
-
-        Args:
-            profiling_path (str): This profiling path should contain data dir.
-
-        Return:
-            dict, return a dict container all framework file paths. Format is {FileDataType: [file paths]}.
-
-        Raises:
-            ProfilerFileNotFoundException: If the framework files are not found.
-        """
-        data_dir = os.path.join(profiling_path, 'data')
-        host_data_dir = os.path.join(profiling_path, '../host/data')
-        if not os.path.isdir(data_dir) and not os.path.isdir(host_data_dir):
-            raise ProfilerDirNotFoundException(data_dir)
-
-        framework_path_dict = defaultdict(list)
-        file_list = [f for f in Path(data_dir).glob(self._match_framework_file)]
-        if not file_list:
-            file_list = [f for f in Path(host_data_dir).glob(self._match_framework_file)]
-
-        for file in file_list:
-            file_name = file.name
-
-            match = re.search(self._regex_framework, file_name)
-            if match is None:
-                match = re.search(self._host_regex_framework, file_name)
-                if match is None:
-                    logger.warning("Profiler does not support to analyse file(%s), this file name format is not %s, "
-                                   "skip this file.", file.resolve(), self._regex_framework)
-                    continue
-
-            if match['data_type'] not in FileDataType.members():
-                logger.warning("Profiler does not support to analyse file(%s), this file data type is %s, "
-                               "skip this file.", file.resolve(), match['data_type'])
-                if match['data_type'].startswith('vm'):
-                    raise RuntimeError("The current profiler file is generated by MindSpore 1.5 or earlier. Use "
-                                       "MindSpore 1.5 or the matching MindSpore version to parse the profiler file.")
-                continue
-
-            framework_path_dict[match['data_type']].append(file.resolve())
-
-        empty_files = [data_type for data_type, files in framework_path_dict.items() if not files]
-        if not framework_path_dict or empty_files:
-            if empty_files:
-                logger.error("Can not find %s files when parse profiler framework file.", ','.join(empty_files))
-            raise ProfilerFileNotFoundException('Framework')
-
-        for data_type in FileDataType.members():
-            if data_type not in framework_path_dict:
-                logger.warning("Can not find %s file when parse profiler framework file.", data_type)
-                continue
-            framework_path_dict[data_type].sort()
-
-        return framework_path_dict
-
-    def _parse_binary_data(self, framework_path_dict):
-        """Parse binary data in the FILE_DATA_STRUCT_DICT from given files, such as task data, step point data"""
-        all_file_data = defaultdict(list)
-        for file_data_type, data_struct in FILE_DATA_STRUCT_DICT.items():
-            line_size = StructType.sizeof(data_struct.values())
-            for path in framework_path_dict[file_data_type]:
-                with open(path, 'rb') as file_handler:
-                    while True:
-                        binary_data = file_handler.read(line_size)
-                        if len(binary_data) < line_size:
-                            break
-                        line_data = StructType.unpack_binary_data(data_struct, binary_data,
-                                                                  self._special_process_binary_data)
-                        all_file_data[file_data_type].append(line_data)
-        return all_file_data
-
-    def _special_process_binary_data(self, item_binary_data, data_name, data_type, unpacked_data):
-        """Specially processes binary data."""
-        unpack_data = None
-        success = False
-        if isinstance(data_type, list):
-            if data_name in ('opName', 'opType'):
-                unpack_data = self._special_process_mixed_data(item_binary_data)
-            elif data_name == 'tensorData':
-                tensor_num = unpacked_data['tensorNum']
-                unpack_data = self._special_process_tensor_data(item_binary_data, data_type, tensor_num)
-            elif data_name == 'tensorNum':
-                unpack_data = self._special_process_tensor_num(item_binary_data, data_type)
-            else:
-                # skip reserve data
-                unpack_data = None
-            success = True
-        return unpack_data, success
-
-    def _special_process_mixed_data(self, item_binary_data):
-        """Specially processes mixed data, for example, opName and opType"""
-        # The first byte is type flag, 0 means data is string, 1 means data is hash value
-        cursor = 0
-        data_size = len(item_binary_data)
-        flag = struct.unpack(StructType.UINT8.value, item_binary_data[cursor:cursor + 1])[0]
-
-        # skip rsv data, rsv has 7 bytes
-        skip_size = 8
-        remain_size = data_size - skip_size
-        if flag == MSPROF_MIX_DATA_STRING:
-            unpack_data = struct.unpack(StructType.CHAR.value * remain_size,
-                                        item_binary_data[cursor + skip_size:cursor + data_size])
-            unpack_data = ''.join(list(map(lambda c: c.decode(), filter(lambda c: c != b'\x00', unpack_data))))
-        else:
-            size = StructType.sizeof(StructType.UINT64) + skip_size
-            hash_value = struct.unpack(StructType.UINT64.value,
-                                       item_binary_data[cursor + skip_size:cursor + size])[0]
-            unpack_data = self._hash_dict[str(hash_value)]
-        return unpack_data
-
-    def _construct_op_data_to_file(self, task_desc_info, task_id_op_attr_dict):
-        """Build data written to a file."""
-        all_op_data = []
-        graph_ids = set()
-        for task_desc in task_desc_info:
-            task_id = task_desc['taskId']
-            full_op_name = task_desc['opName']
-            subgraph = self._get_subgraph_name(full_op_name)
-            combined_task_id = combine_stream_task_id(task_desc['streamId'], task_id)
-            op_data = OpData(task_id=task_id,
-                             stream_id=task_desc['streamId'],
-                             block_dim=task_desc['blockDims'],
-                             full_op_name=full_op_name,
-                             op_name=full_op_name.split('/')[-1],
-                             op_type=task_desc['opType'],
-                             subgraph=subgraph,
-                             op_info=json.dumps(task_id_op_attr_dict.get(combined_task_id, {})),
-                             graph_id=task_desc['modelId'],
-                             kernel_type=TASK_TYPE_TO_KERNEL_TYPE.get(task_desc.get('taskType')))
-            if not task_desc['opType'].startswith("InitDataSetQueue") and not task_desc['opType'].startswith("GetNext"):
-                graph_ids.add(task_desc['modelId'])
-            all_op_data.append(op_data)
-        ProfilerInfo.set_graph_ids(list(graph_ids))
-        return all_op_data
-
-
 class GpuFrameWorkParser:
     """
     The parser for parsing framework files.

mindspore/profiler/parser/gpu_analysis/__init__.py

@@ -0,0 +1,14 @@
+# 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.
+# ============================================================================

mindspore/profiler/parser/gpu_analysis/function_event.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.
+# ============================================================================
+"""Function event data struct."""
+import struct
+
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.function_event import MindSporeOpEnum, MindSporeOpEvent
+from mindspore.profiler.parser.gpu_analysis.profiler_info_parser import GPUProfilerInfoParser
+
+
+class GPUMindSporeOpEvent(MindSporeOpEvent):
+    """
+    Function event collected on the mindspore frame side.
+
+    Args:
+        data(Dict): The mindspore frame side data decoded by TLVDecoder.
+    """
+
+    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 = GPUProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.START_NS.value])  # unit is us
+        self.es = GPUProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.END_NS.value])  # unit is us
+        self.dur = self.es - 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 = super()._get_args(fix_size_data)