mindspore 2.4.1__cp311-cp311-win_amd64.whl → 2.5.0__cp311-cp311-win_amd64.whl

mindspore/profiler/analysis/parser/ascend_cann_parser.py

@@ -0,0 +1,166 @@
+# 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.
+# ============================================================================
+"""Parser for Ascend CANN profiling data."""
+import os
+import glob
+from typing import Dict, Optional
+
+import numpy as np
+
+from mindspore import log as logger
+from mindspore.profiler.analysis.parser.base_parser import BaseParser
+from mindspore.profiler.common.file_manager import FileManager
+from mindspore.profiler.common.path_manager import PathManager
+from mindspore.profiler.common.constant import ProfilerLevel
+from mindspore.profiler.common.ascend_msprof_exporter import AscendMsprofExporter
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+class AscendMsprofParser(BaseParser):
+    """Parser for MindSpore profiling data on Ascend platform."""
+
+    _MSPROF_TIMELINE_FILE_PATTERN = ["msprof_[0-9]*.json", "msprof_slice_*.json"]
+    _OP_SUMMARY_FILE_PATTERN = "op_summary_*.csv"
+    OVERSIZE_MB = 1024
+
+    def __init__(self, next_parser: Optional[BaseParser] = None, **kwargs):
+        """Initialize AscendMsprofParser."""
+        super().__init__(next_parser)
+        self._kwargs = kwargs
+        self._msprof_profile_output_path = self._kwargs.get(
+            "msprof_profile_output_path"
+        )
+        self._msprof_profile_host_path = self._kwargs.get(
+            "msprof_profile_host_path"
+        )
+        self._msprof_profile_device_path = self._kwargs.get(
+            "msprof_profile_device_path"
+        )
+        self._ascend_ms_dir = self._kwargs.get("ascend_ms_dir")
+        self._profiler_level = kwargs.get("profiler_level")
+        ProfilerLogger.init(self._ascend_ms_dir)
+        self._logger = ProfilerLogger.get_instance()
+        self.op_summary = None
+        self.op_summary_headers = None
+        self.msprof_timeline = []
+
+    def _parse(self, data=None) -> Dict:
+        """Parse profiling data and update the input dictionary.
+
+        Args:
+            data (Dict, optional): Input data dictionary. Defaults to None.
+
+        Returns:
+            Dict: Updated data with op_summary, headers and timeline information.
+        """
+        if data is None:
+            data = {}
+        self._check_msprof_data_size()
+        AscendMsprofExporter(**self._kwargs).export()
+        self._logger.info("AscendMsprofExporter export done.")
+        self._parse_op_summary()
+        self._logger.info("AscendMsprofParser parse op summary done.")
+        self._parse_msprof_timeline()
+        self._logger.info("AscendMsprofParser parse msprof timeline done.")
+        data.update(
+            {
+                "op_summary": self.op_summary,
+                "op_summary_headers": self.op_summary_headers,
+                "msprof_timeline": self.msprof_timeline,
+            }
+        )
+        return data
+
+    def _parse_op_summary(self):
+        """Parse operation summary data from CSV files.
+
+        Raises:
+            RuntimeError: If no op summary files are found or read file failed.
+        """
+        if self._profiler_level == ProfilerLevel.LevelNone.value:
+            return
+        file_path_list = glob.glob(
+            os.path.join(
+                self._msprof_profile_output_path, self._OP_SUMMARY_FILE_PATTERN
+            )
+        )
+        if not file_path_list:
+            logger.error(
+                f"Failed to find op_summary_*.csv in directory: {self._msprof_profile_output_path}"
+            )
+            return
+
+        for file_path in file_path_list:
+            csv_data_np, self.op_summary_headers = FileManager.read_csv_file_as_numpy(
+                file_path=file_path, extern_headers=["Step ID"]
+            )
+            if self.op_summary is None:
+                self.op_summary = csv_data_np
+            else:
+                self.op_summary = np.concatenate([self.op_summary, csv_data_np], axis=0)
+
+    def _parse_msprof_timeline(self) -> None:
+        """Parse msprof timeline data from JSON files.
+
+        Raises:
+            RuntimeError: If no msprof JSON files are found in the specified directory.
+        """
+        file_path_list = []
+        for pattern in self._MSPROF_TIMELINE_FILE_PATTERN:
+            file_path_list.extend(glob.glob(os.path.join(self._msprof_profile_output_path, pattern)))
+
+        if not file_path_list:
+            raise RuntimeError(
+                f"Failed to find msprof JSON files in directory: {self._msprof_profile_output_path}"
+            )
+        for file_path in file_path_list:
+            self._process_timeline_file(file_path)
+        if not self.msprof_timeline:
+            logger.error(
+                "Failed to collect msprof timeline data"
+            )
+
+    def _process_timeline_file(self, file_path: str) -> None:
+        """Process a single timeline JSON file.
+
+        Args:
+            file_path (str): Path to the JSON file to process.
+        """
+        try:
+            timeline_data = FileManager.read_json_file(file_path)
+            if timeline_data:
+                self.msprof_timeline.extend(timeline_data)
+            else:
+                logger.warning(
+                    f"Msporf timeline data in {file_path} is empty."
+                )
+        except RuntimeError as err:
+            logger.error(
+                f"Failed to read file: {file_path}. Error: {str(err)}"
+            )
+
+    def _check_msprof_data_size(self) -> None:
+        """Check the size of profiling data."""
+        host_data_size = PathManager.get_directory_size(self._msprof_profile_host_path)
+        device_data_size = PathManager.get_directory_size(self._msprof_profile_device_path)
+        total_size = host_data_size + device_data_size
+
+        if total_size >= self.OVERSIZE_MB:
+            msg = (
+                f"The size of profiling data is too large: {total_size} MB, "
+                "which may spend a lot of time on analysing, you can consider "
+                "reducing the number of collection steps"
+            )
+            logger.warning(msg)

