mindspore 2.4.10__cp311-cp311-win_amd64.whl → 2.6.0rc1__cp311-cp311-win_amd64.whl

mindspore/profiler/common/profiler_parameters.py

@@ -0,0 +1,251 @@
+# Copyright 2022-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.
+# ===========================================================================
+"""ProfilerParameters"""
+import warnings
+from typing import Dict, Optional, Callable, Any
+
+from mindspore import log as logger
+from mindspore.profiler.common.constant import (
+    ProfilerLevel,
+    ProfilerActivity,
+    AicoreMetrics,
+    ExportType
+)
+from mindspore.profiler.schedule import Schedule
+
+
+class ProfilerParameters:
+    """
+    Profiler parameters manage all parameters, parameters validation and type conversion.
+    """
+
+    # key: Parameter name, value: (type, default value)
+    PARAMS: Dict[str, tuple] = {
+        "output_path": (str, "./data"),
+        "profiler_level": (ProfilerLevel, ProfilerLevel.Level0),
+        "activities": (list, [ProfilerActivity.CPU, ProfilerActivity.NPU]),
+        "aic_metrics": (AicoreMetrics, AicoreMetrics.AiCoreNone),
+        "with_stack": (bool, False),
+        "profile_memory": (bool, False),
+        "data_process": (bool, False),
+        "parallel_strategy": (bool, False),
+        "start_profile": (bool, True),
+        "l2_cache": (bool, False),
+        "hbm_ddr": (bool, False),
+        "pcie": (bool, False),
+        "sync_enable": (bool, True),
+        "data_simplification": (bool, True),
+        "export_type": (list, [ExportType.Text]),
+        "mstx": (bool, False),
+        "schedule": (Schedule, None),
+        "on_trace_ready": (Optional[Callable[..., Any]], None)
+    }
+
+    TYPE_INDEX = 0
+    VALUE_INDEX = 1
+
+    def __init__(self, **kwargs):
+        self.is_set_schedule: bool = False
+        self._set_schedule(**kwargs)
+        self._check_deprecated_params(**kwargs)
+        self._init_params(kwargs)
+        self._check_params_type()
+        self._handle_compatibility()
+
+    @property
+    def original_params(self) -> Dict[str, str]:
+        """
+        Get params dict for profiler_info.json save.
+        """
+        params = {}
+        params["is_set_schedule"] = self.is_set_schedule
+        for param, (_, _) in self.PARAMS.items():
+            if param == "profiler_level":
+                params[param] = getattr(self, param).value
+            elif param == "aic_metrics":
+                params[param] = getattr(self, param).value
+            elif param == "activities":
+                params[param] = [item.value for item in getattr(self, param)]
+            elif param == "export_type":
+                params[param] = [item.value for item in getattr(self, param)]
+            elif param == "schedule":
+                params[param] = getattr(self, param).to_dict()
+            elif param == "on_trace_ready":
+                continue
+            else:
+                params[param] = getattr(self, param)
+        return params
+
+    @property
+    def npu_profiler_params(self) -> Dict[str, str]:
+        """
+        Get NPU profiler parameters for Ascend profiler cpp backend.
+
+        Returns:
+            Dict[str, str]: A dictionary of NPU profiler parameters.
+        """
+        return {
+            "profile_memory": self.profile_memory,
+            "aicore_metrics": self.aic_metrics.value,
+            "l2_cache": self.l2_cache,
+            "hbm_ddr": self.hbm_ddr,
+            "pcie": self.pcie,
+            "parallel_strategy": self.parallel_strategy,
+            "profiler_level": self.profiler_level.value,
+            "with_stack": self.with_stack,
+            "mstx": self.mstx,
+            "cpu_trace": ProfilerActivity.CPU in self.activities,
+            "npu_trace": ProfilerActivity.NPU in self.activities,
+        }
+
+    def _init_params(self, kwargs):
+        """
+        Initialize parameters with kwargs
+        """
+        for param, (_, default_value) in self.PARAMS.items():
+            if param == "schedule" and kwargs.get(param) is None:
+                kwargs["schedule"] = Schedule(wait=0, active=1)
+            setattr(self, param, kwargs.get(param) if kwargs.get(param) is not None else default_value)
+
+    def _check_params_type(self) -> None:
+        """
+        Check profiler input params type, if type is invalid reset to default value.
+        """
+        for key, value in self.__dict__.items():
+            if key in ProfilerParameters.PARAMS:
+                expected_type = ProfilerParameters.PARAMS[key][ProfilerParameters.TYPE_INDEX]
+                default_value = ProfilerParameters.PARAMS[key][ProfilerParameters.VALUE_INDEX]
+
+                # Callable特殊处理
+                if key == "on_trace_ready":
+                    if value is not None and not callable(value):
+                        setattr(self, key, default_value)
+                        logger.warning(
+                            f"For Profiler, on_trace_ready value is Invalid, reset to {default_value}."
+                        )
+                elif key == "schedule":
+                    if not isinstance(value, Schedule):
+                        setattr(self, key, Schedule(wait=0, active=1))
+                        logger.warning(
+                            f"For Profiler, schedule value is Invalid, reset to {Schedule(wait=0, active=1)}"
+                        )
+                elif key == "export_type":
+                    setattr(self, key, self._check_and_get_export_type(value))
+                # 检查可迭代类型
+                elif isinstance(expected_type, type) and issubclass(expected_type, (list, tuple, set)):
+                    if not (isinstance(value, expected_type) and
+                            all(isinstance(item, type(default_value[0])) for item in value)):
+                        logger.warning(
+                            f"For Profiler, {key} value is Invalid, reset to {default_value}."
+                        )
+                        setattr(self, key, default_value)
+                # 检查普通类型
+                elif not isinstance(value, expected_type):
+                    logger.warning(
+                        f"For Profiler, the type of {key} should be {expected_type}, "
+                        f"but got {type(value)}, reset to {default_value}."
+                    )
+                    setattr(self, key, default_value)
+
+    def _check_deprecated_params(self, **kwargs) -> None:
+        """
+        Check deprecated parameters.
+        """
+        for key, _ in kwargs.items():
+            if key == "profile_communication":
+                warnings.warn(
+                    "The parameter 'profile_communication' is deprecated,"
+                    " please use 'profiler_level=ProfilerLevel.Level1' or "
+                    "'profiler_level=ProfilerLevel.Level2' instead."
+                )
+            elif key == "op_time":
+                warnings.warn(
+                    "The parameter 'op_time' is deprecated,"
+                    " please use 'activaties=ProfilerActivity.NPU' instead."
+                )
+            elif key == "profile_framework":
+                warnings.warn(
+                    "The parameter 'profile_framework' is deprecated,"
+                    " please use 'activaties=ProfilerActivity.CPU' instead."
+                )
+            elif key == "host_stack":
+                warnings.warn(
+                    "The parameter 'host_stack' is deprecated,"
+                    " please use 'with_stack' instead."
+                )
+            elif key == "timeline_limit":
+                warnings.warn(
+                    "The parameter 'timeline_limit' is deprecated and will have no effect"
+                )
+
+    def _set_schedule(self, **kwargs):
+        if "schedule" in kwargs and isinstance(kwargs["schedule"], Schedule):
+            self.is_set_schedule = True
+
+    def _handle_compatibility(self) -> None:
+        """
+        Handle compatibility.
+        """
+        if hasattr(self, "schedule") and self.is_set_schedule and self.__dict__.get('data_process', False):
+            self.data_process = False
+            warnings.warn("When 'schedule' is set, 'data_process' will be set to False.")
+
+        if not self.__dict__.get('mstx') and self.__dict__.get('profiler_level') == ProfilerLevel.LevelNone:
+            self.profiler_level = ProfilerLevel.Level0
+            warnings.warn("when 'mstx' is disabled, 'profiler_level' cannot be set to 'ProfilerLevel.LevelNone', "
+                          "reset to 'ProfilerLevel.Level0'.")
+
+        if self.__dict__.get('profiler_level') in (ProfilerLevel.LevelNone, ProfilerLevel.Level0) and \
+            self.__dict__.get('aic_metrics') != AicoreMetrics.AiCoreNone:
+            self.aic_metrics = AicoreMetrics.AiCoreNone
+            warnings.warn(f"when 'profiler_level' is set to '{self.__dict__.get('profiler_level')}', "
+                          f"'aic_metrics' cannot be set to other value except 'AicoreMetrics.AiCoreNone', "
+                          f"reset to 'AicoreMetrics.AiCoreNone'.")
+
+        if self.__dict__.get('profiler_level') in (ProfilerLevel.Level1, ProfilerLevel.Level2) and \
+            self.__dict__.get('aic_metrics') == AicoreMetrics.AiCoreNone:
+            self.aic_metrics = AicoreMetrics.PipeUtilization
+            warnings.warn(f"when 'profiler_level' is set to '{self.__dict__.get('profiler_level')}', "
+                          f"'aic_metrics' cannot be set to 'AicoreMetrics.AiCoreNone', "
+                          f"reset to 'AicoreMetrics.PipeUtilization'.")
+
+    def _check_and_get_export_type(self, export_type) -> list:
+        """
+        Check export type.
+        """
+        if not export_type:
+            return [ExportType.Text]
+
+        if isinstance(export_type, str):
+            if export_type in [ExportType.Text.value, ExportType.Db.value]:
+                return [ExportType(export_type)]
+
+        if isinstance(export_type, list):
+            if all(isinstance(type, ExportType) for type in export_type):
+                return list(set(export_type))
+
+        if isinstance(export_type, ExportType):
+            return [export_type]
+
+        logger.warning("Invalid parameter export_type, reset it to text.")
+        return [ExportType.Text]
+
+    def __getattr__(self, name):
+        """
+        Get attribute.
+        """
+        if name in self.PARAMS:
+            return getattr(self, name)
+        raise AttributeError(f"'{self.__class__.__name__}' has no attribute '{name}'")

