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

mindspore/profiler/envprofiler.py

@@ -0,0 +1,163 @@
+# 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.
+# ============================================================================
+"""EnvProfiler"""
+import os
+import json
+from mindspore import log as logger
+from mindspore.profiler.profiler import Profiler
+from mindspore.profiler.common.constant import (
+    ProfilerLevel,
+    AicoreMetrics,
+    ProfilerActivity,
+    ExportType,
+)
+from mindspore.profiler.common.profiler_parameters import ProfilerParameters
+
+
+class EnvProfiler:
+    """Collect and analyze training performance data, support calls during and after training."""
+
+    NOT_SUPPORTED_PARAMS = ["schedule", "on_trace_ready"]
+    profiler = None
+
+    @classmethod
+    def init_profiler(cls):
+        """
+        Initialize the profiler.
+        """
+        if not os.getenv("MS_PROFILER_OPTIONS"):
+            return
+        options = cls._load_options()
+        if not options:
+            logger.error("Failed to load MS_PROFILER_OPTIONS, json decode error.")
+            return
+
+        params = cls._convert_options_to_profiler_params(options)
+        logger.info(f"params: {params}")
+        if params["start_profile"]:
+            cls.profiler = Profiler(**params)
+            logger.info("Profiler init success.")
+
+    def analyse(self):
+        """
+        Analyze the collected data.
+        """
+        logger.info("analyse start")
+        if not self.profiler:
+            logger.info("Profiler is not initialized, skip analyse.")
+            return
+        self.profiler.analyse()
+        logger.info("analyse end")
+
+    @classmethod
+    def _load_options(cls):
+        """
+        Load the options from the environment variable.
+        """
+        try:
+            options = json.loads(os.environ.get("MS_PROFILER_OPTIONS", "{}"))
+        except json.JSONDecodeError:
+            return {}
+        return options
+
+    @classmethod
+    def _convert_option_to_enum_value(cls, enum_class, option_value, default_value):
+        """
+        Convert the option value to the enum value.
+        """
+        try:
+            return enum_class(option_value)
+        except ValueError:
+            logger.warning(
+                f"The value '{option_value}' of parameter '{enum_class.__name__}' is invalid, "
+                f"use default value '{default_value}' instead."
+            )
+            return default_value
+
+    @classmethod
+    def _convert_options_to_profiler_params(cls, options):
+        """
+        Convert the options to the profiler parameters.
+        """
+        params = {}
+        if not options:
+            logger.warning("MS_PROFILER_OPTIONS is empty, use default values.")
+            return params
+
+        if "output_path" in options:
+            params["output_path"] = options["output_path"]
+
+        # if start is not set, default is False
+        params["start_profile"] = options.get("start", False)
+
+        for param, (_, default_value) in ProfilerParameters.PARAMS.items():
+            if param in options and param not in cls.NOT_SUPPORTED_PARAMS:
+                if param == "activities" and isinstance(options[param], list):
+                    params[param] = cls._convert_activities_to_list(
+                        options[param], default_value
+                    )
+                elif param == "aic_metrics":
+                    params[param] = cls._convert_option_to_enum_value(
+                        AicoreMetrics, options[param], default_value
+                    )
+                elif param == "profiler_level":
+                    params[param] = cls._convert_option_to_enum_value(
+                        ProfilerLevel, options[param], default_value
+                    )
+                elif param == "export_type":
+                    params[param] = cls._convert_export_type_to_list(
+                        options[param], default_value
+                    )
+                else:
+                    params[param] = options[param]
+        return params
+
+    @classmethod
+    def _convert_activities_to_list(cls, activities, default_value):
+        """
+        Convert the activities to the list.
+        """
+        res = []
+        for activity in activities:
+            res.append(
+                cls._convert_option_to_enum_value(
+                    ProfilerActivity, activity, default_value
+                )
+            )
+        # remove duplicate
+        return list(set(default_value if default_value in res else res))
+
+    @classmethod
+    def _convert_export_type_to_list(cls, export_types, default_value) -> list:
+        """
+        Check the export type to the list.
+        """
+        res = []
+        for export_type in export_types:
+            if export_type != "text" and export_type != "db":
+                logger.warning(
+                    f"The value '{export_type}' of parameter '{ExportType.__name__}' is invalid, "
+                    f"use default value '{default_value}' instead."
+                )
+                return default_value
+            res.append(
+                cls._convert_option_to_enum_value(
+                    ExportType, export_type, default_value
+                )
+            )
+        # remove duplicate
+        return list(set(res))
+
+EnvProfiler.init_profiler()

mindspore/profiler/experimental_config.py

