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

mindspore/profiler/mstx.py

@@ -0,0 +1,199 @@
+# 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.
+# ============================================================================
+""" Mstx class for NPU profiling """
+import mindspore
+import mindspore._c_expression as c_expression
+
+from mindspore import log as logging
+from mindspore.runtime import Stream
+from mindspore.profiler.common.constant import DeviceTarget
+
+
+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)
+
+    @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
+            >>> from mindspore import nn
+            >>> import mindspore.dataset as ds
+            >>> from mindspore import Profiler
+            >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, schedule, tensor_board_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
+            ...     with Profiler(profiler_level=ProfilerLevel.LevelNone,
+            ...                   on_trace_ready=tensor_board_trace_handler,
+            ...                   activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
+            ...                   schedule=schedule(wait=0, warmup=0, active=3, repeat=1, skip_first=0),
+            ...                   mstx=True) as profiler:
+            ...         net = Net()
+            ...         for i in range(5):
+            ...             train(net)
+            ...             profiler.step()
+        """
+        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
+            >>> from mindspore import nn
+            >>> import mindspore.dataset as ds
+            >>> from mindspore import Profiler
+            >>> from mindspore.profiler import ProfilerLevel, ProfilerActivity, schedule, tensor_board_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)
+            ...     with Profiler(profiler_level=ProfilerLevel.LevelNone,
+            ...                   on_trace_ready=tensor_board_trace_handler,
+            ...                   activities=[ProfilerActivity.CPU, ProfilerActivity.NPU],
+            ...                   schedule=schedule(wait=0, warmup=0, active=3, repeat=1, skip_first=0),
+            ...                   mstx=True) as profiler:
+            ...         net = Net()
+            ...         for i in range(5):
+            ...             train(net)
+            ...             profiler.step()
+        """
+        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 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.
+        """

mindspore/profiler/platform/cpu_profiler.py

@@ -0,0 +1,124 @@
+# 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.
+# ============================================================================
+"""CPU platform profiler."""
+import mindspore._c_expression as c_expression
+
+from mindspore.profiler.common.registry import PROFILERS
+from mindspore.profiler.common.constant import DeviceTarget, ProfilerActivity
+from mindspore.profiler.common.util import print_msg_with_pid
+from mindspore.profiler.common.profiler_context import ProfilerContext
+from mindspore.profiler.common.profiler_path_manager import ProfilerPathManager
+from mindspore.profiler.platform.base_profiler import BaseProfiler
+from mindspore.profiler.analysis.time_converter import TimeConverter
+from mindspore.profiler.analysis.task_manager import TaskManager
+from mindspore.profiler.analysis.parser.ms_framework_parser import FrameworkParser
+from mindspore.profiler.analysis.parser.framework_cann_relation_parser import FrameworkCannRelationParser
+from mindspore.profiler.analysis.viewer.ms_dataset_viewer import MsDatasetViewer
+from mindspore.profiler.analysis.viewer.ascend_timeline_viewer import AscendTimelineViewer
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+@PROFILERS.register_module(DeviceTarget.CPU.value)
+class CpuProfiler(BaseProfiler):
+    """
+    CPU platform profiler
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._prof_ctx = ProfilerContext()
+        self._profiler = c_expression.Profiler.get_instance(DeviceTarget.CPU.value)
+        self._prof_path_mgr = ProfilerPathManager()
+        self._prof_mgr = c_expression.ProfilerManager.get_instance()
+        ProfilerLogger.init(self._prof_ctx.ascend_ms_dir)
+        self._logger = ProfilerLogger.get_instance()
+
+    def start(self) -> None:
+        """Start profiling."""
+        self._logger.info("CpuProfiler start.")
+        self._profiler.init(self._prof_ctx.framework_path)
+        self._logger.info("CpuProfiler framework_path: %s", self._prof_ctx.framework_path)
+        self._profiler.step_profiling_enable(True)
+
+        if ProfilerActivity.CPU in self._prof_ctx.activities:
+            self._profiler.enable_op_time()
+
+        if self._prof_ctx.profile_memory:
+            self._profiler.enable_profile_memory()
+
+    def stop(self) -> None:
+        """Stop profiling."""
+        self._logger.info("CpuProfiler stop.")
+        self._profiler.stop()
+
+    def analyse(self, **kwargs) -> None:
+        """Analyse profiling data."""
+        if ProfilerContext().device_target_set != {DeviceTarget.CPU.value}:
+            return
+        self._logger.info("CpuProfiler analyse.")
+        CPUProfilerAnalysis.online_analyse()
+
+    def finalize(self) -> None:
+        """Finalize profiling data."""
+        self._logger.info("CpuProfiler finalize.")
+
+
+class CPUProfilerAnalysis:
+    """
+    CPU profiler analysis interface
+    """
+
+    @classmethod
+    def online_analyse(cls):
+        """
+        Online analysis for CPU
+        """
+        cls._pre_analyse_online()
+        cls._run_tasks(**ProfilerContext().to_dict())
+
+    @classmethod
+    def _pre_analyse_online(cls):
+        """
+        Pre-process for online analysis
+        """
+        ProfilerPathManager().create_output_path()
+        TimeConverter.init_parameters(freq=100.0, cntvct=0, localtime_diff=0)
+
+    @classmethod
+    def _run_tasks(cls, **kwargs) -> None:
+        """
+        Run tasks for online analysis
+        """
+        ascend_ms_dir = kwargs.get("ascend_ms_dir", "")
+        print_msg_with_pid(f"Start parsing profiling data: {ascend_ms_dir}")
+        task_mgr = cls._construct_task_mgr(**kwargs)
+        task_mgr.run()
+
+    @classmethod
+    def _construct_task_mgr(cls, **kwargs) -> TaskManager:
+        """
+        Construct task manager based on activities and parameters
+        """
+        task_mgr = TaskManager()
+
+        task_mgr.create_flow(
+            FrameworkParser(**kwargs)
+            .register_post_hook(MsDatasetViewer(**kwargs).save),
+            FrameworkCannRelationParser()
+            .register_post_hook(AscendTimelineViewer(**kwargs).save),
+            flow_name="cpu_flow", show_process=True
+        )
+
+        return task_mgr

