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

mindspore/profiler/common/process_bar.py

@@ -0,0 +1,168 @@
+# 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.
+# ============================================================================
+"""Process bar."""
+import os
+import sys
+import time
+from typing import Iterable, Optional, Any
+import threading
+
+
+class ProcessBar:
+    """
+    A progress bar for tracking the progress of an iterable or a process with a known total.
+    """
+    BLANK_SPACE_NUM = 20
+    FINISH_TEXT = "Done"
+
+    def __init__(
+            self,
+            iterable: Optional[Iterable] = None,
+            desc: str = "",
+            bar_length: int = 20,
+            update_interval: float = 1.0,
+    ):
+        """
+        Initialize the ProcessBar.
+
+        Args:
+            iterable: An optional iterable to track progress.
+            desc: A description of the process being tracked.
+            bar_length: The length of the progress bar in characters.
+            update_interval: The minimum time interval between progress bar updates.
+        """
+        if not isinstance(iterable, Iterable):
+            raise ValueError("Must provide an iterable")
+
+        if not isinstance(desc, str):
+            raise ValueError("desc must be a string")
+
+        if not isinstance(bar_length, int):
+            raise ValueError("bar_length must be an integer")
+
+        if bar_length <= 0:
+            raise ValueError("bar_length must be greater than 0")
+
+        if not isinstance(update_interval, float):
+            raise ValueError("update_interval must be a float")
+
+        if update_interval < 0:
+            raise ValueError("update_interval must be greater than 0")
+
+        self.iterable: Iterable = iterable
+        self.total: int = len(iterable)
+        self.desc: str = f"[{os.getpid()}] {desc}"
+        self.bar_length: int = bar_length
+        self.update_interval: float = update_interval
+        self.current: int = 0
+        self.cur_item_name: Optional[str] = None
+        self.start_time: float = time.time()
+        self.last_update_time: float = self.start_time
+        self._stop_refresh = False
+        self._refresh_thread = None
+        self._start_auto_refresh()
+
+    def _start_auto_refresh(self) -> None:
+        """
+        Start auto refresh thread.
+        """
+        def refresh_loop():
+            while not self._stop_refresh:
+                if self.current > 0:
+                    self._print_progress(time.time())
+                time.sleep(self.update_interval)
+
+        self._refresh_thread = threading.Thread(target=refresh_loop, daemon=True)
+        self._refresh_thread.start()
+
+    def update(self, n: int = 1, item_name: Optional[str] = None) -> None:
+        """
+        Update the progress bar.
+
+        Args:
+            n: The number of items or steps to increment the progress by.
+            item_name: The name of the current item being processed.
+        """
+        self.current += n
+        self.cur_item_name = item_name
+
+    def _print_progress(self, now: float) -> None:
+        """
+        Print the current progress to the console.
+
+        Args:
+            now: The current timestamp.
+        """
+        elapsed = now - self.start_time
+        if self.total > 0:
+            progress = min(1, self.current / self.total)
+            block = int(round(self.bar_length * progress))
+
+            text = (
+                f"\r{self.desc}: [{block * '#' + (self.bar_length - block) * ' '}] "
+                f"{self.current}/{self.total} {self.cur_item_name} "
+                f"Elapsed: {int(elapsed)}s"
+            )
+            # 添加额外的空格和回车来清除可能的残留字符
+            text = text + ' ' * self.BLANK_SPACE_NUM + '\r'
+            sys.stdout.write(text)
+            sys.stdout.flush()
+
+    def __iter__(self) -> Iterable[Any]:
+        """
+        Iterate over the items in the iterable, updating the progress bar for each item.
+
+        Yields:
+            The next item from the iterable.
+
+        Raises:
+            ValueError: If no iterable was provided during initialization.
+        """
+        if self.iterable is None:
+            raise ValueError("Must provide an iterable")
+        try:
+            iterator = iter(self.iterable)
+            # 预先获取第一个元素
+            try:
+                first_item = next(iterator)
+            except StopIteration:
+                return
+
+            # 初始化显示，显示0/total和第一个元素的名称
+            self.cur_item_name = first_item.__class__.__name__
+            self._print_progress(time.time())
+
+            # 处理第一个元素
+            yield first_item
+            self.update(item_name=first_item.__class__.__name__)
+            self._print_progress(time.time())
+
+            # 处理剩余元素
+            for item in iterator:
+                # 先更新当前要处理的元素名称
+                self.cur_item_name = item.__class__.__name__
+                self._print_progress(time.time())
+                yield item
+                self.update()
+
+            # 显示完成状态
+            self.cur_item_name = self.FINISH_TEXT
+            self._print_progress(time.time())
+            sys.stdout.write("\n")
+
+        finally:
+            self._stop_refresh = True
+            if self._refresh_thread:
+                self._refresh_thread.join()