mindspore/profiler/analysis/parser/base_parser.py

@@ -0,0 +1,158 @@
+# 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.
+# ============================================================================
+"""Base parser"""
+from typing import (
+    Any,
+    List,
+    Callable,
+    Optional,
+)
+from multiprocessing import Process
+from mindspore import log as logger
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+class BaseParser:
+    """
+    Base class for all parsers in the workflow.
+    """
+    EXEC_HOOK_TIMEOUT = 30 * 60
+
+    def __init__(self, next_parser: Optional["BaseParser"] = None):
+        """
+        Initialize the BaseParser.
+
+        Args:
+            next_parser (Optional[BaseParser]): The next parser in the chain.
+        """
+        self.next_parser: Optional["BaseParser"] = next_parser
+        self._post_hooks: List[Callable[[Any], None]] = []
+        self._logger = ProfilerLogger.get_instance()
+
+    def set_next(self, next_parser: "BaseParser") -> "BaseParser":
+        """
+        Set the next parser in the chain.
+
+        Args:
+            next_parser (BaseParser): The next parser to be set.
+
+        Returns:
+            BaseParser: The next parser that was set.
+        """
+        if not isinstance(next_parser, BaseParser):
+            raise ValueError(
+                f"next_parser {next_parser.__class__.__name__} must be a BaseParser"
+            )
+        self.next_parser = next_parser
+        return self
+
+    def parse(self, data: Any) -> Any:
+        """
+        Parse the input data and execute post-hooks.
+
+        Args:
+            data (Any): The input data to be parsed.
+
+        Returns:
+            Any: The parsed result.
+        """
+        try:
+            result = self._parse(data)
+            self._execute_post_hooks(result)
+        except Exception as e: # pylint: disable=W0703
+            logger.error("Parser [%s] error: %s", self.__class__.__name__, str(e))
+            self._logger.error("Parser [%s] error: %s", self.__class__.__name__, str(e), exc_info=True)
+            return data
+        return result
+
+    def register_post_hook(self, hook: Callable[[Any], None]) -> "BaseParser":
+        """
+        Register a post-hook to be executed after parsing.
+
+        Args:
+            hook (Callable[[Any], None]): The hook function to be registered.
+
+        Returns:
+            BaseParser: The current parser instance.
+
+        Raises:
+            ValueError: If the hook is not callable.
+        """
+        if callable(hook):
+            self._post_hooks.append(hook)
+        else:
+            raise ValueError("Hook must be callable")
+        return self
+
+    def _execute_post_hooks(self, res: Any) -> None:
+        """
+        Execute all registered post-hooks asynchronously.
+
+        Args:
+            res (Any): The result to be passed to the post-hooks.
+        """
+        if not self._post_hooks:
+            return
+
+        processes = []
+        for hook in self._post_hooks:
+            p = Process(target=hook, args=(res,))
+            p.start()
+            hook_class = hook.__self__.__class__.__name__ if hasattr(hook, '__self__') else 'Unknown'
+            hook_name = f"{hook_class}.{hook.__name__}"
+            processes.append((p, hook_name))
+            self._logger.info("Parser [%s] post hook [%s] start", self.__class__.__name__, hook_name)
+
+        for p, hook_name in processes:
+            try:
+                p.join(timeout=self.EXEC_HOOK_TIMEOUT)
+                if p.is_alive():
+                    logger.error(
+                        "Parser [%s] post hook [%s] timeout after %s seconds, terminating",
+                        self.__class__.__name__, hook_name, self.EXEC_HOOK_TIMEOUT
+                    )
+                    p.terminate()
+                    p.join()
+                else:
+                    self._logger.info(
+                        "Parser [%s] post hook [%s] completed",
+                        self.__class__.__name__, hook_name
+                    )
+            except Exception as e:  # pylint: disable=W0703
+                self._logger.error(
+                    "Parser [%s] post hook [%s] failed: %s",
+                    self.__class__.__name__, hook_name, str(e), exc_info=True
+                )
+                if p.is_alive():
+                    p.terminate()
+
+    def _parse(self, data: Any) -> Any:
+        """
+        Abstract method to be implemented by subclasses for parsing logic.
+
+        Args:
+            data (Any): The input data to be parsed.
+
+        Raises:
+            NotImplementedError: If not implemented by subclass.
+        """
+        raise NotImplementedError("Subclasses should implement this!")
+
+
+class DummyParser(BaseParser):
+    """Dummy parser"""
+    def _parse(self, data: Any) -> Any:
+        """Dummy parse"""
+        return data