@@ -0,0 +1,197 @@
+# Copyright 2020-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.
+# ============================================================================
+"""Experimental config file."""
+
+from mindspore.profiler.common.constant import ProfilerLevel, AicoreMetrics
+
+__all__ = ["_ExperimentalConfig"]
+
+
+class _ExperimentalConfig:
+    r"""
+    The purpose of this class is to configure scalable parameters when using profiles for model
+    performance data acquisition.
+
+    Args:
+        profiler_level (ProfilerLevel, optional): (Ascend only) The level of profiling.
+            Default: ``ProfilerLevel.Level0``.
+
+            - ProfilerLevel.LevelNone: This setting takes effect only when mstx is enabled, indicating that no
+              operator data is collected on the device side.
+            - ProfilerLevel.Level0: Leanest level of profiling data collection, collects information about the elapsed
+              time of the computational operators on the NPU and communication large operator information.
+            - ProfilerLevel.Level1: Collect more CANN layer AscendCL data and AICore performance metrics and
+              communication mini operator information based on Level0.
+            - ProfilerLevel.Level2: Collect GE and Runtime information in CANN layer on top of Level1
+        aic_metrics (AicoreMetrics, optional): (Ascend only) Types of AICORE performance data collected,
+            when using this parameter, `activities` must include ``ProfilerActivity.NPU`` , and the value
+            must be a member of AicoreMetrics. When profiler_level is Level0, the default value is
+            ``AicoreMetrics.AiCoreNone``; Profiler_level is a Level1 or Level2 stores, the default value is:
+            ``AicoreMetrics. PipeUtilization``.The data items contained in each metric are as follows:
+
+            - AicoreMetrics.AiCoreNone: Does not collect AICORE data.
+            - AicoreMetrics.ArithmeticUtilization: ArithmeticUtilization contains mac_fp16/int8_ratio,
+              vec_fp32/fp16/int32_ratio, vec_misc_ratio etc.
+            - AicoreMetrics.PipeUtilization: PipeUtilization contains vec_ratio, mac_ratio, scalar_ratio,
+              mte1/mte2/mte3_ratio, icache_miss_rate etc.
+            - AicoreMetrics.Memory: Memory contains ub_read/write_bw, l1_read/write_bw, l2_read/write_bw,
+              main_mem_read/write_bw etc.
+            - AicoreMetrics.MemoryL0: MemoryL0 contains l0a_read/write_bw, l0b_read/write_bw, l0c_read/write_bw etc.
+            - AicoreMetrics.ResourceConflictRatio: ResourceConflictRatio contains vec_bankgroup/bank/resc_cflt_ratio
+              etc.
+            - AicoreMetrics.MemoryUB: MemoryUB contains ub_read/write_bw_mte, ub_read/write_bw_vector,
+              ub\_read/write_bw_scalar etc.
+            - AicoreMetrics.L2Cache: L2Cache contains write_cache_hit, write_cache_miss_allocate, r0_read_cache_hit,
+              r1_read_cache_hit etc. This function only supports Atlas A2 training series products.
+            - AicoreMetrics.MemoryAccess: Statistics on storage access bandwidth and storage capacity of main
+              storage and l2 cache etc.
+        l2_cache (bool, optional): (Ascend only) Whether to collect l2 cache data, collect when True.
+            Default: ``False`` . The l2_cache.csv file is generated in the ASCEND_PROFILER_OUTPUT folder.In O2 mode,
+            only wait and skip_first parameters in schedule configuration can be set to 0.
+        mstx (bool, optional): (Ascend only) Whether to collect light weight profiling data, collect when True.
+            Default: ``False`` .
+        data_simplification (bool, optional): (Ascend only) Whether to remove FRAMEWORK data and other redundant data.
+            If set to True, only the profiler deliverables and raw performance data under the PROF_XXX directory are
+            kept to save space. Default value: ``True`` .
+        export_type (list, optional): (Ascend only) The data type to export.
+            The db and text formats can be exported at the same time. The default value is ``None``,
+            indicating that data of the text type is exported.
+
+            - ExportType.Text: Export text type data.
+            - ExportType.Db: Export db type data.
+
+    Raises:
+        RuntimeError: When the version of CANN does not match the version of MindSpore,
+            MindSpore cannot parse the generated ascend_job_id directory structure.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import nn, context
+        >>> import mindspore.dataset as ds
+        >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, AicoreMetrics, ExportType
+        >>>
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super(Net, self).__init__()
+        ...         self.fc = nn.Dense(2,2)
+        ...     def construct(self, x):
+        ...         return self.fc(x)
+        >>>
+        >>> def generator():
+        ...     for i in range(2):
+        ...         yield np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32)
+        >>>
+        >>> def train(net):
+        ...     optimizer = nn.Momentum(net.trainable_params(), 1, 0.9)
+        ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+        ...     data = ds.GeneratorDataset(generator, ["data", "label"])
+        ...     model = mindspore.train.Model(net, loss, optimizer)
+        ...     model.train(1, data)
+        >>>
+        >>> if __name__ == '__main__':
+        ...     # If the device_target is GPU, set the device_target to "GPU"
+        ...     context.set_context(mode=mindspore.GRAPH_MODE)
+        ...     mindspore.set_device("Ascend")
+        ...
+        ...     # Init Profiler
+        ...     experimental_config = mindspore.profiler._ExperimentalConfig(
+        ...                                 profiler_level=ProfilerLevel.Level0,
+        ...                                 aic_metrics=AicoreMetrics.AiCoreNone,
+        ...                                 l2_cache=False,
+        ...                                 mstx=False,
+        ...                                 data_simplification=False,
+        ...                                 export_type=[ExportType.Text])
+        ...     steps = 10
+        ...     net = Net()
+        ...     # Note that the Profiler should be initialized before model.train
+        ...     with mindspore.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
+        ...                                     schedule=mindspore.profiler.schedule(wait=1, warmup=1, active=2,
+        ...                                           repeat=1, skip_first=2),
+        ...                                     on_trace_ready=mindspore.profiler.tensorboard_trace_handler("./data"),
+        ...                                     profile_memory=False,
+        ...                                     experimental_config=experimental_config) as prof:
+        ...
+        ...         # Train Model
+        ...         for step in range(steps):
+        ...             train(net)
+        ...             prof.step()
+    """
+
+    def __init__(self,
+                 profiler_level: ProfilerLevel = ProfilerLevel.Level0,
+                 aic_metrics: AicoreMetrics = AicoreMetrics.AiCoreNone,
+                 l2_cache: bool = False,
+                 mstx: bool = False,
+                 data_simplification: bool = True,
+                 export_type: list = None):
+        self._profiler_level = profiler_level
+        self._aic_metrics = aic_metrics
+        self._l2_cache = l2_cache
+        self._mstx = mstx
+        self._data_simplification = data_simplification
+        self._export_type = export_type
+
+    @property
+    def profiler_level(self) -> ProfilerLevel:
+        return self._profiler_level
+
+    @property
+    def aic_metrics(self) -> AicoreMetrics:
+        return self._aic_metrics
+
+    @property
+    def l2_cache(self) -> bool:
+        return self._l2_cache
+
+    @property
+    def mstx(self) -> bool:
+        return self._mstx
+
+    @property
+    def data_simplification(self) -> bool:
+        return self._data_simplification
+
+    @property
+    def export_type(self) -> list:
+        return self._export_type
+
+    # Setters
+    @profiler_level.setter
+    def profiler_level(self, value: ProfilerLevel):
+        self._profiler_level = value
+
+    @aic_metrics.setter
+    def aic_metrics(self, value: AicoreMetrics):
+        self._aic_metrics = value
+
+    @l2_cache.setter
+    def l2_cache(self, value: bool):
+        self._l2_cache = value
+
+    @mstx.setter
+    def mstx(self, value: bool):
+        self._mstx = value
+
+    @data_simplification.setter
+    def data_simplification(self, value: bool):
+        self._data_simplification = value
+
+    @export_type.setter
+    def export_type(self, value: list):
+        self._export_type = value