mindspore/profiler/common/process_pool.py

@@ -28,9 +28,15 @@ class MultiProcessPool:
         self.porcess_list: List[Process] = []
         atexit.register(self.wait_all_job_finished)
 
-    def add_async_job(self, func):
-        """Add job and run in subprocess"""
-        process = Process(target=func)
+    def add_async_job(self, func, *args, **kwargs):
+        """Add job and run in subprocess.
+
+        Args:
+            func: The function to be executed in subprocess.
+            args: The positional arguments to be passed to the function.
+            kwargs: The keyword arguments to be passed to the function.
+        """
+        process = Process(target=func, args=args, kwargs=kwargs)
         process.start()
         self.porcess_list.append(process)
 

mindspore/profiler/common/profiler_context.py

@@ -0,0 +1,476 @@
+# 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.
+# ============================================================================
+"""Profiler Context"""
+import os
+from typing import (
+    Dict,
+    Any,
+    Optional,
+    List,
+    Set,
+    Callable,
+)
+
+from mindspore.communication.management import GlobalComm
+from mindspore.communication.management import get_local_rank
+from mindspore.communication.management import get_rank
+from mindspore.profiler.common.constant import (
+    DeviceTarget,
+    ProfilerLevel,
+    ProfilerActivity,
+    AicoreMetrics
+)
+from mindspore.profiler.common.profiler_output_path import ProfilerOutputPath
+from mindspore.profiler.common.profiler_parameters import ProfilerParameters
+from mindspore.profiler.common.constant import AnalysisMode
+from mindspore.profiler.common.singleton import Singleton
+from mindspore.profiler.schedule import Schedule
+
+from mindspore import context
+from mindspore import log as logger
+from mindspore.profiler.common.profiler_info import ProfilerInfo
+
+
+@Singleton
+class ProfilerContext:
+    """
+    Profiler context manage all parameters and paths on runtime.
+    """
+
+    def __init__(self):
+        self._profiler_params_mgr: ProfilerParameters = None
+        self._device_id: Optional[str] = None
+        self._rank_id: Optional[str] = None
+        self._device_target: Optional[str] = None
+        self._dynamic_status: Optional[bool] = None
+        self._step_list: Optional[int] = None
+        self._mode: str = AnalysisMode.SYNC_MODE.value
+        self._pretty: bool = False
+        self._profiler_path_mgr: ProfilerOutputPath = None
+        self._jit_level: Optional[str] = ""
+        self._context_mode: Optional[int] = -1
+
+        self._init_device_target()
+        self._init_device_id()
+        self._init_rank_id()
+        self._init_context_mode()
+
+    def set_params(self, **kwargs):
+        """
+        Set profiler parameters and paths
+        """
+        self._profiler_params_mgr: ProfilerParameters = ProfilerParameters(**kwargs)
+        self._profiler_path_mgr: ProfilerOutputPath = ProfilerOutputPath(
+            device_id=int(self._device_id), rank_id=int(self._rank_id)
+        )
+        self._profiler_path_mgr.output_path = self._profiler_params_mgr.output_path
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the profiler context to a dictionary for multiprocessing.
+        """
+        return {
+            **self._profiler_params_mgr.original_params,
+            **self._profiler_path_mgr.to_dict(),
+            "device_id": self._device_id,
+            "rank_id": self._rank_id,
+            "device_target": self._device_target,
+            "dynamic_status": self._dynamic_status,
+            "step_list": self._step_list,
+            "mode": self._mode,
+            "jit_level": self._jit_level,
+            "context_mode": self._context_mode
+        }
+
+    def load_offline_profiler_params(self, profiler_parameters: Dict[str, Any]) -> None:
+        """
+        Update profiler parameters from profiler_info.json
+        """
+        if not profiler_parameters:
+            raise ValueError("Profiler parameters is empty")
+
+        for param, (_, _) in self._profiler_params_mgr.PARAMS.items():
+            if param in profiler_parameters:
+                if param == "profiler_level":
+                    value = ProfilerLevel(profiler_parameters[param])
+                elif param == "aicore_metrics":
+                    value = AicoreMetrics(profiler_parameters[param])
+                elif param == "activities":
+                    value = [ProfilerActivity(activity) for activity in profiler_parameters[param]]
+                elif param == "schedule":
+                    continue
+                else:
+                    value = profiler_parameters[param]
+
+                setattr(self._profiler_params_mgr, param, value)
+        setattr(self._profiler_params_mgr, "is_set_schedule", profiler_parameters["is_set_schedule"])
+
+    @property
+    def device_target_set(self) -> Set[str]:
+        """
+        Get the device target set for ProfilerInterface initialization.
+
+        CPU is always included in the list, device_target includes CPU、Ascend、GPU.
+        """
+        return set([DeviceTarget.CPU.value, self._device_target])
+
+    @property
+    def npu_profiler_params(self) -> Dict[str, Any]:
+        """
+        Get NPU profiler parameters for Ascend profiler cpp backend.
+
+        Returns:
+            Dict[str, Any]: A dictionary of NPU profiler parameters.
+        """
+        params = self._profiler_params_mgr.npu_profiler_params
+        # update framework_path for profile memory
+        params["framework_path"] = self._profiler_path_mgr.framework_path
+        params["rank_id"] = int(self._rank_id)
+        params["device_id"] = int(self._device_id)
+        return params
+
+    @property
+    def original_params(self) -> Dict[str, str]:
+        """Get the original parameters from ProfilerParameters."""
+        return self._profiler_params_mgr.original_params
+
+    @property
+    def output_path(self) -> str:
+        """Get the output path from ProfilerOutputPath."""
+        return self._profiler_path_mgr.output_path
+
+    @property
+    def ascend_ms_dir(self) -> str:
+        """Get the Ascend MS directory from ProfilerOutputPath."""
+        return self._profiler_path_mgr.ascend_ms_dir
+
+    @ascend_ms_dir.setter
+    def ascend_ms_dir(self, value: str):
+        """Set the Ascend MS directory to ProfilerOutputPath."""
+        self._profiler_path_mgr.ascend_ms_dir = value
+
+    @property
+    def ascend_profiler_output_path(self) -> str:
+        """Get the Ascend profiler output path from ProfilerOutputPath."""
+        return self._profiler_path_mgr.ascend_profiler_output_path
+
+    @property
+    def framework_path(self) -> str:
+        """Get the framework path from ProfilerOutputPath."""
+        return self._profiler_path_mgr.framework_path
+
+    @property
+    def msprof_profile_path(self) -> str:
+        """Get the MSProf profile path from ProfilerOutputPath."""
+        return self._profiler_path_mgr.msprof_profile_path
+
+    @msprof_profile_path.setter
+    def msprof_profile_path(self, value: str):
+        """Set the MSProf profile path to ProfilerOutputPath."""
+        self._profiler_path_mgr.msprof_profile_path = value
+
+    @property
+    def msprof_profile_host_path(self) -> str:
+        """Get the MSProf profile host path from ProfilerOutputPath."""
+        return self._profiler_path_mgr.msprof_profile_host_path
+
+    @property
+    def msprof_profile_device_path(self) -> str:
+        """Get the MSProf profile device path from ProfilerOutputPath."""
+        return self._profiler_path_mgr.msprof_profile_device_path
+
+    @property
+    def msprof_profile_log_path(self) -> str:
+        """Get the MSProf profile log path from ProfilerOutputPath."""
+        return self._profiler_path_mgr.msprof_profile_log_path
+
+    @property
+    def msprof_profile_output_path(self) -> str:
+        """Get the MSProf profile output path from ProfilerOutputPath."""
+        return self._profiler_path_mgr.msprof_profile_output_path
+
+    @property
+    def profiler_level(self) -> ProfilerLevel:
+        """Get the profiler level from ProfilerParameters."""
+        return self._profiler_params_mgr.profiler_level
+
+    @property
+    def activities(self) -> List[ProfilerActivity]:
+        """Get the activities from ProfilerParameters."""
+        return self._profiler_params_mgr.activities
+
+    @property
+    def profile_memory(self) -> bool:
+        """Get the profile memory from ProfilerParameters."""
+        return self._profiler_params_mgr.profile_memory
+
+    @property
+    def parallel_strategy(self) -> bool:
+        """Get the parallel strategy from ProfilerParameters."""
+        return self._profiler_params_mgr.parallel_strategy
+
+    @property
+    def start_profile(self) -> bool:
+        """Get the start profile from ProfilerParameters."""
+        return self._profiler_params_mgr.start_profile
+
+    @property
+    def aicore_metrics(self) -> int:
+        """Get the aicore metrics from ProfilerParameters."""
+        return self._profiler_params_mgr.aicore_metrics
+
+    @property
+    def l2_cache(self) -> bool:
+        """Get the l2 cache from ProfilerParameters."""
+        return self._profiler_params_mgr.l2_cache
+
+    @property
+    def hbm_ddr(self) -> bool:
+        """Get the hbm ddr from ProfilerParameters."""
+        return self._profiler_params_mgr.hbm_ddr
+
+    @property
+    def pcie(self) -> bool:
+        """Get the pcie from ProfilerParameters."""
+        return self._profiler_params_mgr.pcie
+
+    @property
+    def sync_enable(self) -> bool:
+        """Get the sync enable from ProfilerParameters."""
+        return self._profiler_params_mgr.sync_enable
+
+    @property
+    def data_process(self) -> bool:
+        """Get the data process from ProfilerParameters."""
+        return self._profiler_params_mgr.data_process
+
+    @property
+    def with_stack(self) -> bool:
+        """Get the with stack from ProfilerParameters."""
+        return self._profiler_params_mgr.with_stack
+
+    @property
+    def mstx(self) -> bool:
+        """Get the mstx from ProfilerParameters."""
+        return self._profiler_params_mgr.mstx
+
+    @property
+    def data_simplification(self) -> bool:
+        """Get the data simplification from ProfilerParameters."""
+        return self._profiler_params_mgr.data_simplification
+
+    @data_simplification.setter
+    def data_simplification(self, value: bool) -> None:
+        """Set data simplification value."""
+        if not isinstance(value, bool):
+            logger.warning(f"For profiler, the type of data_simplification should be bool, "
+                           f"but got {type(value)}, reset to True.")
+            value = True
+        self._profiler_params_mgr.data_simplification = value
+
+    @property
+    def device_target(self) -> str:
+        """Get device target."""
+        return self._device_target
+
+    @property
+    def rank_id(self) -> str:
+        """Get rank id."""
+        return self._rank_id
+
+    @rank_id.setter
+    def rank_id(self, value: str) -> None:
+        """Set rank id."""
+        if not value:
+            raise ValueError("Rank id must be a non-empty string")
+
+        if not value.isdigit():
+            raise ValueError("Rank id must be a number")
+        self._rank_id = value
+
+    @property
+    def device_id(self) -> str:
+        """Get device id."""
+        return self._device_id
+
+    @device_id.setter
+    def device_id(self, value) -> None:
+        """Set device id."""
+        if not value:
+            raise ValueError("Device id must be a non-empty string")
+
+        if not value.isdigit():
+            raise ValueError("Device id must be a number")
+        self._device_id = value
+
+    @property
+    def dynamic_status(self) -> bool:
+        """Get dynamic status."""
+        return self._dynamic_status
+
+    @property
+    def step_list(self) -> Optional[List[int]]:
+        """Get step list."""
+        return self._step_list
+
+    @step_list.setter
+    def step_list(self, value: Optional[List[int]]) -> None:
+        """Set step list for profiling."""
+        if value is not None and not isinstance(value, list):
+            logger.error(f"For profiler, the parameter step_list must be a list, "
+                         f"but got type {type(value)}, step_list reset to None.")
+            return
+        if value:
+            if not all(isinstance(step_id, int) for step_id in value):
+                logger.error(f"For profiler, the elements of the parameter step_list "
+                             "must be integers, step_list reset to None.")
+                return
+            value.sort()
+            if value[-1] - value[0] != len(value) - 1:
+                logger.error(f"For profiler, the elements of the parameter step_list "
+                             "must be continuous integers, step_list reset to None.")
+                return
+        self._step_list = value
+
+    @property
+    def pretty(self) -> bool:
+        return self._pretty
+
+    @pretty.setter
+    def pretty(self, value: bool) -> None:
+        """Set pretty print value."""
+        if not isinstance(value, bool):
+            logger.warning(f"For profiler, the parameter pretty must be bool, "
+                           f"but got {type(value)}, reset to False.")
+            value = False
+        self._pretty = value
+
+    @property
+    def mode(self) -> str:
+        """Get the analysis mode."""
+        return self._mode
+
+    @mode.setter
+    def mode(self, mode: str) -> None:
+        """Set analysis mode value."""
+        if not isinstance(mode, str):
+            logger.warning(f"For Profiler.analyse(), the parameter mode must be str, "
+                           f"but got {type(mode)}, reset to {AnalysisMode.SYNC_MODE.value}.")
+            self._mode = AnalysisMode.SYNC_MODE.value
+            return
+
+        mode_range = [m.value for m in AnalysisMode]
+        if mode not in mode_range:
+            logger.warning(f"For Profiler.analyse(), the parameter mode must be one of {mode_range}, "
+                           f"but got {mode}, reset to {AnalysisMode.SYNC_MODE.value}.")
+            self._mode = AnalysisMode.SYNC_MODE.value
+            return
+
+        self._mode = mode
+
+    @property
+    def schedule(self) -> Schedule:
+        """Get the schedule from ProfilerParameters."""
+        return self._profiler_params_mgr.schedule
+
+    @property
+    def on_trace_ready(self) -> Optional[Callable[..., Any]]:
+        """Get the on trace ready from ProfilerParameters."""
+        return self._profiler_params_mgr.on_trace_ready
+
+    @property
+    def is_set_schedule(self) -> bool:
+        """Get the is set schedule from ProfilerParameters."""
+        return self._profiler_params_mgr.is_set_schedule
+
+    @property
+    def context_mode(self) -> int:
+        return self._context_mode
+
+    @context_mode.setter
+    def context_mode(self, value: int) -> None:
+        """Set context mode value."""
+        if not isinstance(value, int):
+            logger.warning(f"For profiler, the parameter context_mode must be int, "
+                           f"but got {type(value)}, reset to -1.")
+            value = -1
+        self._context_mode = value
+
+    @property
+    def jit_level(self) -> str:
+        return self._jit_level
+
+    @jit_level.setter
+    def jit_level(self, value: str) -> None:
+        """Set jit level value."""
+        if not isinstance(value, str):
+            logger.warning(f"For profiler, the parameter jit_level must be str, "
+                           f"but got {type(value)}, reset to ''.")
+            value = ""
+        self._jit_level = value
+
+    def _init_device_target(self) -> None:
+        """
+        Initialize the device target.
+
+        Raises:
+            RuntimeError: If the device target is not supported.
+        """
+        self._device_target = context.get_context("device_target")
+
+        if self._device_target and self._device_target not in (
+                member.value for member in DeviceTarget
+        ):
+            msg = "Profiling: unsupported backend: %s" % self._device_target
+            raise RuntimeError(msg)
+
+    def _init_device_id(self) -> None:
+        """
+        Initialize the device ID.
+        """
+        self._device_id = str(context.get_context("device_id"))
+
+        if not self._device_id or not self._device_id.isdigit():
+            if GlobalComm.INITED and self._device_target == DeviceTarget.NPU.value:
+                self._device_id = str(get_local_rank())
+            else:
+                self._device_id = os.getenv("DEVICE_ID")
+
+        if not self._device_id or not self._device_id.isdigit():
+            self._device_id = "0"
+            logger.warning("Fail to get DEVICE_ID, use 0 instead.")
+
+    def _init_rank_id(self) -> None:
+        """
+        Initialize the rank ID.
+        """
+        if GlobalComm.INITED and self._device_target == DeviceTarget.NPU.value:
+            self._rank_id = str(get_rank())
+        else:
+            self._rank_id = os.getenv("RANK_ID")
+
+        if not self._rank_id or not self._rank_id.isdigit():
+            self._rank_id = "0"
+
+    def _init_context_mode(self):
+        """
+        Initialize the jit level.
+        """
+        if context.get_context("mode") == context.GRAPH_MODE:
+            jit_config = context.get_jit_config()
+            self._jit_level = jit_config.get("jit_level", "")
+            ProfilerInfo().jit_level = self._jit_level
+        ProfilerInfo().context_mode = context.get_context("mode")
+        self._context_mode = context.get_context("mode")