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

mindspore/profiler/parser/ascend_analysis/fwk_cann_parser.py

@@ -0,0 +1,136 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""The parser for integrating data from the framework side and CANN side."""
+from collections import defaultdict
+from typing import List, Tuple, Optional
+from decimal import Decimal
+
+from mindspore import log as logger
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent, MindSporeOpEvent
+from mindspore.profiler.parser.ascend_analysis.fwk_file_parser import FwkFileParser
+from mindspore.profiler.parser.ascend_analysis.trace_event_manager import TraceEventManager
+from mindspore.profiler.parser.ascend_analysis.msprof_timeline_parser import MsprofTimelineParser
+from mindspore.profiler.parser.ascend_analysis.profiler_info_parser import ProfilerInfoParser
+from mindspore.profiler.parser.profiler_info import ProfilerInfo
+
+
+class FwkCANNParser:
+    """The top-level trace view parser."""
+
+    def __init__(self, source_path: str, msprof_data: List, rank_id: int, step_list=None):
+        source_path = validate_and_normalize_path(source_path)
+        ProfilerInfoParser.init_source_path(source_path)
+        ProfilerInfoParser.init_rank_id(rank_id)
+
+        fwk_parser = FwkFileParser(source_path, rank_id)
+        self._fwk_data = fwk_parser.get_op_range_data(step_list)
+        self._fwk_json, self._link_event_dict, self._fwk_launch_op = fwk_parser.get_fwk_trace_data(self._fwk_data)
+
+        msprof_timeline_parser = MsprofTimelineParser(msprof_data)
+        self._start_flow_to_npu_dict, self._device_mostly_json, self.scope_data_without_flow \
+            = msprof_timeline_parser.get_acl_to_npu_data()
+        self.scope_data_with_flow = []
+        self.rank_id: int = rank_id
+        self.kernels: List[CANNEvent] = []
+
+    def generate_trace_data(self):
+        """
+        Generate trace view json timeline file which contains framework side and
+        device side data.
+        """
+        fwk_flow_json = self.__link_msop_self()
+        device_flow_and_x_json = self.__link_msop_kernel()
+        return self._fwk_json + fwk_flow_json + self._device_mostly_json + device_flow_and_x_json
+
+    def __link_msop_self(self):
+        """Create flow between framework-side multi-level pipeline task."""
+        flow_json = []
+        for op_data_list in self._link_event_dict.values():
+            if len(op_data_list) != 2:
+                logger.info('Only alow 2 op_data have the same flow_id. but got %s', len(op_data_list))
+                continue
+            flow_json.extend(TraceEventManager.create_mindspore_to_self_flow(op_data_list[0],
+                                                                             op_data_list[1]))
+        return flow_json
+
+    def __link_msop_kernel(self):
+        """Associate the frame-side operator with the device-side kernel"""
+        trace_data_json = []
+        acl_to_npu_by_tid = {}
+        for (cann_op_tid, cann_op_ts), event_list in self._start_flow_to_npu_dict.items():
+            acl_to_npu_by_tid.setdefault(cann_op_tid, defaultdict(list))[cann_op_ts].extend(event_list)
+
+        if self._fwk_launch_op and acl_to_npu_by_tid and self._fwk_launch_op.keys() != acl_to_npu_by_tid.keys():
+            logger.warning("Failed to create link between mindspore operator and kernels.")
+        is_not_O2 = bool(ProfilerInfo.get_profiler_info().get(ProfilerInfo.JIT_LEVEL, "") != "O2")
+        for device_tid in acl_to_npu_by_tid:
+            host_data_sorted = sorted(self._fwk_launch_op.get(device_tid, []), key=lambda x: x.ts)
+            op_idx = 0
+
+            for ts, device_data_list in sorted(acl_to_npu_by_tid.get(device_tid).items(), key=lambda x: x[0]):
+                op_idx, status = FwkCANNParser.__find_launch_op(ts, host_data_sorted, op_idx)
+                if not status and is_not_O2:
+                    logger.warning("There are %s device ops have no flows were found. The CANN ts is %s.",
+                                   len(device_data_list), ts)
+
+                for device_data in device_data_list:
+                    if status:
+                        device_data.parent = host_data_sorted[op_idx]
+                        trace_data_json.extend(TraceEventManager.create_mindspore_to_npu_flow(device_data.parent,
+                                                                                              device_data))
+                        self.kernels.append(device_data)
+
+                    scope_layer = MsprofTimelineParser.parse_ascend_hardware_scope(device_data)
+
+                    if scope_layer is not None:
+                        self.scope_data_with_flow.append(scope_layer)
+
+                    event_json = device_data.to_json()
+                    if event_json and isinstance(event_json, list):
+                        trace_data_json.extend(event_json)
+                    elif event_json and isinstance(event_json, dict):
+                        trace_data_json.append(event_json)
+
+        return trace_data_json
+
+    @staticmethod
+    def __find_launch_op(ts: Decimal, op_list: List[MindSporeOpEvent],
+                         left: Optional[int] = None, right: Optional[int] = None
+                         ) -> Tuple[int, bool]:
+        """
+        Searching the op_list in [left, right) range and find the operator
+        whose start time is larger than ts and end time is less than ts.
+
+        Args:
+            ts(Decimal): kernel start time
+            op_list(List): MindSporeOpEvent list
+            left & right(int): the searching index range is [left, right)
+
+        Return:
+            Tuple[int, bool]: the first element is the searched index, the second element
+                marks where the operator index is found or not.
+        """
+        left = 0 if (left is None or left < 0) else left
+        right = len(op_list) if (right is None or right < 0) else right
+        # The data in range [left, right) is considered.
+        while right > left:
+            if op_list[left].ts > ts:
+                return left, False
+            if op_list[left].te < ts:
+                left += 1
+            else:
+                return left, True
+        return left, False

mindspore/profiler/parser/ascend_analysis/fwk_file_parser.py

@@ -0,0 +1,131 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""MindSpore framework oprange file parser"""
+
+import os
+import stat
+import csv
+from typing import List
+from collections import defaultdict
+
+from mindspore import log as logger
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.file_manager import FileManager
+from mindspore.profiler.parser.ascend_analysis.tlv_decoder import TLVDecoder
+from mindspore.profiler.parser.ascend_analysis.function_event import MindSporeOpEvent
+from mindspore.profiler.parser.ascend_analysis.trace_event_manager import TraceEventManager
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+
+
+class FwkFileParser:
+    """Framework-side operator file parser."""
+
+    _op_range = "FRAMEWORK/op_range_{}"
+    _op_range_struct_size = 74
+
+    def __init__(self, source_path: str, rank_id: int):
+        """
+            source_path: The path of PROF_* directory
+        """
+        self.rank_id = rank_id
+        self._prof_root = None
+        self._op_range_path = None
+        self._init_framework_path(source_path)
+
+    def get_op_range_data(self, step_list=None) -> List[MindSporeOpEvent]:
+        """Read and decode all the mindspore oprange data."""
+        op_range_list = []
+        if os.path.exists(self._op_range_path):
+            op_range_bytes = FileManager.read_file_content(self._op_range_path, "rb")
+            op_range_list = TLVDecoder.decode(op_range_bytes, MindSporeOpEvent, self._op_range_struct_size)
+        else:
+            logger.warning("Failed to find op_range data. skip parse host profiler data.")
+        if step_list and isinstance(step_list, list):
+            first_step = min(op.step for op in op_range_list)
+            step_list = [step - 1 + first_step for step in step_list]
+            op_range_list = list(filter(lambda op: op.step in step_list, op_range_list))
+        return op_range_list
+
+    def get_fwk_trace_data(self, mindspore_op_data: List[MindSporeOpEvent] = None):
+        """Generate chrome trace format json data from decoded oprange data."""
+        if not mindspore_op_data:
+            mindspore_op_data = self.get_op_range_data()
+        tid_map = defaultdict(set)
+        fwk_x_event_list = []
+        link_event_dict = defaultdict(list)
+        fwk_launch_op = defaultdict(list)
+        dataset_op_data = []
+
+        for mindspore_op in mindspore_op_data:
+            if mindspore_op.name == Constant.FLOW_OP:
+                link_event_dict[mindspore_op.flow_id].insert(0, mindspore_op)
+                continue
+            if mindspore_op.flow_id != Constant.INVALID_FLOW_ID:
+                link_event_dict[mindspore_op.flow_id].append(mindspore_op)
+
+            if 'KernelLaunch' in mindspore_op.name or 'LaunchTask' in mindspore_op.name:
+                fwk_launch_op[mindspore_op.tid].append(mindspore_op)
+
+            if mindspore_op.name.split('::')[0] == 'Dataset':
+                dataset_op_data.append(mindspore_op)
+
+            tid_map[mindspore_op.pid].add(mindspore_op.tid)
+            if mindspore_op.dur > 0:
+                fwk_x_event_list.append(TraceEventManager.create_x_event(mindspore_op, "cpu_op"))
+            else:
+                fwk_x_event_list.append(TraceEventManager.create_i_event(mindspore_op))
+
+        fwk_m_event_list = []
+        for pid, tid_set in tid_map.items():
+            fwk_m_event_list.extend(TraceEventManager.create_m_event(pid, tid_set, pid))
+
+        self.calculate_dataset_item(dataset_op_data)
+
+        return fwk_x_event_list + fwk_m_event_list, link_event_dict, fwk_launch_op
+
+    def calculate_dataset_item(self, dataset_op_data: List[MindSporeOpEvent]):
+        """
+        Get the summary data of dataset op by parsing the dataset_op_data.
+        """
+        self._prof_root = validate_and_normalize_path(self._prof_root)
+        dataset_file = os.path.join(self._prof_root, f'dataset_{self.rank_id}.csv')
+        summary_data = defaultdict(list)
+        for op_data in dataset_op_data:
+            _, event, stage = op_data.name.split('::')
+            key = event + '::' + stage + '::' + op_data.custom_info
+            summary_data[key].append(op_data.dur)
+
+        flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+        modes = stat.S_IWUSR | stat.S_IRUSR
+        with os.fdopen(os.open(dataset_file, flags, modes), 'w', newline='') as fw:
+            csv_writer = csv.writer(fw)
+            csv_writer.writerow(['Operation', 'Stage', 'Occurrences', 'Avg. time (us)', 'Custom Info'])
+            for k, v in summary_data.items():
+                event, stage, custom_info = k.split('::')
+                count = len(v)
+                average_execution = round(float(sum(v) / count), 2)
+                csv_writer.writerow([event, stage, count, average_execution, custom_info])
+        os.chmod(dataset_file, modes)
+
+    def _init_framework_path(self, source_path: str):
+        """Init the oprange data path."""
+        source_path = validate_and_normalize_path(source_path)
+        if not os.path.exists(source_path):
+            raise FileNotFoundError("Input source_path does not exist!")
+        device_name = os.path.basename(source_path)
+        if not device_name.startswith("device") and not os.path.isdir(source_path):
+            raise RuntimeError("Input source_path is invalid!")
+        self._prof_root = os.path.dirname(os.path.dirname(source_path))
+        self._op_range_path = os.path.join(self._prof_root, self._op_range.format(self.rank_id))