mindspore/profiler/common/profiler_path_manager.py

@@ -0,0 +1,179 @@
+# Copyright 2022-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.
+# ============================================================================
+"""Profiler Path Manager"""
+import os
+import socket
+import glob
+import shutil
+from datetime import datetime, timezone
+
+from mindspore import log as logger
+from mindspore.profiler.common.singleton import Singleton
+from mindspore.profiler.common.profiler_context import ProfilerContext
+from mindspore.profiler.common.path_manager import PathManager
+
+
+@Singleton
+class ProfilerPathManager:
+    """
+    ProfilerPathManager is responsible for creating and managing all paths used by profiler.
+    """
+
+    _ASCEND_MS_DIR = "{}_{}_ascend_ms"
+    MAX_WORKER_NAME_LENGTH = 226
+
+    def __init__(self):
+        self._prof_ctx = ProfilerContext()
+        self._worker_name = None
+        self._dir_path = None
+
+    def init(self, worker_name: str = None, dir_name: str = None) -> None:
+        """
+        Init the profiler path.
+        """
+        valid_wk_name = worker_name and isinstance(worker_name, str)
+        valid_wk_len = isinstance(worker_name, str) and len(worker_name) < self.MAX_WORKER_NAME_LENGTH
+        if (valid_wk_name and valid_wk_len) or worker_name is None:
+            self._worker_name = worker_name
+        else:
+            logger.warning("Invalid parameter worker_name, reset it to default.")
+            self._worker_name = None
+
+        valid_dir_name = dir_name and isinstance(dir_name, str)
+        if valid_dir_name:
+            dir_path = PathManager.get_real_path(dir_name)
+            PathManager.check_input_directory_path(dir_path)
+            self._dir_path = dir_path
+        elif dir_name is None:
+            self._dir_path = dir_name
+        else:
+            logger.warning(f"Invalid parameter dir_name, reset it to default.")
+            self._dir_path = None
+
+        if self._dir_path:
+            self._prof_ctx.on_trace_ready_output_path = self._dir_path
+
+    def clean_analysis_cache(self):
+        """
+        Clean the profiler analysis cache.
+        """
+        ANALYSIS_CACHE = (
+            # ASEND_PROFILER_OUTPUT_PATH
+            self._prof_ctx.ascend_profiler_output_path,
+            # PROF_XXX/mindstudio_profiler_output
+            self._prof_ctx.msprof_profile_output_path,
+            # PROF_XXX/mindstudio_profiler_log
+            self._prof_ctx.msprof_profile_log_path,
+            # PROF_XXX/host/sqlite
+            os.path.join(self._prof_ctx.msprof_profile_host_path, "sqlite"),
+            # PROF_XXX/host/data/all_file.complete
+            os.path.join(self._prof_ctx.msprof_profile_host_path, "data", "all_file.complete"),
+            # PROF_XXX/device_x/sqlite
+            os.path.join(self._prof_ctx.msprof_profile_device_path, "sqlite"),
+            # PROF_XXX/device_x/data/all_file.complete
+            os.path.join(self._prof_ctx.msprof_profile_device_path, "data", "all_file.complete"),
+        )
+
+        for cache_path in ANALYSIS_CACHE:
+            if os.path.isfile(cache_path):
+                PathManager.remove_file_safety(cache_path)
+            elif os.path.isdir(cache_path):
+                PathManager.remove_path_safety(cache_path)
+
+    def simplify_data(self):
+        """
+        Simplify the profiler data.
+        """
+        SIMPLIFY_CACHE = (
+            # PROF_XXX/mindstudio_profiler_output
+            self._prof_ctx.msprof_profile_output_path,
+            # PROF_XXX/mindstudio_profiler_log
+            self._prof_ctx.msprof_profile_log_path,
+            # PROF_XXX/host/sqlite
+            os.path.join(self._prof_ctx.msprof_profile_host_path, "sqlite"),
+            # PROF_XXX/host/data/all_file.complete
+            os.path.join(self._prof_ctx.msprof_profile_host_path, "data", "all_file.complete"),
+            # PROF_XXX/device_x/sqlite
+            os.path.join(self._prof_ctx.msprof_profile_device_path, "sqlite"),
+            # PROF_XXX/device_x/data/all_file.complete
+            os.path.join(self._prof_ctx.msprof_profile_device_path, "data", "all_file.complete"),
+        )
+
+        for cache_path in SIMPLIFY_CACHE:
+            if os.path.isfile(cache_path):
+                PathManager.remove_file_safety(cache_path)
+            elif os.path.isdir(cache_path):
+                PathManager.remove_path_safety(cache_path)
+
+    def move_db_file(self):
+        """
+        Copy the db file to the output path.
+        """
+        if not self._prof_ctx.msprof_profile_output_path:
+            return
+        db_files = glob.glob(os.path.join(
+            os.path.dirname(self._prof_ctx.msprof_profile_output_path),
+            'msprof*.db'
+        )) + glob.glob(os.path.join(
+            os.path.dirname(self._prof_ctx.msprof_profile_output_path),
+            "analyze",
+            "communication_analyzer.db"
+        ))
+        for db_file in db_files:
+            if os.path.isfile(db_file):
+                db_file_name = os.path.basename(db_file)
+                if db_file_name == "communication_analyzer.db":
+                    new_file_name = os.path.join(self._prof_ctx.ascend_profiler_output_path, db_file_name)
+                    shutil.copy(db_file, new_file_name)
+                else:
+                    new_file_name = f"ascend_mindspore_profiler_{self._prof_ctx.rank_id}.db" if self._prof_ctx.rank_id \
+                        else f"ascend_mindspore_profiler.db"
+                    new_file_path = os.path.join(self._prof_ctx.ascend_profiler_output_path, new_file_name)
+                    shutil.move(db_file, new_file_path)
+
+
+    def create_output_path(self):
+        """
+        Create ASCEND_PROFILER_OUTPUT dir, this method should call before analysis
+        """
+        PathManager.make_dir_safety(self._prof_ctx.ascend_profiler_output_path)
+
+    def set_ascend_ms_dir(self):
+        """
+        reset xxx_ascend_ms name
+        """
+        self._prof_ctx.ascend_ms_dir = self._get_ascend_ms_dir()
+
+    def create_profiler_paths(self):
+        """
+        Create xxx_ascend_ms and FRAMEWORK dir, this method should call before Profiler start
+        """
+        PathManager.make_dir_safety(self._prof_ctx.ascend_ms_dir)
+        PathManager.make_dir_safety(self._prof_ctx.framework_path)
+        logger.info(
+            "Profiler ascend_ms_dir initialized: %s", self._prof_ctx.ascend_ms_dir
+        )
+
+    def _get_ascend_ms_dir(self) -> str:
+        """
+        Generate xxx_ascend_ms name
+        """
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d%H%M%S%f")[:-3]
+        if not self._worker_name:
+            worker_name = f"{socket.gethostname()}_{os.getpid()}"
+        else:
+            worker_name = f"{self._worker_name}_{os.getpid()}"
+
+        return self._ASCEND_MS_DIR.format(worker_name, timestamp)

