mindspore 2.2.14__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc2__cp37-cp37m-manylinux1_x86_64.whl

mindspore/profiler/parser/ascend_analysis/fwk_cann_parser.py

@@ -0,0 +1,109 @@
+# 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
+
+
+class FwkCANNParser:
+    """The top-level trace view parser."""
+
+    _trace_view_save_path = "trace_view_{}.json"
+
+    def __init__(self, source_path: str, msprof_data: List, rank_id: int):
+        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_op_data = fwk_parser.get_op_range_data()
+        self._fwk_trace_data = fwk_parser.get_fwk_trace_data(self._fwk_op_data)
+        self._acl_to_npu = 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.
+        """
+        trace_data = self.__link_msop_kernel()
+        return self._fwk_trace_data + trace_data
+
+    def __link_msop_kernel(self) -> List:
+        """Associate the frame-side operator with the device-side kernel"""
+        trace_data = []
+        op_data_by_tid = defaultdict(list)
+        acl_to_npu_by_tid = {}
+        for op_data in self._fwk_op_data:
+            op_data_by_tid[op_data.tid].append(op_data)
+        for (ts, tid), event_list in self._acl_to_npu.items():
+            acl_to_npu_by_tid.setdefault(tid, defaultdict(list))[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 tid in op_data_by_tid:
+            op_idx = 0
+            op_data_sorted = sorted(op_data_by_tid[tid], key=lambda x: x.ts)
+            acl_sorted = sorted(acl_to_npu_by_tid.get(tid, {}).items(), key=lambda x: x[0])
+            for ts, cann_event_list in acl_sorted:
+                op_idx, status = FwkCANNParser.__find_launch_op(ts, op_data_sorted, op_idx)
+                if not status:
+                    continue
+                for cann_event in cann_event_list:
+                    cann_event.parent = op_data_sorted[op_idx]
+                    op_data_sorted[op_idx].children.append(cann_event)
+                    flow_list = TraceEventManager.create_mindspore_to_npu_flow(op_data_sorted[op_idx], cann_event)
+                    self.kernels.append(cann_event)
+                    trace_data += flow_list
+        return trace_data
+
+    @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].end_us < ts:
+                left += 1
+            else:
+                return left, True
+        return left, False

mindspore/profiler/parser/ascend_analysis/fwk_file_parser.py

@@ -0,0 +1,80 @@
+# 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
+
+
+class FwkFileParser:
+    """Framework-side operator file parser."""
+
+    _op_range = "FRAMEWORK/op_range_{}"
+    _op_range_struct_size = 57
+
+    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) -> 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.")
+        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(list)
+        fwk_x_event_list = [None] * len(mindspore_op_data)
+        index = 0
+
+        for mindspore_op in mindspore_op_data:
+            tid_map[mindspore_op.pid].append(mindspore_op.tid)
+            fwk_x_event_list[index] = TraceEventManager.create_x_event(mindspore_op, "cpu_op")
+            index += 1
+        fwk_m_event_list = []
+        for pid, tid_list in tid_map.items():
+            fwk_m_event_list.extend(TraceEventManager.create_m_event(pid, tid_list))
+        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,52 @@
+# 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, Dict, Tuple
+
+from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent
+
+
+class MsprofTimelineParser:
+    """Msprof timeline file parser."""
+
+    ACL_TO_NPU = "acl_to_npu"
+    START_FLOW = "s"
+    END_FLOW = "f"
+    TIMELINE = "timeline"
+
+    def __init__(self, msprof_data: List):
+        self.timeline_data = msprof_data
+
+    def get_acl_to_npu_data(self) -> Dict[Tuple, List[CANNEvent]]:
+        """Get all the acl to npu flow events."""
+        flow_start_dict, flow_end_dict = {}, {}
+        cann_event_list: List[CANNEvent] = []
+        for data in self.timeline_data:
+            cann_event = CANNEvent(data)
+            cann_event_list.append(cann_event)
+            if cann_event.is_flow_start_event():
+                flow_start_dict[cann_event.id] = (cann_event.ts, cann_event.tid)
+            elif cann_event.is_flow_end_event():
+                flow_end_dict[cann_event.unique_id] = cann_event.id
+        acl_to_npu_dict = defaultdict(list)
+        for cann_event in cann_event_list:
+            if not cann_event.is_x_event():
+                continue
+            corr_id = flow_end_dict.get(cann_event.unique_id)
+            acl_ts_tid = flow_start_dict.get(corr_id)
+            if corr_id is not None and acl_ts_tid is not None:
+                acl_to_npu_dict[acl_ts_tid].append(cann_event)
+        return acl_to_npu_dict

mindspore/profiler/parser/ascend_analysis/profiler_info_parser.py

@@ -0,0 +1,116 @@
+# 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 host information parser"""
+import os
+import json
+from decimal import Decimal
+from subprocess import CalledProcessError, TimeoutExpired
+from subprocess import Popen, PIPE
+
+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.profiler_info import ProfilerInfo
+
+
+class ProfilerInfoParser:
+    """Parse files that record information, such as profiler_info.json"""
+
+    _localtime_diff = Decimal(0)
+    _freq = 100.0
+    _time_offset = 0
+    _start_cnt = 0
+    _msprof_cmd = "msprof"
+    _time_out = 1
+    # profiler information related files
+    _source_prof_path = None
+    _loaded_frequency = False
+    _rank_id = 0
+
+    @classmethod
+    def init_source_path(cls, source_path: str):
+        """initialize the path of PROF_* directory."""
+        source_path = validate_and_normalize_path(source_path)
+        prof_path = os.path.dirname(source_path)
+        dir_name = os.path.basename(source_path)
+        if not dir_name.startswith("device") or not os.path.exists(source_path):
+            raise RuntimeError("Input source path is invalid!")
+        cls._source_prof_path = prof_path
+
+    @classmethod
+    def init_rank_id(cls, rank_id):
+        """initialize the rank id."""
+        cls._rank_id = rank_id
+
+    @classmethod
+    def get_local_time(cls, syscnt: int) -> Decimal:
+        """Convert syscnt to local time."""
+        if not cls._loaded_frequency:
+            outs, _ = cls.__run_cmd(['which', cls._msprof_cmd])
+            if not outs:
+                raise FileNotFoundError("Failed to find msprof command!")
+            msprof_path = os.path.realpath(outs.strip())
+            sup_path = msprof_path.split('tools')[0]
+            script_path = os.path.join(sup_path, 'tools/profiler/profiler_tool/analysis/interface/get_msprof_info.py')
+            py_cmd = ['python', script_path, '-dir', os.path.join(cls._source_prof_path, 'host')]
+            outs, _ = cls.__run_cmd(py_cmd)
+            if not outs:
+                raise RuntimeError("Failed to get msprof information!")
+            result = json.loads(outs)
+            cpu_info = result.get('data', {}).get('host_info', {}).get('cpu_info', [{}])[0]
+            try:
+                cls._freq = float(cpu_info.get("Frequency", cls._freq))
+            except ValueError:
+                pass
+            profiler_info_path = os.path.join(cls._source_prof_path, os.path.pardir,
+                                              f"profiler_info_{cls._rank_id}.json")
+            if not os.path.isfile(profiler_info_path):
+                raise RuntimeError(f"Can`t find the file {profiler_info_path}, please check!")
+            with os.fdopen(os.open(profiler_info_path, os.O_RDONLY, 0o600), 'r') as fr:
+                profiler_info_data = json.load(fr)
+            cls._start_cnt = profiler_info_data.get('system_cnt')
+            cls._time_offset = profiler_info_data.get('system_time')
+            ProfilerInfo.set_system_time(cls._time_offset)
+            ProfilerInfo.set_system_cnt(cls._start_cnt)
+            cls._loaded_frequency = True
+        start_ns = cls.__get_timestamp(syscnt)
+        start_us = Decimal(start_ns) / Constant.NS_TO_US
+        return start_us
+
+    @classmethod
+    def __run_cmd(cls, cmd):
+        """run shell command"""
+        try:
+            proc = Popen(cmd, stdout=PIPE, stderr=PIPE, text=True)
+        except (FileNotFoundError, PermissionError, CalledProcessError) as exc:
+            raise RuntimeError(exc) from exc
+        try:
+            outs, errs = proc.communicate(timeout=cls._time_out)
+        except TimeoutExpired as err:
+            proc.kill()
+            msg = "The possible cause is that too much data is collected " \
+                  "and the export time is too long."
+            logger.error(msg)
+            raise TimeoutError(msg) from err
+        logger.info(outs)
+        return outs, errs
+
+    @classmethod
+    def __get_timestamp(cls, syscnt: int, time_fmt: int = 1000):
+        """Convert syscnt to time stamp."""
+        ratio = time_fmt / cls._freq
+        # The unit of timestamp is ns
+        timestamp = round((syscnt - cls._start_cnt) * ratio) + cls._time_offset
+        return timestamp