mindspore/profiler/analysis/parser/framework_cann_relation_parser.py

@@ -0,0 +1,45 @@
+# 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.
+# ============================================================================
+"""Parser for analyzing the relationship between framework and CANN data."""
+from typing import Dict, Any
+
+from mindspore.profiler.analysis.parser.base_parser import BaseParser
+from mindspore.profiler.analysis.parser.timeline_assembly_factory.ascend_timeline_assembler import (
+    AscendTimelineAssembler
+)
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+class FrameworkCannRelationParser(BaseParser):
+    """FrameworkCannRelationParser"""
+
+    def __init__(self, **kwargs):
+        """Initialize the AscendTraceAnalyser."""
+        super().__init__()
+        self.assembler = AscendTimelineAssembler(**kwargs)
+        self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
+        ProfilerLogger.init(kwargs.get("ascend_ms_dir"))
+        self._logger = ProfilerLogger.get_instance()
+
+    def _parse(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Parse the relation of framework and cann data."""
+        self.assembler.assemble(data)
+        self._logger.info("FrameworkCannRelationParser assemble done")
+        trace_view_container = self.assembler.get_trace_view_container()
+        self._logger.info("FrameworkCannRelationParser get trace view container done")
+        data.update({
+            "trace_view_container": trace_view_container,
+        })
+        return data

mindspore/profiler/analysis/parser/ms_framework_parser.py

@@ -0,0 +1,142 @@
+# 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.
+# ============================================================================
+"""Parser for MindSpore framework profiling data."""
+import os
+import struct
+from typing import List, Dict, Any, Optional
+
+from mindspore import log as logger
+from mindspore.profiler.common.tlv_decoder import TLVDecoder
+from mindspore.profiler.common.file_manager import FileManager
+from mindspore.profiler.common.constant import ProfilerActivity, FileConstant, DeviceTarget
+from mindspore.profiler.analysis.parser.base_parser import BaseParser
+from mindspore.profiler.analysis.parser.timeline_event.fwk_event import FwkFixSizeFormat, OpRangeStructField
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+class FrameworkParser(BaseParser):
+    """Parser for MindSpore framework profiling data."""
+
+    _OP_RANGE_FILE_NAME = "op_range_{}"
+    _CPU_OP_TIMESTAMP_FILE_NAME = "cpu_op_execute_timestamp_{}.txt"
+
+    def __init__(self, next_parser: Optional[BaseParser] = None, **kwargs):
+        """Initialize FrameworkParser."""
+        super().__init__(next_parser)
+        self._rank_id = kwargs.get("rank_id")
+        self._activities = kwargs.get("activities")
+        self._step_list = kwargs.get("step_list")
+        self._framework_path = kwargs.get("framework_path")
+        self._device_target = kwargs.get("device_target")
+        self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
+        self._op_range_path = os.path.join(
+            self._framework_path,
+            self._OP_RANGE_FILE_NAME.format(self._rank_id)
+        )
+        self._cpu_op_path = os.path.join(
+            self._framework_path,
+            self._CPU_OP_TIMESTAMP_FILE_NAME.format(self._rank_id),
+        )
+        ProfilerLogger.init(self._ascend_ms_dir)
+        self._logger = ProfilerLogger.get_instance()
+
+    def _parse(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Parse MindSpore framework profiling data.
+
+        Args:
+            data (Dict[str, Any]): Input data dictionary.
+
+        Returns:
+            Dict[str, Any]: Updated data with:
+                - mindspore_op_list: List of parsed operation events
+                - cpu_op_lines: List of CPU operation timestamp data
+        """
+        if ProfilerActivity.CPU.value not in self._activities:
+            return data
+        mindspore_op_list = self._parse_op_range_data()
+        self._logger.info("FrameworkParser parse op range done.")
+        cpu_op_lines = self._parse_cpu_op_data()
+        self._logger.info("FrameworkParser parse cpu op done.")
+        data.update(
+            {
+                "mindspore_op_list": mindspore_op_list,
+                "cpu_op_lines": cpu_op_lines,
+            }
+        )
+        return data
+
+    def _parse_op_range_data(self) -> List[Dict]:
+        """Read and decode MindSpore op_range data.
+
+        Returns:
+            List[Dict]: List of parsed MindSpore operation events.
+        """
+        if self._device_target == DeviceTarget.CPU.value:
+            return []
+
+        if not os.path.exists(self._op_range_path):
+            logger.error("Failed to find op_range data. Skipping parse host profiler data.")
+            return []
+
+        try:
+            op_range_bytes = FileManager.read_file_content(self._op_range_path, "rb")
+            op_range_list = TLVDecoder.decode(
+                op_range_bytes, FwkFixSizeFormat.OpRangeStruct, struct.calcsize(FwkFixSizeFormat.OpRangeStruct)
+            )
+            self._logger.info("FrameworkParser parse op range done, op_range_list length: %d", len(op_range_list))
+            if not op_range_list:
+                logger.error(
+                    f"Failed to decode op_range data: empty result from file {self._op_range_path}"
+                )
+            return self._filter_op_range_list(op_range_list)
+        except RuntimeError as err:
+            logger.error(f"Failed to read file: {self._op_range_path}. Error: {str(err)}")
+            return []
+
+    def _filter_op_range_list(self, op_range_list: List[Dict]) -> List[Dict]:
+        """Filter op_range_list based on step_list.
+
+        Args:
+            op_range_list (List[Dict]): List of operation events to filter.
+
+        Returns:
+            List[Dict]: Filtered list of operation events.
+        """
+        if not self._step_list or not isinstance(self._step_list, list):
+            return op_range_list
+
+        first_step = min(
+            op[FileConstant.FIX_SIZE_DATA][OpRangeStructField.STEP_ID.value]
+            for op in op_range_list
+        )
+        adjusted_step_list = [step - 1 + first_step for step in self._step_list]
+        return [
+            op for op in op_range_list
+            if op[FileConstant.FIX_SIZE_DATA][OpRangeStructField.STEP_ID.value] in adjusted_step_list
+        ]
+
+    def _parse_cpu_op_data(self) -> List[str]:
+        """Parse CPU op timestamp data.
+
+        Returns:
+            List[str]: List of CPU operation timestamp data lines.
+        """
+        if not os.path.exists(self._cpu_op_path):
+            return []
+        try:
+            return FileManager.read_txt_file(self._cpu_op_path)
+        except RuntimeError as err:
+            logger.warning(f"Failed to read file: {self._cpu_op_path}. Error: {str(err)}")
+            return []

mindspore/profiler/analysis/parser/ms_minddata_parser.py

@@ -0,0 +1,145 @@
+# 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.
+# ============================================================================
+"""mind data parser"""
+import os
+from typing import Dict, Tuple, Optional, Any, List
+from mindspore import log as logger
+from mindspore.profiler.analysis.parser.base_parser import BaseParser
+from mindspore.profiler.common.file_manager import FileManager
+from mindspore.profiler.common.constant import ProfilerActivity
+from mindspore.profiler.common.exceptions.exceptions import (
+    ProfilerPathErrorException,
+    ProfilerRawFileException
+)
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+class MindDataParser(BaseParser):
+    """
+    Parser for MindData profiling information.
+    """
+    _FILE_NAMES = {
+        'pipeline': 'pipeline_profiling_{}.json',
+        'cpu_utilization': 'minddata_cpu_utilization_{}.json',
+        'device_queue': 'device_queue_profiling_{}.txt',
+        'device_iterator': 'dataset_iterator_profiling_{}.txt'
+    }
+
+    def __init__(self, next_parser: Optional[BaseParser] = None, **kwargs):
+        super().__init__(next_parser)
+        self._device_id = kwargs.get("rank_id") if (ProfilerActivity.NPU.value in
+                                                    kwargs.get("activities")) else kwargs.get("device_id")
+        self._output_path = kwargs.get("framework_path")
+        self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
+        ProfilerLogger.init(self._ascend_ms_dir)
+        self._logger = ProfilerLogger.get_instance()
+        self._file_paths = self._setup_file_paths()
+
+    def _setup_file_paths(self) -> Dict[str, str]:
+        return {
+            key: os.path.join(self._output_path, file_name.format(self._device_id))
+            for key, file_name in self._FILE_NAMES.items()
+        }
+
+    def _parse(self, data=None) -> Dict[str, Any]:
+        if data is None:
+            data = {}
+        if not os.path.exists(self._file_paths['pipeline']):
+            logger.info(
+                "pipeline profiling file %s does not exist. Please check whether minddata profiling data should exist.",
+                self._file_paths['pipeline'])
+            return data
+        op_id_info, sample_interval = self._parse_pipeline_info_dict()
+        cpu_util_info = self._parse_cpu_util_info()
+        device_trace_info = self._parse_device_trace()
+        self._logger.info("MindDataParser parse done")
+        data.update({
+            "pipeline_info": (op_id_info, sample_interval),
+            "cpu_util_info": cpu_util_info,
+            "device_trace_info": device_trace_info,
+            "device_queue_file_found": self._device_queue_file_found
+        })
+        return data
+
+    def _parse_pipeline_info_dict(self) -> Tuple[Dict[str, Any], float]:
+        """
+        Parse the pipeline information into a dictionary.
+        Returns:
+            Tuple[Dict[str, Any], float]: A tuple containing the parsed op_info dictionary
+                                          and sampling interval.
+        Raises:
+            ProfilerRawFileException: If the format of the pipeline raw file is incorrect.
+        """
+        pipeline_info = FileManager.read_json_file(self._file_paths['pipeline'])
+        if not pipeline_info:
+            raise ProfilerRawFileException('The minddata pipeline file is empty.')
+
+        sample_interval = pipeline_info.get('sampling_interval')
+        op_info = pipeline_info.get('op_info')
+
+        if sample_interval is None or not op_info:
+            raise ProfilerRawFileException('The format of minddata pipeline raw file is wrong.')
+
+        dict_op_id_info = {
+            item['op_id']: item for item in op_info if item
+        }
+
+        if len(dict_op_id_info) != len(op_info):
+            raise ProfilerRawFileException('The content of minddata pipeline raw file is wrong.')
+
+        return dict_op_id_info, sample_interval
+
+    def _parse_cpu_util_info(self) -> Dict[str, Any]:
+        try:
+            cpu_util_info = FileManager.read_json_file(self._file_paths['cpu_utilization'])
+            if not cpu_util_info:
+                msg = f'The MindData CPU utilization file {self._file_paths["cpu_utilization"]} is empty.'
+                raise RuntimeError(msg)
+        except RuntimeError as err:
+            cpu_util_info = {}
+            logger.warning(f'Failed to read the MindData CPU utilization data. ERROR:{err}')
+        return cpu_util_info
+
+    def _parse_device_trace(self) -> List[Any]:
+        """parse the device trace data"""
+        try:
+            self._device_trace_path, self._device_queue_file_found = self._setup_device_trace()
+            device_trace = FileManager.read_txt_file(self._device_trace_path)
+            if not device_trace:
+                msg = f"The MindData trace profiling file {self._device_trace_path} is empty."
+                raise RuntimeError(msg)
+        except RuntimeError as err:
+            device_trace = []
+            logger.warning(f'Failed to read the MindData device trace data. ERROR:{err}')
+        return device_trace
+
+    def _setup_device_trace(self) -> Tuple[str, bool]:
+        """
+        Set up the device trace file path.
+        Returns:
+            Tuple[str, bool]: A tuple containing the device trace file path and a boolean
+                              indicating whether the device queue file was found.
+        Raises:
+            ProfilerPathErrorException: If no device trace file is found.
+        """
+        queue_path = self._file_paths['device_queue']
+        iterator_path = self._file_paths['device_iterator']
+
+        if os.path.exists(queue_path):
+            return queue_path, True
+        if os.path.exists(iterator_path):
+            return iterator_path, False
+
+        raise ProfilerPathErrorException('A MindData device trace profiling file cannot be found.')