mindspore/profiler/common/record_function.py

@@ -0,0 +1,76 @@
+# Copyright 2024-2025 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.
+# ====================
+"""Record Function"""
+
+from mindspore._c_expression import PythonProfilerRecorder
+
+
+class RecordFunction:
+    """
+    A context manager for recording profiling data using PythonProfilerRecorder.
+
+    This class provides a convenient way to start and stop recording profiling data
+    using a PythonProfilerRecorder instance. It can be used as a context manager to
+    ensure that recording is properly started and stopped, even if an exception occurs.
+
+    Attributes:
+        recorder (PythonProfilerRecorder): The underlying profiler recorder instance.
+
+    Methods:
+        start(): Starts the recording process.
+        stop(): Stops the recording process.
+        __enter__(): Starts the recording process when entering a with statement.
+        __exit__(exc_type): Stops the recording process when exiting a with statement.
+    """
+
+    def __init__(self, name):
+        """
+        Initializes a new instance of RecordFunction.
+
+        Args:
+            name (str): The name of the profiling record.
+        """
+        self.recorder = PythonProfilerRecorder(name)
+
+    def start(self):
+        """
+        Starts the recording process.
+
+        """
+        self.recorder.record_start()
+
+    def stop(self):
+        """
+        Stops the recording process.
+
+        """
+        self.recorder.record_end()
+
+    def __enter__(self) -> None:
+        """
+        Starts the recording process when entering a with statement.
+
+        """
+        self.start()
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        """
+        Stops the recording process when exiting a with statement.
+
+        Args:
+            exc_type (type): The type of exception that occurred, if any.
+
+        """
+        self.stop()