mindspore/profiler/parser/ascend_analysis/tlv_decoder.py

@@ -0,0 +1,86 @@
+# 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.
+# ============================================================================
+"""TLV format file decoder"""
+
+import struct
+from typing import List, Dict, Union
+
+from mindspore import log as logger
+
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.function_event import MindSporeOpEvent
+
+
+class TLVDecoder:
+    """
+    The class of TLV format data decoder.
+
+    Args:
+        all_bytes(bytes): all the bytes data of tlv format binary file.
+        event_class(MindSporeOpEvent): class of events to decode.
+        fix_data_struct_size(int): a constant value.
+
+    Return:
+        List[MindSporeOpEvent]: event list of input event class.
+    """
+    _type_len = 2
+    _length_len = 4
+
+    @classmethod
+    def decode(cls, all_bytes: bytes, event_class: MindSporeOpEvent, fix_data_struct_size: int):
+        """Decode all the data."""
+        result_data = []
+        records = cls.tlv_list_decode(all_bytes)
+        for record in records:
+            if fix_data_struct_size > len(record):
+                logger.warning("The collected data has been lost")
+                continue
+            fix_data_bytes = record[0: fix_data_struct_size]
+            tlv_fields = cls.tlv_list_decode(record[fix_data_struct_size:], is_field=True)
+            tlv_fields[Constant.FIX_SIZE_BYTES] = fix_data_bytes
+            result_data.append(event_class(tlv_fields))
+        return result_data
+
+    @classmethod
+    def tlv_list_decode(cls, tlv_bytes: bytes, is_field: bool = False) -> Union[Dict, List]:
+        """Decode TLV format data."""
+        result_data = {} if is_field else []
+        index = 0
+        all_bytes_len = len(tlv_bytes)
+        while index < all_bytes_len:
+            if index + cls._type_len > all_bytes_len:
+                logger.warning("The collected data has been lost")
+                break
+            type_id = struct.unpack("<H", tlv_bytes[index: index + cls._type_len])[0]
+            index += cls._type_len
+            if index + cls._length_len > all_bytes_len:
+                logger.warning("The collected data has been lost")
+                break
+            value_len = struct.unpack("<I", tlv_bytes[index: index + cls._length_len])[0]
+            index += cls._length_len
+            if index + value_len > all_bytes_len:
+                logger.warning("The collected data has been lost")
+                break
+            value = tlv_bytes[index: index + value_len]
+            index += value_len
+            if is_field:
+                try:
+                    result_data[type_id] = bytes.decode(value)
+                except UnicodeDecodeError:
+                    logger.warning(f"The collected data can't decode by bytes.decode: {value}")
+                    result_data[type_id] = 'N/A'
+            else:
+                result_data.append(value)
+        return result_data