mindspore/profiler/mstx.py

@@ -0,0 +1,242 @@
+# Copyright 2020-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.
+# ============================================================================
+""" Mstx class for NPU profiling """
+import os
+from os.path import basename
+import mindspore
+import mindspore._c_expression as c_expression
+
+from mindspore import context
+from mindspore import log as logging
+from mindspore.runtime import Stream
+from mindspore.profiler.common.constant import DeviceTarget, CannLibName
+from mindspore.profiler.common.path_manager import PathManager
+
+
+class Mstx:
+    """
+    Mstx class provides profiling tools for marking and tracing on NPU. This class provides three static methods: mark,
+    range_start and range_end for adding marker points and ranges in profiling.
+    """
+
+    NPU_PROFILER = c_expression.Profiler.get_instance(DeviceTarget.NPU.value)
+    enable = any(
+        basename(path) == CannLibName.CANN_MSPTI and PathManager.check_cann_lib_valid(path)
+        for path in os.environ.get("LD_PRELOAD", "").split(":")
+        if path.strip()
+    )
+
+    @staticmethod
+    def mark(message: str, stream: mindspore.runtime.Stream = None) -> None:
+        """Add a marker point in profiling.
+
+        Args:
+            message (str): Description for the marker.
+            stream (:class:`~.runtime.Stream`, optional): NPU stream for async execution, expected type:
+                mindspore.runtime.Stream. Default: ``None``, which means only marking on host side without
+                marking on device stream.
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore as ms
+            >>> import mindspore
+            >>> from mindspore import nn
+            >>> import mindspore.dataset as ds
+            >>> from mindspore import Profiler
+            >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, schedule, tensorboard_trace_handler
+            >>> from mindspore.profiler import mstx
+            >>>
+            >>> class Net(nn.Cell):
+            ...     def __init__(self):
+            ...         super(Net, self).__init__()
+            ...         self.fc = nn.Dense(2,2)
+            ...     def construct(self, x):
+            ...         return self.fc(x)
+            >>>
+            >>> def generator():
+            ...     for i in range(2):
+            ...         yield (np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32))
+            >>>
+            >>> def train(net):
+            ...     stream = ms.runtime.current_stream()
+            ...     optimizer = nn.Momentum(net.trainable_params(), 1, 0.9)
+            ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+            ...     data = ds.GeneratorDataset(generator, ["data", "label"])
+            ...     model = ms.train.Model(net, loss, optimizer)
+            ...     # Add marker before training
+            ...     mstx.mark("train start", stream)
+            ...     model.train(1, data)
+            ...     # Add marker after training
+            ...     mstx.mark("train end", stream)
+            >>>
+            >>> if __name__ == '__main__':
+            ...     # Note: mstx only supports Ascend device and cannot be used in mindspore.nn.Cell.construct
+            ...     # when in mindspore.GRAPH_MODE
+            ...     ms.set_context(mode=ms.PYNATIVE_MODE)
+            ...     ms.set_device(device_target="Ascend", device_id=0)
+            ...     # Init Profiler
+            ...     experimental_config = mindspore.profiler._ExperimentalConfig(
+            ...                                 profiler_level=ProfilerLevel.LevelNone,
+            ...                                 mstx=True)
+            ...     # Note that the Profiler should be initialized before model.train
+            ...     with mindspore.profiler.profile(
+            ...         activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
+            ...         schedule=schedule(wait=0, warmup=0, active=3, repeat=1, skip_first=0),
+            ...         on_trace_ready=mindspore.profiler.tensorboard_trace_handler("./data"),
+            ...         experimental_config=experimental_config
+            ...     ) as profiler:
+            ...         net = Net()
+            ...         for i in range(5):
+            ...             train(net)
+            ...             profiler.step()
+        """
+        if not Mstx.enable:
+            return
+        if context.get_context('device_target') != DeviceTarget.NPU.value:
+            return
+        if not Mstx.NPU_PROFILER:
+            logging.warning("Invalid npu profiler for mstx, please check.")
+            return
+        if not message or not isinstance(message, str):
+            logging.warning("Invalid message for mstx.mark func. Please input valid message string.")
+            return
+        if stream:
+            if isinstance(stream, Stream):
+                device_stream = stream.device_stream()
+                Mstx.NPU_PROFILER.mstx_mark(message, device_stream)
+            else:
+                logging.warning(
+                    f"Invalid stream for mstx.mark func. Expected mindspore.runtime.Stream but got {type(stream)}.",
+                )
+        else:
+            Mstx.NPU_PROFILER.mstx_mark(message)
+
+    @staticmethod
+    def range_start(message: str, stream: mindspore.runtime.Stream = None) -> int:
+        """Start a profiling range.
+
+        Args:
+            message (str): Description for the range.
+            stream (:class:`~.runtime.Stream`, optional): NPU stream for async execution, expected type:
+                mindspore.runtime.Stream. Default: ``None``, which means only starting mstx range on
+                host side without starting on device stream.
+
+        Returns:
+            int, range ID for range_end.
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore as ms
+            >>> import mindspore
+            >>> from mindspore import nn
+            >>> import mindspore.dataset as ds
+            >>> from mindspore import Profiler
+            >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, schedule, tensorboard_trace_handler
+            >>> from mindspore.profiler import mstx
+            >>>
+            >>> class Net(nn.Cell):
+            ...     def __init__(self):
+            ...         super(Net, self).__init__()
+            ...         self.fc = nn.Dense(2,2)
+            ...     def construct(self, x):
+            ...         return self.fc(x)
+            >>>
+            >>> def generator():
+            ...     for i in range(2):
+            ...         yield (np.ones([2, 2]).astype(np.float32), np.ones([2]).astype(np.int32))
+            >>>
+            >>> def train(net):
+            ...     stream = ms.runtime.current_stream()
+            ...     optimizer = nn.Momentum(net.trainable_params(), 1, 0.9)
+            ...     loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+            ...     data = ds.GeneratorDataset(generator, ["data", "label"])
+            ...     model = ms.train.Model(net, loss, optimizer)
+            ...     # Start profiling range
+            ...     range_id = mstx.range_start("training process", stream)
+            ...     model.train(1, data)
+            ...     # End profiling range
+            ...     mstx.range_end(range_id)
+            >>>
+            >>> if __name__ == '__main__':
+            ...     # Note: mstx only supports Ascend device and cannot be used in mindspore.nn.Cell.construct
+            ...     # when in mindspore.GRAPH_MODE
+            ...     ms.set_context(mode=ms.PYNATIVE_MODE)
+            ...     ms.set_device(device_target="Ascend", device_id=0)
+            ...     # Init Profiler
+            ...     experimental_config = mindspore.profiler._ExperimentalConfig(
+            ...                                 profiler_level=ProfilerLevel.LevelNone,
+            ...                                 mstx=True)
+            ...     # Note that the Profiler should be initialized before model.train
+            ...     with mindspore.profiler.profile(
+            ...         activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
+            ...         schedule=schedule(wait=0, warmup=0, active=3, repeat=1, skip_first=0),
+            ...         on_trace_ready=mindspore.profiler.tensorboard_trace_handler("./data"),
+            ...         experimental_config=experimental_config
+            ...     ) as profiler:
+            ...         net = Net()
+            ...         for i in range(5):
+            ...             train(net)
+            ...             profiler.step()
+        """
+        if not Mstx.enable:
+            return 0
+        if context.get_context('device_target') != DeviceTarget.NPU.value:
+            return 0
+        if not Mstx.NPU_PROFILER:
+            logging.warning("Invalid npu profiler for mstx, please check.")
+            return 0
+        if not message or not isinstance(message, str):
+            logging.warning("Invalid message for mstx.range_start func. Please input valid message string.")
+            return 0
+        # pylint: disable=no-else-return
+        if stream:
+            if isinstance(stream, Stream):
+                device_stream = stream.device_stream()
+                return Mstx.NPU_PROFILER.mstx_range_start(message, device_stream)
+            else:
+                logging.warning(
+                    f"Invalid stream for mstx.range_start func. "
+                    f"Expected mindspore.runtime.Stream but got {type(stream)}.",
+                )
+                return 0
+        else:
+            return Mstx.NPU_PROFILER.mstx_range_start(message)
+
+    @staticmethod
+    def range_end(range_id: int) -> None:
+        """End a profiling range.
+
+        Args:
+            range_id (int): Range ID from range_start.
+
+        Examples:
+            >>> # Please refer to the example in range_start
+            >>> # range_id = mstx.range_start("training process", stream)
+            >>> # model.train(1, data)
+            >>> # mstx.range_end(range_id)
+        """
+        if not Mstx.enable or range_id == 0:
+            return
+        if context.get_context('device_target') != DeviceTarget.NPU.value:
+            return
+        if not Mstx.NPU_PROFILER:
+            logging.warning("Invalid npu profiler for mstx, please check.")
+            return
+        if not isinstance(range_id, int):
+            logging.warning(
+                "Invalid message for mstx.range_start func. Please input return value from mstx.range_start."
+            )
+            return
+        Mstx.NPU_PROFILER.mstx_range_end(range_id)

mindspore/profiler/platform/__init__.py

@@ -0,0 +1,21 @@
+# Copyright 2020-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.
+# ============================================================================
+"""Platform profiler"""
+from .cpu_profiler import CpuProfiler
+from .gpu_profiler import GpuProfiler
+from .npu_profiler import NpuProfiler
+
+
+__all__ = ["CpuProfiler", "GpuProfiler", "NpuProfiler"]

mindspore/profiler/platform/base_profiler.py

@@ -0,0 +1,40 @@
+# Copyright 2020-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.
+# ============================================================================
+"""Platform profiler interface."""
+from abc import ABC, abstractmethod
+
+
+class BaseProfiler(ABC):
+    """
+    BaseProfiler is the base class for all platform profilers.
+    """
+
+    @abstractmethod
+    def start(self):
+        """
+        Start profiling.
+        """
+
+    @abstractmethod
+    def stop(self):
+        """
+        Stop profiling.
+        """
+
+    @abstractmethod
+    def analyse(self, **kwargs):
+        """
+        Analyse profiling result.
+        """