mindspore 2.6.0__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

mindspore/profiler/common/profiler_context.py

@@ -31,7 +31,8 @@ from mindspore.profiler.common.constant import (
     ProfilerLevel,
     ProfilerActivity,
     AicoreMetrics,
-    ExportType
+    ExportType,
+    HostSystem
 )
 from mindspore.profiler.common.profiler_output_path import ProfilerOutputPath
 from mindspore.profiler.common.profiler_parameters import ProfilerParameters
@@ -42,6 +43,7 @@ from mindspore.profiler.schedule import Schedule
 from mindspore import context
 from mindspore import log as logger
 from mindspore.profiler.common.profiler_info import ProfilerInfo
+from mindspore.profiler.experimental_config import _ExperimentalConfig
 
 
 @Singleton
@@ -62,12 +64,11 @@ class ProfilerContext:
         self._profiler_path_mgr: ProfilerOutputPath = None
         self._on_trace_ready_output_path = 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()
+        self._init_jit_level()
 
     def set_params(self, **kwargs):
         """
@@ -81,14 +82,34 @@ class ProfilerContext:
                 logger.warning(f"Both on_trace_ready path and output_path are provided. "
                                f"The on_trace_ready path takes effect. Final path is {final_path}")
             kwargs["output_path"] = final_path
-
+        if kwargs.get("experimental_config"):
+            self._check_and_set_experimental_params(kwargs)
         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: ProfilerOutputPath = ProfilerOutputPath(rank_id=int(self._rank_id))
         self._profiler_path_mgr.output_path = self._profiler_params_mgr.output_path
 
+    @staticmethod
+    def _check_and_set_experimental_params(kwargs):
+        """
+        Set experimental parameters
+        """
+        if not isinstance(kwargs.get("experimental_config"), _ExperimentalConfig):
+            logger.warning("For Profiler, experimental_config value must be the "
+                           "'mindspore.profiler._ExperimentalConfig' class, "
+                           "reset to default value.")
+            return
+        kwargs["profiler_level"] = kwargs.get("experimental_config").profiler_level
+        kwargs["aic_metrics"] = kwargs.get("experimental_config").aic_metrics
+        kwargs["l2_cache"] = kwargs.get("experimental_config").l2_cache
+        kwargs["mstx"] = kwargs.get("experimental_config").mstx
+        kwargs["data_simplification"] = kwargs.get("experimental_config").data_simplification
+        kwargs["export_type"] = kwargs.get("experimental_config").export_type
+        kwargs["mstx_domain_include"] = kwargs.get("experimental_config").mstx_domain_include
+        kwargs["mstx_domain_exclude"] = kwargs.get("experimental_config").mstx_domain_exclude
+        kwargs["sys_io"] = kwargs.get("experimental_config").sys_io
+        kwargs["sys_interconnection"] = kwargs.get("experimental_config").sys_interconnection
+        kwargs["host_sys"] = kwargs.get("experimental_config").host_sys
+
     @property
     def on_trace_ready_output_path(self) -> str:
         """Get the on trace ready output path."""
@@ -113,7 +134,6 @@ class ProfilerContext:
             "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:
@@ -133,6 +153,8 @@ class ProfilerContext:
                     value = [ProfilerActivity(activity) for activity in profiler_parameters[param]]
                 elif param == "export_type":
                     value = [ExportType(export_type) for export_type in profiler_parameters[param]]
+                elif param == "host_sys":
+                    value = [HostSystem(host_sys) for host_sys in profiler_parameters[param]]
                 elif param == "schedule":
                     continue
                 else:
@@ -290,6 +312,16 @@ class ProfilerContext:
         """Get the mstx from ProfilerParameters."""
         return self._profiler_params_mgr.mstx
 
+    @property
+    def mstx_domain_include(self) -> List[str]:
+        """Get the mstx domain include from ProfilerParameters."""
+        return self._profiler_params_mgr.mstx_domain_include
+
+    @property
+    def mstx_domain_exclude(self) -> List[str]:
+        """Get the mstx domain exclude from ProfilerParameters."""
+        return self._profiler_params_mgr.mstx_domain_exclude
+
     @property
     def data_simplification(self) -> bool:
         """Get the data simplification from ProfilerParameters."""
@@ -304,6 +336,11 @@ class ProfilerContext:
             value = True
         self._profiler_params_mgr.data_simplification = value
 
+    @property
+    def record_shapes(self) -> bool:
+        """Get the record shapes from ProfilerParameters."""
+        return self._profiler_params_mgr.record_shapes
+
     @property
     def device_target(self) -> str:
         """Get device target."""
@@ -419,19 +456,6 @@ class ProfilerContext:
         """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
@@ -488,13 +512,10 @@ class ProfilerContext:
         if not self._rank_id or not self._rank_id.isdigit():
             self._rank_id = "0"
 