mindspore/profiler/parser/ascend_analysis/trace_event_manager.py

@@ -0,0 +1,59 @@
+# 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.
+# ============================================================================
+"""Json trace event manager"""
+
+from typing import Dict, List
+
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.function_event import BaseEvent
+
+
+class TraceEventManager:
+    """Chrome trace format json object manager."""
+
+    @classmethod
+    def create_x_event(cls, event: BaseEvent, cat: str) -> Dict:
+        """Create a X event."""
+        x_event = {
+            "ph": "X", "name": event.name, "pid": event.pid, "tid": event.tid,
+            "ts": str(event.ts), "dur": str(event.dur), "cat": cat, "args": event.args
+        }
+        return x_event
+
+    @classmethod
+    def create_m_event(cls, pid: int, tid_list: List) -> List:
+        """Create some metadata event."""
+        # framework sidee trace information display format: MindSpore(pid pid_value): CPU
+        event_list = [
+            # process information
+            {"ph": "M", "name": Constant.PROCESS_NAME, "pid": pid, "tid": 0, "args": {"name": "MindSpore"}},
+            {"ph": "M", "name": Constant.PROCESS_LABEL, "pid": pid, "tid": 0, "args": {"labels": "CPU"}},
+            {"ph": "M", "name": Constant.PROCESS_SORT, "pid": pid, "tid": 0, "args": {"sort_index": 0}},
+        ]
+        for tid in tid_list:
+            sort_index = tid
+            event_list.extend(
+                [{"ph": "M", "name": Constant.THREAD_NAME, "pid": pid, "tid": tid, "args": {"name": f"Thread {tid}"}},
+                 {"ph": "M", "name": Constant.THREAD_SORT, "pid": pid, "tid": tid, "args": {"sort_index": sort_index}}])
+        return event_list
+
+    @classmethod
+    def create_mindspore_to_npu_flow(cls, start_event: BaseEvent, end_event: BaseEvent) -> List:
+        """Create flow events link mindspore operator and npu kernel."""
+        flow_id = str(end_event.ts)
+        return [{"ph": "s", "bp": "e", "name": "mindspore_to_npu", "id": flow_id, "pid": start_event.pid,
+                 "tid": start_event.tid, "ts": str(start_event.ts), "cat": "async_npu"},
+                {"ph": "f", "bp": "e", "name": "mindspore_to_npu", "id": flow_id, "pid": end_event.pid,
+                 "tid": end_event.tid, "ts": str(end_event.ts), "cat": "async_npu"}]

