mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0rc1__cp39-cp39-win_amd64.whl

mindspore/profiler/common/profiler_info.py

@@ -0,0 +1,304 @@
+# 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 Info"""
+import os
+from typing import Dict, Any
+from configparser import ConfigParser, NoSectionError, NoOptionError
+
+from mindspore import log as logger
+from mindspore.version import __version__ as ms_version
+from mindspore.profiler.common.util import get_cann_version
+from mindspore.profiler.common.singleton import Singleton
+from mindspore.profiler.common.file_manager import FileManager
+from mindspore.profiler.common.path_manager import PathManager
+from mindspore.profiler.common.msprof_cmd_tool import MsprofCmdTool
+
+
+@Singleton
+class ProfilerInfo:
+    """
+    Profiler Info
+    This class is used to record profiler information.
+
+    Example:
+    {
+        "profiler_parameters": {
+        },
+        "ms_profiler_info": {
+            "start_collect_syscnt": xxx,
+            "start_collect_clock_time": xxx,
+        },
+        "cann_profiler_info": {
+        },
+        "ms_version": "x.x.x",
+        "cann_version": x.x.x",
+    }
+    """
+    HOST_START_LOG = "host_start.log"
+    START_INFO = "start_info"
+    MSPROF_INFO_SCRIPT_PATH = os.path.join(
+        "tools",
+        "profiler",
+        "profiler_tool",
+        "analysis",
+        "interface",
+        "get_msprof_info.py",
+    )
+
+    PROFILER_INFO_FILE = "profiler_info_{}.json"
+    PROFILER_PARAMETERS = "profiler_parameters"
+    MS_PROFILER_INFO = "ms_profiler_info"
+    CANN_PROFILER_INFO = "cann_profiler_info"
+    ANALYSIS_COST_TIME = "analysis_cost_time"
+    MS_VERSION = "ms_version"
+    CANN_VERSION = "cann_version"
+    CONTEXT_MODE = "context_mode"
+    JIT_LEVEL = "jit_level"
+
+    US_TO_NS = 1000
+
+    def __init__(self):
+        self._profiler_info = {
+            self.PROFILER_PARAMETERS: {},
+            self.MS_PROFILER_INFO: {},
+            self.CANN_PROFILER_INFO: {},
+            self.ANALYSIS_COST_TIME: {},
+            self.MS_VERSION: ms_version,
+            self.CANN_VERSION: get_cann_version(),
+            self.CONTEXT_MODE: -1,
+            self.JIT_LEVEL: "",
+        }
+        # time params
+        self._freq = 100.0
+        self._cntvct = 0
+        self._clock_monotonic_raw = 0 # from host start log
+        self._collection_time_begin = 0
+        self._clock_monotonic_raw_info = 0 # from start info file
+        self._localtime_diff = 0
+
+    def load_info(self, info_file_path: str) -> None:
+        """"
+        Load profiler info from profiler_info_*.json path.
+        """
+        self._profiler_info = FileManager.read_json_file(info_file_path)
+
+    def load_time_parameters(self, msprof_profile_path: str, msprof_profile_host_path: str) -> None:
+        """
+        Load time parameters from msprof profile and host start log.
+        This method should be called before TimeConverter.init_parameters.
+        """
+        if not msprof_profile_path or not msprof_profile_host_path:
+            raise ValueError(
+                "msprof_profile_path and msprof_profile_host_path must be provided"
+            )
+        self._read_host_start_log(msprof_profile_host_path)
+        self._read_start_info(msprof_profile_host_path)
+        self._get_freq_from_msprof(msprof_profile_path)
+
+    @property
+    def time_parameters(self) -> Dict[str, Any]:
+        """
+        Get time parameters for TimeConverter.
+        """
+        return {
+            "freq": self._freq,
+            "cntvct": self._cntvct,
+            "localtime_diff": self._localtime_diff
+        }
+
+    @property
+    def profiler_parameters(self) -> Dict[str, str]:
+        """
+        Get profiler parameters.
+        """
+        return self._profiler_info[self.PROFILER_PARAMETERS]
+
+    @profiler_parameters.setter
+    def profiler_parameters(self, value: dict):
+        """
+        Set profiler parameters.
+        """
+        self._profiler_info[self.PROFILER_PARAMETERS] = value
+
+    @property
+    def context_mode(self) -> int:
+        """
+        Get context mode.
+        """
+        return self._profiler_info[self.CONTEXT_MODE]
+
+    @context_mode.setter
+    def context_mode(self, value: int):
+        """
+        Set context mode.
+        """
+        self._profiler_info[self.CONTEXT_MODE] = value
+
+    @property
+    def jit_level(self) -> str:
+        """
+        Get jit level.
+        """
+        return self._profiler_info[self.JIT_LEVEL]
+
+    @jit_level.setter
+    def jit_level(self, value: str):
+        """
+        Set jit level.
+        """
+        self._profiler_info[self.JIT_LEVEL] = value
+
+    @property
+    def ms_profiler_info(self) -> Dict[str, str]:
+        """
+        Get ms profiler info.
+        """
+        return self._profiler_info[self.MS_PROFILER_INFO]
+
+    @ms_profiler_info.setter
+    def ms_profiler_info(self, value: dict):
+        """
+        Set ms profiler info.
+        """
+        self._profiler_info[self.MS_PROFILER_INFO] = value
+
+    def save(self, output_path: str, rank_id: int):
+        """
+        Save profiler info to json file.
+        """
+        if not output_path:
+            logger.warning("Output path is empty, please check the output path.")
+            return
+
+        FileManager.create_json_file(
+            output_file_path=os.path.join(
+                output_path, self.PROFILER_INFO_FILE.format(rank_id)
+            ),
+            json_data=self._profiler_info,
+            indent=4,
+        )
+
+    def _read_host_start_log(self, host_path: str) -> None:
+        """
+        Read host_start.log and get clock_monotonic_raw and cntvct
+
+        host_start.log format:
+        [Host]
+        clock_monotonic_raw = 1234567890
+        cntvct = 1234567890
+        cntvct_diff = 1234567890
+        """
+        start_log_path = os.path.join(host_path, self.HOST_START_LOG)
+        PathManager.check_input_file_path(start_log_path)
+
+        cfg = ConfigParser()
+        try:
+            cfg.read(start_log_path)
+        except Exception as err: # pylint: disable=W0703
+            raise ValueError(f"Error parsing host start log file: {err}") from err
+
+        try:
+            self._clock_monotonic_raw = int(cfg.get("Host", "clock_monotonic_raw"))
+            self._cntvct = int(cfg.get("Host", "cntvct"))
+        except NoSectionError as err:
+            raise ValueError("'Host' section not found in host start log file") from err
+        except NoOptionError as err:
+            raise ValueError(f"Required option not found in host start log file: {err}") from err
+        except ValueError as err:
+            raise ValueError(f"Invalid data in host start log file: {err}") from err
+
+        if self._clock_monotonic_raw <= 0 or self._cntvct <= 0:
+            raise ValueError(
+                "Invalid clock_monotonic_raw or cntvct value must be positive"
+            )
+
+    def _read_start_info(self, host_path: str) -> None:
+        """
+        Read start_info file and calculate localtime_diff.
+
+        Raises:
+            FileNotFoundError: If the start_info file is not found.
+            ValueError: If required data is missing or invalid in the file.
+            JSONDecodeError: If there's an error decoding the JSON file.
+        """
+        start_info_path = os.path.join(host_path, self.START_INFO)
+        info_data = FileManager.read_json_file(start_info_path)
+
+        try:
+            self._collection_time_begin = int(
+                info_data.get("collectionTimeBegin", 0)
+            )  # us
+            self._clock_monotonic_raw_info = int(info_data.get("clockMonotonicRaw", 0))
+        except ValueError as err:
+            raise ValueError(f"Invalid data in start info file: {err}") from err
+
+        if self._collection_time_begin <= 0 or self._clock_monotonic_raw_info <= 0:
+            raise ValueError(
+                "Invalid collectionTimeBegin or clockMonotonicRaw value must be positive"
+            )
+
+        self._localtime_diff = self._clock_monotonic_raw + (
+            self._collection_time_begin * self.US_TO_NS - self._clock_monotonic_raw_info
+        )
+
+    def _get_freq_from_msprof(self, msprof_profile_path: str) -> None:
+        """
+        Get frequency from get_msprof_info.py script
+
+        script return json information:
+        {
+            "data": {
+                "host_info": {
+                    "cpu_info": [{"Frequency": "100.0000"}]
+                }
+            }
+        }
+        """
+        msprof_info = MsprofCmdTool(msprof_profile_path).get_msprof_info()
+
+        if not isinstance(msprof_info, dict):
+            raise RuntimeError("msprof_info must be a dictionary")
+
+        data = msprof_info.get("data")
+        if not isinstance(data, dict):
+            raise RuntimeError("msprof_info['data'] must be a dictionary")
+
+        host_info = data.get("host_info")
+        if not isinstance(host_info, dict):
+            raise RuntimeError("msprof_info['data']['host_info'] must be a dictionary")
+
+        cpu_info_list = host_info.get("cpu_info", [])
+        if not isinstance(cpu_info_list, list) or not cpu_info_list:
+            raise RuntimeError("cpu_info must be a non-empty list")
+
+        cpu_info = cpu_info_list[0]
+        if not isinstance(cpu_info, dict):
+            raise RuntimeError("cpu_info[0] must be a dictionary")
+
+        freq_str = cpu_info.get("Frequency", self._freq)
+        if not freq_str:
+            logger.warning("Frequency is empty, use default frequency: %s", str(self._freq))
+            return
+
+        try:
+            freq = float(freq_str)
+        except ValueError as e:
+            raise ValueError(
+                "Convert frequency to float failed, please check msprof information"
+            ) from e
+
+        if freq <= 0.0:
+            raise ValueError("Frequency is invalid, please check msprof info")
+        self._freq = freq