-    def _init_context_mode(self):
+    def _init_jit_level(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")
+        jit_config = context.get_jit_config()
+        self._jit_level = jit_config.get("jit_level", "")
+        ProfilerInfo().jit_level = self._jit_level

mindspore/profiler/common/profiler_info.py

@@ -64,7 +64,6 @@ class ProfilerInfo:
     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
@@ -77,7 +76,6 @@ class ProfilerInfo:
             self.ANALYSIS_COST_TIME: {},
             self.MS_VERSION: ms_version,
             self.CANN_VERSION: get_cann_version(),
-            self.CONTEXT_MODE: -1,
             self.JIT_LEVEL: "",
         }
         # time params
@@ -132,20 +130,6 @@ class ProfilerInfo:
         """
         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:
         """

mindspore/profiler/common/profiler_meta_data.py

@@ -30,6 +30,7 @@ class ProfilerMetaData:
         This class is used to handle metadata.
     """
     metadata: Dict[str, str] = {}
+    MAX_META_SIZE = 100 * 1024 * 1024  # 100MB
 
     @classmethod
     def get_metadata(cls) -> Dict[str, str]:

mindspore/profiler/common/profiler_op_analyse.py

@@ -0,0 +1,239 @@
+# 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.
+# ============================================================================
+"""The OpAnalyser."""
+import json
+import os
+from collections import defaultdict
+from mindspore.profiler.common.path_manager import PathManager
+
+
+class OpAnalyser:
+    """
+    The parser for parsing framework files.
+
+    Note:
+        This parser only supports CPU and GPU devices.
+
+    Args:
+        output_path (str): The profiling path which should contain GPU profiling data.
+        dev_id (str): The device ID.
+    """
+
+    def __init__(self, output_path, dev_id, op_names=None):
+        """The parser for parsing framework files."""
+        self._dev_id = dev_id
+        self._output_path = PathManager.get_real_path(output_path)
+        self.op_names = op_names
+        self.op_name = ''
+        self.framework_list = []
+        self.op_detail = {}
+        self.operation_info = {}
+        self.activity_info_dir = []
+        self.framework_info_dir = []
+        self.cpu_detail_info_dir = []
+        self.gpu_op_type_info_dir = []
+        self.op_execute_times = {}
+        self.op_step_shape_info = defaultdict(list)
+
+    def parse(self):
+        """Parse op performance data."""
+        self.get_device_target_filename()
+        self.get_framework_summary()
+        self.get_cpu_op_detail_info()
+        self.get_activity_op_info()
+        if isinstance(self.op_names, str):
+            self.combine_performance_data(self.op_names)
+        elif isinstance(self.op_names, list):
+            for op_name in self.op_names:
+                self.combine_performance_data(op_name)
+        self.operation_info["device_id"] = self._dev_id
+        return json.dumps(self.operation_info)
+
+    def get_framework_summary(self):
+        """Get framework data."""
+        for filename in self.framework_info_dir:
+            op_side = filename.split('_')[0]
+            framework_file_path = os.path.join(self._output_path, filename)
+            PathManager.check_input_file_path(framework_file_path)
+            PathManager.check_directory_path_readable(framework_file_path)
+            with open(framework_file_path, 'r') as f_obj:
+                framework_info = f_obj.readlines()
+            for line_info in framework_info:
+                line_info = line_info.strip(' ').strip('\n').split(';')
+                # line_info[0]: op_type, line_info[1]: op_name, line_info[2]: graph_id, line_info[3]: input_shape;
+                input_shape = line_info[3:]
+                item = [line_info[0], line_info[1], input_shape, op_side]
+                if not self.op_step_shape_info.get(line_info[1]):
+                    self.op_step_shape_info[line_info[1]].append(op_side)
+                self.op_step_shape_info[line_info[1]].append(input_shape)
+                if item not in self.framework_list:
+                    self.framework_list.append(item)
+
+    def get_cpu_op_detail_info(self):
+        """Get cpu operators detail data."""
+        for filename in self.cpu_detail_info_dir:
+            op_side = filename.split('_')[0]
+            op_detail_file_path = os.path.join(self._output_path, filename)
+            PathManager.check_input_file_path(op_detail_file_path)
+            PathManager.check_directory_path_readable(op_detail_file_path)
+            with open(op_detail_file_path, 'r') as f_obj:
+                op_detail_info = f_obj.readlines()
+            for line_info in op_detail_info[1:]:
+                line_info = line_info.strip(' ').strip('\n').split(',')
+                if not self.op_detail.get(line_info[2]):
+                    # line_info[4]: op_occurrences, line_info[5]: op_detail_time(us), line_info[6]: op_avg_time(us);
+                    self.op_detail[line_info[2]] = [float(line_info[4]), float(line_info[5]),
+                                                    float(line_info[6]), op_side]
+
+    def get_execute_times(self):
+        """Get gpu operators execute times."""
+        if self.gpu_op_type_info_dir:
+            gpu_op_type_file_path = os.path.join(self._output_path, self.gpu_op_type_info_dir[0])
+            PathManager.check_input_file_path(gpu_op_type_file_path)
+            PathManager.check_directory_path_readable(gpu_op_type_file_path)
+            with open(gpu_op_type_file_path, 'r') as fp:
+                op_type_info = fp.readlines()
+                for line_info in op_type_info[1:]:
+                    line_info = line_info.strip(' ').strip('\n').split(',')
+                    self.op_execute_times[line_info[0]] = line_info[1]
+
+    def get_activity_op_info(self):
+        """Get op detail data."""
+        all_file = os.listdir(self._output_path)
+        for file_name in all_file:
+            if file_name.startswith('gpu_op_type') and file_name.endswith(f'{self._dev_id}.csv'):
+                self.gpu_op_type_info_dir.append(file_name)
+        if not self.gpu_op_type_info_dir and self.activity_info_dir:
+            raise RuntimeError(f'The output file <%s> is not found.' % self.gpu_op_type_info_dir)
+        self.get_execute_times()
+        for filename in self.activity_info_dir:
+            op_side = filename.split('_')[0]
+            activity_file_path = os.path.join(self._output_path, filename)
+            PathManager.check_input_file_path(activity_file_path)
+            PathManager.check_directory_path_readable(activity_file_path)
+            with open(activity_file_path, 'r') as file:
+                activity_info = file.readlines()
+            for line_info in activity_info[1:]:
+                line_info = line_info.strip(' ').strip('\n').replace(', ', ';').split(',')
+                op_name = line_info[2].split('/')[-1]
+                # op_name: xxx-opx
+                op_type = op_name.split('-')[0]
+                op_value = self.op_execute_times.get(op_type)
+                if op_value is not None and op_value != '':
+                    try:
+                        op_occurrences = int(op_value)
+                    except (ValueError, TypeError):
+                        op_occurrences = 1
+                else:
+                    op_occurrences = 1
+
+                op_total_time = float(line_info[-4])
+                if not self.op_detail.get(op_name):
+                    # line_info[4]: op_occurrences, line_info[5]: op_detail_time(us), line_info[6]: op_avg_time(us);
+                    if op_occurrences > 0:
+                        avg_time = round(op_total_time / op_occurrences, 4)
+                    else:
+                        avg_time = 0
+                    self.op_detail[op_name] = [
+                        op_occurrences, op_total_time, avg_time, op_side
+                    ]
+                else:
+                    self.op_detail.get(op_name)[1] += op_total_time
+                    self.op_detail.get(op_name)[2] = self.op_detail.get(op_name)[1] / self.op_detail.get(op_name)[0]
+                    self.op_detail[op_name] = [
+                        self.op_detail.get(op_name)[0],
+                        round(self.op_detail.get(op_name)[1], 4),
+                        round(self.op_detail.get(op_name)[2], 4), op_side
+                    ]
+
+    def combine_performance_data(self, op_name):
+        """Combine operator detail info with framework info."""
+        unique_op_info = []
+        op_shape_dict = {}
+        operation_info = {}
+        factor = 1000  # convert time unit from ms to us.
+        for line_info in self.framework_list:
+            op_detail = self.op_detail.get(line_info[1])
+            if not op_detail:
+                continue
+            if op_name in line_info and line_info[3] == op_detail[3]:
+                op_side = line_info[3]
+                op_shape = '[{}]{}'.format(op_side, ','.join(line_info[2]))
+                op_occurrences = int(op_detail[0])
+                op_total_time = float(op_detail[1])
+                op_avg_time = float(op_detail[2])
+                if op_shape in op_shape_dict:
+                    # Classify according to the operator information of the same shape.
+                    op_shape_dict.get(op_shape)[0] += op_occurrences
+                    op_shape_dict.get(op_shape)[1] += op_total_time
+                    if op_shape_dict.get(op_shape)[0] > 0:
+                        op_shape_dict.get(op_shape)[2] = op_shape_dict.get(op_shape)[1] / op_shape_dict.get(op_shape)[0]
+                    else:
+                        op_shape_dict.get(op_shape)[2] = 0
+                    op_shape_dict[op_shape] = [
+                        op_shape_dict.get(op_shape)[0], round(op_shape_dict.get(op_shape)[1], 4),
+                        round(op_shape_dict.get(op_shape)[2], 4), op_side
+                    ]
+                else:
+                    op_shape_dict[op_shape] = [op_occurrences, op_total_time, op_avg_time, op_side]
+
+        for input_shape in op_shape_dict:
+            # 0: op_occurrences, 1: op_total_time, 2: op_avg_time, 3: op_side
+            operation_info['op_side'] = op_shape_dict.get(input_shape)[3]
+            operation_info['input_shape'] = input_shape.strip('[').split(']')[-1]
+            operation_info['op_occurrences'] = op_shape_dict.get(input_shape)[0]
+            if operation_info.get('op_side') == 'cpu':
+                operation_info['op_total_time(us)'] = round(op_shape_dict.get(input_shape)[1] * factor, 4)
+                operation_info['op_avg_time(us)'] = round(op_shape_dict.get(input_shape)[2] * factor, 4)
+            else:
+                operation_info['op_total_time(us)'] = op_shape_dict.get(input_shape)[1]
+                operation_info['op_avg_time(us)'] = op_shape_dict.get(input_shape)[2]
+            unique_op_info.append(operation_info)
+            operation_info = dict()
+
+        if unique_op_info:
+            self.operation_info[op_name] = unique_op_info
+        else:
+            raise RuntimeError(f'The information of <{op_name}> is not found. Please verify that the operator name is'
+                               f' correct or the operator is used in the network.')
+
+    def get_device_target_filename(self):
+        """Get device target filename."""
+        gpu_framework_file = f'gpu_framework_{self._dev_id}.txt'
+        cpu_framework_file = f'cpu_framework_{self._dev_id}.txt'
+        gpu_activity_file = f'gpu_activity_data_{self._dev_id}.csv'
+        cpu_op_detail_file = f'cpu_op_detail_info_{self._dev_id}.csv'
+        all_file = os.listdir(self._output_path)
+        if not all_file:
+            raise RuntimeError(f'No profiler file is found in the path <%s>. '
+                               f'Check whether the profiler path is correct.' % self._output_path)
+        if gpu_activity_file in all_file and gpu_framework_file not in all_file:
+            raise RuntimeError(f'The output file <%s> is not found.' % gpu_framework_file)
+        if cpu_op_detail_file in all_file and cpu_framework_file not in all_file:
+            raise RuntimeError(f'The output file <%s> is not found.' % cpu_framework_file)
+        if gpu_framework_file in all_file and gpu_activity_file not in all_file:
+            raise RuntimeError(f'The output file <%s> is not found.' % gpu_activity_file)
+        if cpu_framework_file in all_file and cpu_op_detail_file not in all_file:
+            raise RuntimeError(f'The output file <%s> is not found.' % cpu_op_detail_file)
+        if gpu_activity_file not in all_file and cpu_op_detail_file not in all_file:
+            raise RuntimeError(f'The profiling data of this card which device_id is equal to {self._dev_id} does not'
+                               f' exist. Check whether device_id is correct.')
+        for file_name in all_file:
+            if file_name.endswith(f'activity_data_{self._dev_id}.csv'):
+                self.activity_info_dir.append(file_name)
+            if file_name.endswith(f'framework_{self._dev_id}.txt'):
+                self.framework_info_dir.append(file_name)
+            if file_name.startswith('cpu_op_detail') and file_name.endswith(f'{self._dev_id}.csv'):
+                self.cpu_detail_info_dir.append(file_name)

mindspore/profiler/common/profiler_output_path.py

@@ -14,7 +14,10 @@
 # ============================================================================
 """Profiler output path"""
 import os
+import glob
+import re
 from typing import Any, Dict, Optional
+from mindspore import log as logger
 from mindspore.profiler.common.path_manager import PathManager
 
 
@@ -49,12 +52,9 @@ class ProfilerOutputPath:
     _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")
+    def __init__(self, rank_id: int):
 
         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
@@ -269,10 +269,25 @@ class ProfilerOutputPath:
         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)
-        )
+
+        device_pattern = os.path.join(self._msprof_profile_path, "device_*")
+        device_dirs = glob.glob(device_pattern)
+        valid_device_dirs = [d for d in device_dirs if re.match(r'^device_\d+$', os.path.basename(d))]
+
+        if valid_device_dirs:
+            device_dir = os.path.basename(valid_device_dirs[0])
+            device_id = device_dir.replace("device_", "")
+            self._msprof_profile_device_path = os.path.join(
+                self._msprof_profile_path,
+                ProfilerOutputPath._MINISTUDIO_PROFILER_DEVICE.format(device_id)
+            )
+        else:
+            logger.error(f"No device_* directory found in {self._msprof_profile_path}, using device_0 as default")
+            self._msprof_profile_device_path = os.path.join(
+                self._msprof_profile_path,
+                ProfilerOutputPath._MINISTUDIO_PROFILER_DEVICE.format("0")
+            )
+
         self._msprof_profile_log_path = os.path.join(
             self._msprof_profile_path, ProfilerOutputPath._MINISTUDIO_PROFILER_LOG
         )