mindspore/profiler/parser/ascend_analysis/msprof_timeline_parser.py

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

mindspore/profiler/parser/ascend_analysis/path_manager.py

@@ -0,0 +1,313 @@
+# 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 path manager"""
+import os
+import re
+import shutil
+import warnings
+
+from mindspore import log as logger
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+
+
+__all__ = ['PathManager']
+
+
+class PathManager:
+    """
+    Path common operations manager
+    """
+    MAX_PATH_LENGTH = 4096
+    MAX_FILE_NAME_LENGTH = 255
+    DATA_FILE_AUTHORITY = 0o640
+    DATA_DIR_AUTHORITY = 0o750
+
+    @classmethod
+    def check_input_directory_path(cls, path: str):
+        """
+        Function Description:
+            check whether the path is valid, some businesses can accept a path that does not exist,
+            so the function do not verify whether the path exists
+        Parameter:
+            path: the path to check, whether the incoming path is absolute or relative depends on the business
+        Exception Description:
+            when invalid data throw exception
+        """
+        cls._input_path_common_check(path)
+
+        if os.path.isfile(path):
+            msg = "Invalid input path is a file path: {path}"
+            raise RuntimeError(msg)
+
+    @classmethod
+    def check_input_file_path(cls, path: str):
+        """
+        Function Description:
+            check whether the file path is valid, some businesses can accept a path that does not exist,
+            so the function do not verify whether the path exists
+        Parameter:
+            path: the file path to check, whether the incoming path is absolute or relative depends on the business
+        Exception Description:
+            when invalid data throw exception
+        """
+        cls._input_path_common_check(path)
+
+        if os.path.isdir(path):
+            msg = "Invalid input path is a directory path: {path}"
+            raise RuntimeError(msg)
+
+    @classmethod
+    def copy_file(cls, src_path: str, dst_path: str):
+        """
+        Function Description:
+            copy file safety
+        Parameter:
+            src_path: file source path
+            dst_path: file destination path
+        Exception Description:
+            when src_path is link throw exception
+        """
+        if not os.path.exists(src_path):
+            logger.warning("The source file does not exist: %s", src_path)
+            return
+
+        cls.check_input_file_path(src_path)
+        dst_dir = os.path.dirname(dst_path)
+        cls.check_directory_path_writeable(dst_dir)
+
+        try:
+            shutil.copy2(src_path, dst_path)
+        except Exception as err:
+            msg = f"Failed to copy path: {src_path}"
+            raise RuntimeError(msg) from err
+
+    @classmethod
+    def check_path_owner_consistent(cls, path: str):
+        """
+        Function Description:
+            check whether the path belong to process owner
+        Parameter:
+            path: the path to check
+        Exception Description:
+            when invalid path, prompt the user
+        """
+
+        if not os.path.exists(path):
+            msg = f"The path does not exist: {path}"
+            raise RuntimeError(msg)
+        if os.stat(path).st_uid != os.getuid():
+            warnings.warn(f"Warning: The {path} owner does not match the current user.")
+
+    @classmethod
+    def check_directory_path_writeable(cls, path):
+        """
+        Function Description:
+            check whether the path is writable
+        Parameter:
+            path: the path to check
+        Exception Description:
+            when invalid data throw exception
+        """
+        cls.check_path_owner_consistent(path)
+        if os.path.islink(path):
+            msg = f"Invalid path is a soft chain: {path}"
+            raise RuntimeError(msg)
+        if not os.access(path, os.W_OK):
+            msg = f"The path permission check failed: {path}"
+            raise RuntimeError(msg)
+
+    @classmethod
+    def check_directory_path_readable(cls, path):
+        """
+        Function Description:
+            check whether the path is writable
+        Parameter:
+            path: the path to check
+        Exception Description:
+            when invalid data throw exception
+        """
+        cls.check_path_owner_consistent(path)
+        if os.path.islink(path):
+            msg = f"Invalid path is a soft chain: {path}"
+            raise RuntimeError(msg)
+        if not os.access(path, os.R_OK):
+            msg = f"The path permission check failed: {path}"
+            raise RuntimeError(msg)
+
+    @classmethod
+    def remove_path_safety(cls, path: str):
+        """
+        Function Description:
+            remove path safety
+        Parameter:
+            path: the path to remove
+        Exception Description:
+            when invalid data throw exception
+        """
+        msg = f"Failed to remove path: {path}"
+        if os.path.islink(path):
+            raise RuntimeError(msg)
+        if not os.path.exists(path):
+            return
+        try:
+            shutil.rmtree(path)
+        except FileNotFoundError:
+            return
+        except Exception as err:
+            raise RuntimeError(msg) from err
+
+    @classmethod
+    def remove_file_safety(cls, file: str):
+        """
+        Function Description:
+            remove file safety
+        Parameter:
+            path: the file to remove
+        Exception Description:
+            when invalid data throw exception
+        """
+        msg = f"Failed to remove file: {file}"
+        if os.path.islink(file):
+            raise RuntimeError(msg)
+        if not os.path.exists(file):
+            return
+        try:
+            os.remove(file)
+        except FileExistsError:
+            return
+        except Exception as err:
+            raise RuntimeError(msg) from err
+
+    @classmethod
+    def make_dir_safety(cls, path: str):
+        """
+        Function Description:
+            make directory safety
+        Parameter:
+            path: the directory to remove
+        Exception Description:
+            when invalid data throw exception
+        """
+        msg = f"Failed to make directory: {path}"
+        if os.path.islink(path):
+            raise RuntimeError(msg)
+        if os.path.exists(path):
+            return
+        try:
+            os.makedirs(path, mode=cls.DATA_DIR_AUTHORITY, exist_ok=True)
+        except Exception as err:
+            raise RuntimeError(msg) from err
+
+    @classmethod
+    def create_file_safety(cls, path: str):
+        """
+        Function Description:
+            create file safety
+        Parameter:
+            path: the file to remove
+        Exception Description:
+            when invalid data throw exception
+        """
+        msg = f"Failed to create file: {path}"
+        if os.path.islink(path):
+            raise RuntimeError(msg)
+        if os.path.exists(path):
+            return
+        try:
+            os.close(os.open(path, os.O_WRONLY | os.O_CREAT, cls.DATA_FILE_AUTHORITY))
+        except Exception as err:
+            raise RuntimeError(msg) from err
+
+    @classmethod
+    def _input_path_common_check(cls, path: str):
+        """
+        Function Description:
+            input path check common function
+        Parameter:
+            path: the file path to check
+        Exception Description:
+            when invalid data throw exception
+        """
+        if len(path) > cls.MAX_PATH_LENGTH:
+            raise RuntimeError("Length of input path exceeds the limit.")
+
+        if os.path.islink(path):
+            msg = f"Invalid input path is a soft chain: {path}"
+            raise RuntimeError(msg)
+
+        pattern = r'(\.|/|_|-|\s|[~0-9a-zA-Z])+'
+        if not re.fullmatch(pattern, path):
+            msg = f"Invalid input path: {path}"
+            raise RuntimeError(msg)
+
+        path_split_list = path.split("/")
+        for name in path_split_list:
+            if len(name) > cls.MAX_FILE_NAME_LENGTH:
+                raise RuntimeError("Length of input path exceeds the limit.")
+
+    @classmethod
+    def get_profiler_parent_path_list(cls, input_path: str):
+        """
+        Function Description:
+            get valid profiler parent path list from input_path
+        Parameter:
+            input_path: The directory path from which to extract profiler parent paths.
+        Return:
+            A list containing the input path or its subdirectories that are valid profiler parents.
+        """
+        profiler_path = os.path.join(input_path, Constant.PROFILER_DIR)
+        if os.path.isdir(profiler_path) and (cls.get_fwk_path(profiler_path) or cls.get_cann_path(profiler_path)):
+            return [input_path]
+        sub_dirs = os.listdir(os.path.realpath(input_path))
+        profiler_parent_path_list = []
+        for sub_dir in sub_dirs:
+            sub_path = os.path.join(input_path, sub_dir, Constant.PROFILER_DIR)
+            if not os.path.isdir(sub_path):
+                continue
+            if cls.get_fwk_path(sub_path) or cls.get_cann_path(sub_path):
+                profiler_parent_path_list.append(os.path.join(input_path, sub_dir))
+        return profiler_parent_path_list
+
+    @classmethod
+    def get_fwk_path(cls, input_path: str):
+        """
+        Function Description:
+            get valid framework path from input_path
+        Parameter:
+            input_path: the directory path to check whether exist valid FRAMEWORK path
+        Return:
+            The path to the FRAMEWORK directory if found, otherwise an empty string.
+        """
+        fwk_path = os.path.join(input_path, Constant.FRAMEWORK_DIR)
+        if os.path.isdir(fwk_path):
+            return fwk_path
+        return ""
+
+    @classmethod
+    def get_cann_path(cls, input_path: str):
+        """
+        Function Description:
+            get valid PROF_XXX path from input_path
+        Parameter:
+            input_path: the directory path to check valid PROF_XXX path
+        Return:
+            The path to the PROF_XXX directory if it matches the pattern and exists, otherwise an empty string.
+        """
+        sub_dirs = os.listdir(os.path.realpath(input_path))
+        for sub_dir in sub_dirs:
+            sub_path = os.path.join(input_path, sub_dir)
+            if os.path.isdir(sub_path) and re.match(r"^PROF_\d+_\d+_[0-9a-zA-Z]+", sub_dir):
+                return sub_path
+        return ""