mindspore 2.6.0rc1__cp39-cp39-win_amd64.whl → 2.7.0rc1__cp39-cp39-win_amd64.whl

mindspore/profiler/parser/ascend_analysis/function_event.py

@@ -1,185 +0,0 @@
-# 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

@@ -1,136 +0,0 @@
-# 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

@@ -1,131 +0,0 @@
-# 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))

mindspore/profiler/parser/ascend_analysis/msprof_timeline_parser.py

@@ -1,104 +0,0 @@
-# Copyright 2023 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""msprof timeline file parser"""
-from collections import defaultdict
-from typing import List
-
-from mindspore.profiler.parser.ascend_analysis.constant import Constant
-from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent, MindSporeOpEvent, BaseEvent
-
-
-class MsprofTimelineParser:
-    """Msprof timeline file parser."""
-
-    def __init__(self, msprof_data: List):
-        self.timeline_data = msprof_data
-
-    def get_acl_to_npu_data(self):
-        """Get all the acl to npu flow events."""
-        flow_start_dict, flow_end_dict = {}, {}
-        x_event_list, other_event_json = [], []
-        for data in self.timeline_data:
-            cann_event = CANNEvent(data)
-            if cann_event.is_x_event():
-                x_event_list.append(cann_event)
-            else:
-                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:
-                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
-
-        if full_scope_name and full_scope_name.startswith(Constant.TOP_SCOPE_NAMES):
-            return full_scope_name.split('/')[:-1]
-        return None