mindspore/profiler/parser/ascend_cluster_generator.py

@@ -25,13 +25,13 @@ from mindspore.profiler.common.exceptions.exceptions import ProfilerIOException
 
 
 def find_files(directory, pattern):
-    """Find files with feature 'pattern' from the directory"""
+    """Find files from the directory"""
     file_list = []
-    for root, _, files in os.walk(directory):
-        files.sort(key=lambda x: os.path.getctime(os.path.join(directory, x)))
-        for basename in files:
-            if fnmatch.fnmatch(basename, pattern):
-                filename = os.path.join(root, basename)
+    for root, _, file in os.walk(directory):
+        file.sort(key=lambda x: os.path.getctime(os.path.join(directory, x)))
+        for base in file:
+            if fnmatch.fnmatch(base, pattern):
+                filename = os.path.join(root, base)
                 file_list.append(filename)
     return file_list
 
@@ -56,8 +56,11 @@ class AscendClusterGenerator:
         Analyse msprof json generate cluster data.
         """
         self.read_msprof()
-        if self.msprof_data.size < 1:
+
+        if (not isinstance(self.msprof_data, np.ndarray) or self.msprof_data.shape[0] == 0
+                or not self.msprof_data.tolist()):
             return
+
         self.step_trace_time['Computing'] = np.sum(self.msprof_data[self.msprof_data['name'] == 'Computing']['dur'])
         self.step_trace_time['comunNotOverlp'] = np.sum(
             self.msprof_data[self.msprof_data['name'] == 'Communication(Not Overlapped)']['dur'])
@@ -82,9 +85,11 @@ class AscendClusterGenerator:
         for file in find_files(self.root_path, "msprof_*.json"):
             with open(file) as jsonfile:
                 for row in json.load(jsonfile):
+                    name = row.get('name', '')
+                    if name is None:
+                        name = ''
                     if row.get('name') in ['Computing', 'Communication', 'Communication(Not Overlapped)',
-                                           'Free'] or row.get('name').find('/Receive-op'):
-                        name = row.get('name', '')
+                                           'Free'] or name.find('/Receive-op'):
                         ts = row.get('ts', 0)
                         dur = row.get('dur', 0)
                         msprof_data.append(tuple([name, ts, dur]))

mindspore/profiler/parser/ascend_communicate_generator.py

@@ -209,7 +209,6 @@ class AscendCommunicationGenerator:
                                     communication_op, comm_op_type)
                 else:
                     comm_op_type = match_obj.group()
-
                 for link, data in communication_info.items():
                     new_comm_op_name = (comm_op_type, communication_op.split("@")[-1], link)
                     data['op_name'] = communication_op.split("@")[0]

mindspore/profiler/parser/ascend_flops_generator.py

@@ -20,19 +20,22 @@ import os
 import stat
 
 import numpy as np
+from mindspore import log as logger
 from mindspore.profiler.common.exceptions.exceptions import ProfilerIOException
 
 
 class AscendFlopsGenerator:
     """Generate ascend flops data from DataFrame."""
 
-    def __init__(self, op_summary, pretty=False):
+    def __init__(self, op_summary, launch_ops, pretty=False):
         self.op_summary = op_summary
+        self.launch_ops = launch_ops
         self.flops_dt = np.dtype(
-            [('op_full_name', object), ('MFLOPs(10^6 cube)', float), ('GFLOPS(10^9 cube)', float),
+            [('full_kernel_name', object), ('MFLOPs(10^6 cube)', float), ('GFLOPS(10^9 cube)', float),
              ('MFLOPs(10^6 vector)', float), ('GFLOPS(10^9 vector)', float)])
         self.flops = None
         self.flops_summary = None
+        self._full_kernel_name = None
         self.pretty = pretty
 
     @property
@@ -44,9 +47,9 @@ class AscendFlopsGenerator:
         """Analyse the op_summary data generate flops data."""
 
         self.flops = np.empty((len(self.op_summary)), dtype=self.flops_dt)
-
+        self._set_full_kernel_name(self.op_summary, self.launch_ops)
         nonzero_duration = self.op_summary['Task Duration'] != 0
-        self.flops['op_full_name'] = self.op_summary['Op Name']
+        self.flops['full_kernel_name'] = self._full_kernel_name
         self.flops['MFLOPs(10^6 cube)'] = self.op_summary['cube_fops'] * 1e-6
         self.flops['GFLOPS(10^9 cube)'] = np.where(nonzero_duration, self.op_summary['cube_fops'] / self.op_summary[
             'Task Duration'] * 1e-6, 0)
@@ -98,3 +101,16 @@ class AscendFlopsGenerator:
             raise ProfilerIOException() from err
         if os.path.exists(flops_summary_path):
             os.chmod(flops_summary_path, stat.S_IREAD | stat.S_IWRITE)
+
+    def _set_full_kernel_name(self, op_summary, launch_ops):
+        """update full kernel name"""
+        self._full_kernel_name = op_summary['Op Name']
+
+        if launch_ops and len(launch_ops) != len(op_summary):
+            logger.error("Size mismatch between op_summary and launch_ops!")
+            launch_ops = []
+
+        for index, launch_op in enumerate(launch_ops):
+            if not launch_op:
+                continue
+            self._full_kernel_name[index] = f"{launch_op}/{self._full_kernel_name[index]}"