mindspore/profiler/common/profiler_meta_data.py

@@ -0,0 +1,74 @@
+# 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.
+# ============================================================================
+"""Profiler Meta Data"""
+import os
+from typing import Dict
+
+import mindspore.communication as comm
+from mindspore.profiler.common.constant import DeviceTarget
+from mindspore.profiler.common.profiler_context import ProfilerContext
+import mindspore.communication._comm_helper as comm_helper
+from mindspore.profiler.common.file_manager import FileManager
+from mindspore import log as logger
+
+
+class ProfilerMetaData:
+    """
+        Profiler MetaData
+        This class is used to handle metadata.
+    """
+    metadata: Dict[str, str] = {}
+
+    @classmethod
+    def get_metadata(cls) -> Dict[str, str]:
+        """Get metadata"""
+        return cls.metadata
+
+    @classmethod
+    def set_metadata(cls, value: Dict[str, str]):
+        """Set metadata"""
+        cls.metadata = value
+
+    @classmethod
+    def dump_metadata(cls):
+        """Dump metadata to file."""
+        cls.add_group_info_to_metadata()
+        if not cls.metadata:
+            return
+        save_path = os.path.join(ProfilerContext().ascend_ms_dir, "profiler_metadata.json")
+        FileManager.create_json_file(save_path, cls.metadata)
+        cls.metadata.clear()
+
+    @classmethod
+    def add_group_info_to_metadata(cls):
+        """Add parallel group info to metadata"""
+        try:
+            if ProfilerContext().device_target == DeviceTarget.NPU.value and comm.GlobalComm.INITED \
+                    and comm.GlobalComm.BACKEND == comm_helper.Backend.HCCL:
+                group_info = {}
+                # pylint: disable=protected-access
+                for group_name in comm_helper._get_group_map().keys():
+                    comm_name = comm.get_comm_name(group_name)
+                    if not comm_name:
+                        continue
+                    group_info[comm_name] = {
+                        "group_name": group_name,
+                        "group_rank": comm.get_local_rank(group_name),
+                        "global_ranks": comm.get_process_group_ranks(group_name)
+                    }
+                if group_info:
+                    cls.metadata.update({"parallel_group_info": group_info})
+        except Exception as err:    # pylint: disable=broad-except
+            logger.error(f"Failed to get parallel group info, Exception: {str(err)}")