mindspore/profiler/platform/gpu_profiler.py

@@ -0,0 +1,74 @@
+# 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.
+# ============================================================================
+"""GPU platform profiler."""
+import mindspore._c_dataengine as cde
+import mindspore._c_expression as c_expression
+from mindspore.profiler.common.registry import PROFILERS
+from mindspore.profiler.common.constant import DeviceTarget, ProfilerActivity
+
+from mindspore.profiler.common.profiler_context import ProfilerContext
+from mindspore.profiler.platform.base_profiler import BaseProfiler
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+@PROFILERS.register_module(DeviceTarget.GPU.value)
+class GpuProfiler(BaseProfiler):
+    """
+    GPU platform profiler
+    """
+    def __init__(self) -> None:
+        super().__init__()
+        self._prof_ctx = ProfilerContext()
+        self._profiler = c_expression.Profiler.get_instance(DeviceTarget.GPU.value)
+        ProfilerLogger.init(self._prof_ctx.ascend_ms_dir)
+        self._logger = ProfilerLogger.get_instance()
+
+        self._profiler.init(self._prof_ctx.output_path)
+        self._profiler.sync_enable(self._prof_ctx.sync_enable)
+
+        if self._prof_ctx.data_process:
+            self._md_profiler = cde.GlobalContext.profiling_manager()
+            self._md_profiler.init()
+
+    def start(self) -> None:
+        """Start profiling."""
+        self._logger.info("GpuProfiler start.")
+
+        if self._prof_ctx.data_process:
+            self._profiler.data_process_enable(True)
+            self._md_profiler.start()
+
+        if ProfilerActivity.GPU in self._prof_ctx.activities:
+            self._profiler.enable_op_time()
+
+            if ProfilerActivity.CPU in self._prof_ctx.activities:
+                self._profiler.step_profiling_enable(True)
+
+    def stop(self) -> None:
+        """Stop profiling."""
+        self._logger.info("GpuProfiler stop.")
+        self._profiler.stop()
+
+        if self._prof_ctx.data_process:
+            self._md_profiler.stop()
+            self._md_profiler.save(self._prof_ctx.output_path)
+
+    def analyse(self, **kwargs) -> None:
+        """Analyse profiling data."""
+        self._logger.info("GpuProfiler analyse.")
+
+    def finalize(self) -> None:
+        """Finalize profiling data."""
+        self._logger.info("GpuProfiler finalize.")