mindspore/profiler/common/tlv_decoder.py

@@ -0,0 +1,76 @@
+# 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.common.constant import FileConstant
+
+
+class TLVDecoder:
+    """
+    The class of TLV format data decoder.
+    """
+    _TYPE_LEN = 2
+    _LENGTH_LEN = 4
+
+    @classmethod
+    def decode(cls, all_bytes: bytes, fix_data_formats: any, fix_data_struct_size: int) -> List:
+        """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[FileConstant.FIX_SIZE_DATA] = struct.unpack(fix_data_formats, fix_data_bytes)
+            result_data.append(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(f"Failed to decode TLV: type field truncated at index {index}")
+                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(f"Failed to decode TLV: length field truncated at index {index}")
+                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(f"Failed to decode TLV: value field truncated at index {index}")
+                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/common/util.py

@@ -20,13 +20,75 @@ This module provides the utils.
 import os
 import time
 from functools import wraps
-
-# one sys count takes 10 ns, 1 ms has 100000 system count
+from typing import Any, Callable, Type, Tuple, Union
 import re
 import shutil
 import stat
 
 from mindspore import log as logger
+from mindspore.profiler.common.path_manager import PathManager
+from mindspore.profiler.common.exceptions.exceptions import ProfilerPathErrorException
+
+
+def no_exception_func(
+        default_ret: Any = None,
+        exception_types: Union[Type[Exception], Tuple[Type[Exception], ...]] = Exception,
+        custom_handler: Callable[[Exception], Any] = None
+) -> Callable[[Callable], Callable]:
+    """
+    A decorator that catches specified exceptions and handles them gracefully.
+
+    Args:
+        default_ret (Any, optional): The default return value if an exception occurs. Defaults to None.
+        exception_types (Union[Type[Exception], Tuple[Type[Exception], ...]], optional):
+            The type(s) of exceptions to catch. Defaults to Exception.
+        custom_handler (Callable[[Exception], Any], optional):
+            A custom function to handle the caught exception. Defaults to None.
+
+    Returns:
+        Callable[[Callable], Callable]: A decorator function.
+
+    Example:
+        @no_exception_func(default_ret=0, exception_types=(ValueError, TypeError))
+        def divide(a, b):
+            return a / b
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return func(*args, **kwargs)
+            except exception_types as ex: # pylint: disable=W0703
+                if custom_handler:
+                    return custom_handler(ex)
+
+                logger.error(f"Call to {func.__name__} failed. Exception: {str(ex)}")
+                return default_ret
+        return wrapper
+    return decorator
+
+
+def get_cann_version():
+    """
+    get cann version from env
+    """
+    ascend_home_path = os.environ.get("ASCEND_HOME_PATH", "")
+    cann_version = "not known"
+    try:
+        PathManager.check_directory_path_readable(os.path.realpath(ascend_home_path))
+        for dirpath, _, filenames in os.walk(os.path.realpath(ascend_home_path)):
+            install_files = [file for file in filenames if re.match(r"ascend_.{1,20}_install\.info", file)]
+            if install_files:
+                filepath = os.path.realpath(os.path.join(dirpath, install_files[0]))
+                PathManager.check_directory_path_readable(filepath)
+                with open(filepath, "r") as f:
+                    for line in f:
+                        if line.find("version") != -1:
+                            cann_version = line.strip().split("=")[-1]
+                            break
+    except ProfilerPathErrorException as e:
+        logger.warning(f"Failed to read CANN version from {ascend_home_path}: {e}")
+    return cann_version
 
 
 def timeit(custom_message=None):
@@ -55,6 +117,17 @@ def timeit(custom_message=None):
 
     return decorator
 
+
+def print_msg_with_pid(msg):
+    """
+    Print message with process id.
+
+    Args:
+        msg (str): The message to print.
+    """
+    print(f"[{os.getpid()}] {msg}", flush=True)
+
+
 def to_int(param, param_name):
     """
     Transfer param to int type.