mindspore/profiler/common/profiler_output_path.py

@@ -0,0 +1,284 @@
+# 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 output path"""
+import os
+from typing import Any, Dict, Optional
+from mindspore.profiler.common.path_manager import PathManager
+
+
+class ProfilerOutputPath:
+    """
+    Profiler output path structure:
+
+    └── output_path
+        └── {}_ascend_ms  # rank 0
+                └── ASCEND_PROFILER_OUTPUT
+                └── FRAMEWORK
+                └── PROF_{}
+                        └── host
+                        └── device_{}
+                        └── mindstudio_profiler_log
+                        └── mindstudio_profiler_output
+        └── {}_ascend_ms  # rank 1
+                └── ASCEND_PROFILER_OUTPUT
+                └── FRAMEWORK
+                └── PROF_{}
+                        └── host
+                        └── device_{}
+                        └── mindstudio_profiler_log
+                        └── mindstudio_profiler_output
+    """
+
+    _ASCEND_PROFILER_OUTPUT = "ASCEND_PROFILER_OUTPUT"
+    _FRAMEWORK = "FRAMEWORK"
+    _MINISTUDIO_PROFILER_HOST = "host"
+    _MINISTUDIO_PROFILER_DEVICE = "device_{}"
+    _MINISTUDIO_PROFILER_LOG = "mindstudio_profiler_log"
+    _MINISTUDIO_PROFILER_OUTPUT = "mindstudio_profiler_output"
+    _MINISTUDIO_ANALYZE_OUTPUT = "analyze"
+
+    def __init__(self, rank_id: int, device_id: int):
+        if not isinstance(rank_id, int) or not isinstance(device_id, int):
+            raise ValueError("rank_id and device_id must be integers")
+
+        self._rank_id = rank_id
+        self._device_id = device_id
+        self._output_path: Optional[str] = None
+        self._ascend_ms_dir: Optional[str] = None
+        self._ascend_profiler_output_path: Optional[str] = None
+        self._framework_path: Optional[str] = None
+
+        # PROF_{} and its subdirectories
+        self._msprof_profile_path: Optional[str] = None
+        self._msprof_profile_host_path: Optional[str] = None
+        self._msprof_profile_device_path: Optional[str] = None
+        self._msprof_profile_log_path: Optional[str] = None
+        self._msprof_profile_output_path: Optional[str] = None
+        self._msprof_analyze_output_path: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the profiler parameters to a dictionary.
+        """
+        return {
+            "output_path": self._output_path,
+            "ascend_ms_dir": self._ascend_ms_dir,
+            "ascend_profiler_output_path": self._ascend_profiler_output_path,
+            "framework_path": self._framework_path,
+            "msprof_profile_path": self._msprof_profile_path,
+            "msprof_profile_host_path": self._msprof_profile_host_path,
+            "msprof_profile_device_path": self._msprof_profile_device_path,
+            "msprof_profile_log_path": self._msprof_profile_log_path,
+            "msprof_profile_output_path": self._msprof_profile_output_path,
+            "msprof_analyze_output_path": self._msprof_analyze_output_path,
+        }
+
+    @property
+    def output_path(self) -> str:
+        """
+        Get the output path, which is the parent directory of all profiler output paths.
+        Set by Profiler output_path parameter.
+
+        Returns:
+            str: The output path.
+
+        Raises:
+            ValueError: If output_path has not been set.
+        """
+        if self._output_path is None:
+            raise ValueError("output_path has not been set")
+        return self._output_path
+
+    @property
+    def ascend_ms_dir(self) -> str:
+        """
+        Get the Ascend MS directory, which is each rank's output path.
+
+        Returns:
+            str: The Ascend MS directory, eg. output_path/xxxx_ascend_ms
+
+        Raises:
+            ValueError: If ascend_ms_dir has not been set.
+        """
+        if self._ascend_ms_dir is None:
+            raise ValueError("ascend_ms_dir has not been set")
+        return self._ascend_ms_dir
+
+    @property
+    def ascend_profiler_output_path(self) -> str:
+        """
+        Get the MindSpore Profiler official deliverables output path.
+
+        Returns:
+            str: The MindSpore Profiler official deliverables output path.
+            eg. ascend_ms_dir/ASCEND_PROFILER_OUTPUT
+
+        Raises:
+            ValueError: If ascend_profiler_output_path has not been set.
+        """
+        if self._ascend_profiler_output_path is None:
+            raise ValueError("ascend_profiler_output_path has not been set")
+        return self._ascend_profiler_output_path
+
+    @property
+    def framework_path(self) -> str:
+        """
+        Get the framework path, which is the intermediate directory of framework profiling data.
+
+        Returns:
+            str: The framework path. eg. ascend_ms_dir/FRAMEWORK
+
+        Raises:
+            ValueError: If framework_path has not been set.
+        """
+        if self._framework_path is None:
+            raise ValueError("framework_path has not been set")
+        return self._framework_path
+
+    @property
+    def msprof_profile_path(self) -> str:
+        """
+        Get the PROF_XXX path, which is the directory of msprof profiling data.
+
+        Returns:
+            str: The MSProf profile path. eg. ascend_ms_dir/PROF_XXX
+
+        Raises:
+            ValueError: If msprof_profile_path has not been set.
+        """
+        if self._msprof_profile_path is None:
+            raise ValueError("msprof_profile_path has not been set")
+        return self._msprof_profile_path
+
+    @property
+    def msprof_profile_host_path(self) -> str:
+        """
+        Get the msprof host path.
+
+        Returns:
+            str: The msprof host path. eg. ascend_ms_dir/PROF_XXX/host
+
+        Raises:
+            ValueError: If msprof_profile_host_path has not been set.
+        """
+        if self._msprof_profile_host_path is None:
+            raise ValueError("msprof_profile_host_path has not been set")
+        return self._msprof_profile_host_path
+
+    @property
+    def msprof_profile_device_path(self) -> str:
+        """
+        Get the msprof device path.
+
+        Returns:
+            str: The msprof device path. eg. ascend_ms_dir/PROF_XXX/device_X
+
+        Raises:
+            ValueError: If msprof_profile_device_path has not been set.
+        """
+        if self._msprof_profile_device_path is None:
+            raise ValueError("msprof_profile_device_path has not been set")
+        return self._msprof_profile_device_path
+
+    @property
+    def msprof_profile_log_path(self) -> str:
+        """
+        Get the msprof log path.
+
+        Returns:
+            str: The msprof log path. eg. ascend_ms_dir/PROF_XXX/mindstudio_profiler_log
+
+        Raises:
+            ValueError: If msprof_profile_log_path has not been set.
+        """
+        if self._msprof_profile_log_path is None:
+            raise ValueError("msprof_profile_log_path has not been set")
+        return self._msprof_profile_log_path
+
+    @property
+    def msprof_profile_output_path(self) -> str:
+        """
+        Get the msprof official deliverables output path.
+
+        Returns:
+            str: The msprof official deliverables output path.
+            eg. ascend_ms_dir/PROF_XXX/mindstudio_profiler_output
+
+        Raises:
+            ValueError: If msprof_profile_output_path has not been set.
+        """
+        if self._msprof_profile_output_path is None:
+            raise ValueError("msprof_profile_output_path has not been set")
+        return self._msprof_profile_output_path
+
+    @property
+    def msprof_analyze_output_path(self) -> str:
+        """
+        Get the msprof analyze output path.
+
+        Returns:
+            str: The msprof analyze output path.
+            eg. ascend_ms_dir/PROF_XXX/analyze
+
+        Raises:
+            ValueError: If msprof_analyze_output_path has not been set.
+        """
+        if self._msprof_analyze_output_path is None:
+            raise ValueError("msprof_analyze_output_path has not been set")
+        return self._msprof_analyze_output_path
+
+    @output_path.setter
+    def output_path(self, value: str):
+        """Set the output path."""
+        real_path = PathManager.get_real_path(value)
+        PathManager.check_input_directory_path(real_path)
+        self._output_path = real_path
+
+    @ascend_ms_dir.setter
+    def ascend_ms_dir(self, value: str):
+        """Set the xxx_ascend_ms directory."""
+        if self._output_path is None:
+            raise ValueError("output_path has not been set")
+
+        self._ascend_ms_dir = os.path.join(self._output_path, value)
+        self._ascend_profiler_output_path = os.path.join(
+            self._ascend_ms_dir, ProfilerOutputPath._ASCEND_PROFILER_OUTPUT
+        )
+        self._framework_path = os.path.join(
+            self._ascend_ms_dir, ProfilerOutputPath._FRAMEWORK
+        )
+
+    @msprof_profile_path.setter
+    def msprof_profile_path(self, value: str):
+        """Set the PROF_XXX path."""
+        if self._ascend_ms_dir is None:
+            raise ValueError("ascend_ms_dir has not been set")
+        self._msprof_profile_path = value
+        self._msprof_profile_host_path = os.path.join(
+            self._msprof_profile_path, ProfilerOutputPath._MINISTUDIO_PROFILER_HOST
+        )
+        self._msprof_profile_device_path = os.path.join(
+            self._msprof_profile_path,
+            ProfilerOutputPath._MINISTUDIO_PROFILER_DEVICE.format(self._device_id)
+        )
+        self._msprof_profile_log_path = os.path.join(
+            self._msprof_profile_path, ProfilerOutputPath._MINISTUDIO_PROFILER_LOG
+        )
+        self._msprof_profile_output_path = os.path.join(
+            self._msprof_profile_path, ProfilerOutputPath._MINISTUDIO_PROFILER_OUTPUT
+        )
+        self._msprof_analyze_output_path = os.path.join(
+            self._msprof_profile_path, ProfilerOutputPath._MINISTUDIO_ANALYZE_OUTPUT
+        )