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

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_op_analyse.py

@@ -0,0 +1,235 @@
+# 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.validator.validate_path import validate_and_normalize_path
+
+
+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 = 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)
+            framework_file_path = validate_and_normalize_path(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)
+            op_detail_file_path = validate_and_normalize_path(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])
+            gpu_op_type_file_path = validate_and_normalize_path(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)
+            activity_file_path = validate_and_normalize_path(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
         )

mindspore/profiler/common/profiler_parameters.py

@@ -21,7 +21,8 @@ from mindspore.profiler.common.constant import (
     ProfilerLevel,
     ProfilerActivity,
     AicoreMetrics,
-    ExportType
+    ExportType,
+    HostSystem
 )
 from mindspore.profiler.schedule import Schedule
 
@@ -45,10 +46,16 @@ class ProfilerParameters:
         "l2_cache": (bool, False),
         "hbm_ddr": (bool, False),
         "pcie": (bool, False),
+        "sys_io": (bool, False),
+        "sys_interconnection": (bool, False),
+        "host_sys": (list, []),
         "sync_enable": (bool, True),
         "data_simplification": (bool, True),
+        "record_shapes": (bool, False),
         "export_type": (list, [ExportType.Text]),
         "mstx": (bool, False),
+        "mstx_domain_include": (list, []),
+        "mstx_domain_exclude": (list, []),
         "schedule": (Schedule, None),
         "on_trace_ready": (Optional[Callable[..., Any]], None)
     }
@@ -72,13 +79,9 @@ class ProfilerParameters:
         params = {}
         params["is_set_schedule"] = self.is_set_schedule
         for param, (_, _) in self.PARAMS.items():
-            if param == "profiler_level":
+            if param in ["profiler_level", "aic_metrics"]:
                 params[param] = getattr(self, param).value
-            elif param == "aic_metrics":
-                params[param] = getattr(self, param).value
-            elif param == "activities":
-                params[param] = [item.value for item in getattr(self, param)]
-            elif param == "export_type":
+            elif param in ["activities", "export_type", "host_sys"]:
                 params[param] = [item.value for item in getattr(self, param)]
             elif param == "schedule":
                 params[param] = getattr(self, param).to_dict()
@@ -102,10 +105,16 @@ class ProfilerParameters:
             "l2_cache": self.l2_cache,
             "hbm_ddr": self.hbm_ddr,
             "pcie": self.pcie,
+            "sys_io": self.sys_io,
+            "sys_interconnection": self.sys_interconnection,
+            "host_sys": ",".join([item.value for item in self.host_sys]) if self.host_sys else "",
             "parallel_strategy": self.parallel_strategy,
             "profiler_level": self.profiler_level.value,
             "with_stack": self.with_stack,
+            "record_shapes": self.record_shapes,
             "mstx": self.mstx,
+            "mstx_domain_include": self.mstx_domain_include,
+            "mstx_domain_exclude": self.mstx_domain_exclude,
             "cpu_trace": ProfilerActivity.CPU in self.activities,
             "npu_trace": ProfilerActivity.NPU in self.activities,
         }
@@ -127,43 +136,62 @@ class ProfilerParameters:
             if key in ProfilerParameters.PARAMS:
                 expected_type = ProfilerParameters.PARAMS[key][ProfilerParameters.TYPE_INDEX]
                 default_value = ProfilerParameters.PARAMS[key][ProfilerParameters.VALUE_INDEX]
-
-                # Callable特殊处理
                 if key == "on_trace_ready":
-                    if value is not None and not callable(value):
-                        setattr(self, key, default_value)
-                        logger.warning(
-                            f"For Profiler, on_trace_ready value is Invalid, reset to {default_value}."
-                        )
+                    setattr(self, key, self._check_and_get_on_trace_ready(value, default_value))
                 elif key == "schedule":
-                    if not isinstance(value, Schedule):
-                        setattr(self, key, Schedule(wait=0, active=1))
-                        logger.warning(
-                            f"For Profiler, schedule value is Invalid, reset to {Schedule(wait=0, active=1)}"
-                        )
+                    setattr(self, key, self._check_and_get_schedule(value))
                 elif key == "export_type":
                     setattr(self, key, self._check_and_get_export_type(value))
+                elif key in ("mstx_domain_include", "mstx_domain_exclude"):
+                    setattr(self, key, self._check_and_get_mstx_domain(key, value))
+                elif key == "host_sys":
+                    setattr(self, key, self._check_and_get_host_sys(value, expected_type, default_value))
                 # 检查可迭代类型
                 elif isinstance(expected_type, type) and issubclass(expected_type, (list, tuple, set)):
-                    if not (isinstance(value, expected_type) and
-                            all(isinstance(item, type(default_value[0])) for item in value)):
-                        logger.warning(
-                            f"For Profiler, {key} value is Invalid, reset to {default_value}."
-                        )
-                        setattr(self, key, default_value)
+                    setattr(self, key, self._check_and_get_iterable_params(key, value, expected_type, default_value))
                 # 检查普通类型
-                elif not isinstance(value, expected_type):
-                    logger.warning(
-                        f"For Profiler, the type of {key} should be {expected_type}, "
-                        f"but got {type(value)}, reset to {default_value}."
-                    )
-                    setattr(self, key, default_value)
+                else:
+                    setattr(self, key, self._check_and_get_common_params(key, value, expected_type, default_value))
+
+    @staticmethod
+    def _check_and_get_on_trace_ready(value, default_value):
+        if value is not None and not callable(value):
+            logger.warning(f"For Profiler, on_trace_ready value is Invalid, reset to {default_value}.")
+            return default_value
+
+        return value
+
+    @staticmethod
+    def _check_and_get_schedule(value):
+        if not isinstance(value, Schedule):
+            logger.warning(f"For Profiler, schedule value is Invalid, reset to {Schedule(wait=0, active=1)}")
+            return Schedule(wait=0, active=1)
+
+        return value
 
-    def _check_deprecated_params(self, **kwargs) -> None:
+    @staticmethod
+    def _check_and_get_iterable_params(key, value, expected_type, default_value):
+        if not (isinstance(value, expected_type) and all(isinstance(item, type(default_value[0])) for item in value)):
+            logger.warning(f"For Profiler, {key} value is Invalid, reset to {default_value}.")
+            return default_value
+
+        return list(set(value))
+
+    @staticmethod
+    def _check_and_get_common_params(key, value, expected_type, default_value):
+        if not isinstance(value, expected_type):
+            logger.warning(f"For Profiler, the type of {key} should be {expected_type}, "
+                           f"but got {type(value)}, reset to {default_value}.")
+            return default_value
+
+        return value
+
+    @staticmethod
+    def _check_deprecated_params(**kwargs) -> None:
         """
         Check deprecated parameters.
         """
-        for key, _ in kwargs.items():
+        for key, value in kwargs.items():
             if key == "profile_communication":
                 warnings.warn(
                     "The parameter 'profile_communication' is deprecated,"
@@ -189,6 +217,16 @@ class ProfilerParameters:
                 warnings.warn(
                     "The parameter 'timeline_limit' is deprecated and will have no effect"
                 )
+            elif key == "pcie" and value is True:
+                warnings.warn(
+                    "The parameter 'pcie' will be deprecated in future versions. "
+                    "Please use 'sys_interconnection' in mindspore.profiler._ExperimentalConfig instead."
+                )
+            elif key == "hbm_ddr" and value is True:
+                warnings.warn(
+                    "The parameter 'hbm_ddr' will be deprecated in future versions. "
+                    "Please use 'profile_memory' in instead."
+                )
 
     def _set_schedule(self, **kwargs):
         if "schedule" in kwargs and isinstance(kwargs["schedule"], Schedule):
@@ -221,7 +259,29 @@ class ProfilerParameters:
                           f"'aic_metrics' cannot be set to 'AicoreMetrics.AiCoreNone', "
                           f"reset to 'AicoreMetrics.PipeUtilization'.")
 
-    def _check_and_get_export_type(self, export_type) -> list:
+        if self.__dict__.get('record_shapes', False) and ProfilerActivity.CPU not in self.__dict__.get('activities'):
+            self.record_shapes = False
+            warnings.warn("when 'ProfilerActivity.CPU' is not set in 'activities', 'Record_shapes' cannot be set to "
+                          "True, reset to 'False'.")
+
+        if not self.__dict__.get('mstx') and (self.__dict__.get('mstx_domain_include') or \
+            self.__dict__.get('mstx_domain_exclude')):
+            self.mstx_domain_include = []
+            self.mstx_domain_exclude = []
+            warnings.warn(
+                "when 'mstx' is set to 'False', 'mstx_domain_include' and 'mstx_domain_exclude' cannot be set, "
+                "reset them to '[]'."
+            )
+
+        if self.__dict__.get('mstx_domain_include') and self.__dict__.get('mstx_domain_exclude'):
+            self.mstx_domain_exclude = []
+            warnings.warn(
+                f"mstx_domain_include and mstx_domain_exclude can not be set together, "
+                f"mstx_domain_exclude has been reset to {self.mstx_domain_exclude}."
+            )
+
+    @staticmethod
+    def _check_and_get_export_type(export_type) -> list:
         """
         Check export type.
         """
@@ -229,7 +289,7 @@ class ProfilerParameters:
             return [ExportType.Text]
 
         if isinstance(export_type, str):
-            if export_type in [ExportType.Text.value, ExportType.Db.value]:
+            if export_type in (ExportType.Text.value, ExportType.Db.value):
                 return [ExportType(export_type)]
 
         if isinstance(export_type, list):
@@ -242,6 +302,39 @@ class ProfilerParameters:
         logger.warning("Invalid parameter export_type, reset it to text.")
         return [ExportType.Text]
 
+    @staticmethod
+    def _check_and_get_mstx_domain(list_name, domain_list) -> list:
+        """
+        Check mstx domain.
+        """
+        if not domain_list:
+            return []
+        if not isinstance(domain_list, list):
+            logger.warning(f"For Profiler, {list_name} value is Invalid, reset to [].")
+            return []
+        for domain_name in domain_list:
+            if not isinstance(domain_name, str) or domain_name == "":
+                logger.warning(f"{list_name} has value {domain_name} is not str or is empty, reset to [].")
+                return []
+        return list(set(domain_list))
+
+    @staticmethod
+    def _check_and_get_host_sys(host_sys, expected_type, default_value):
+        """
+        Check host system.
+        """
+        if not host_sys:
+            return default_value
+
+        if not (isinstance(host_sys, expected_type) and
+                all(isinstance(item, HostSystem) for item in host_sys)):
+            logger.warning(
+                f"For Profiler, 'host_sys' value is Invalid, reset to {default_value}."
+            )
+            return default_value
+
+        return set(host_sys)
+
     def __getattr__(self, name):
         """
         Get attribute.

mindspore/profiler/dynamic_profile/dynamic_monitor_proxy.py

@@ -0,0 +1,39 @@
+# Copyright 2025-2026 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.
+# ============================================================================
+"""Dynamic Profiler utils"""
+from mindspore.profiler.common.singleton import Singleton
+
+
+@Singleton
+class MsDynamicMonitorProxySingleton:
+    """
+    Class for dyno monitor proxy.
+    """
+    def __init__(self):
+        self._proxy = None
+        self._load_success = True
+
+    def _load_proxy(self):
+        if not self._proxy and self._load_success:
+            try:
+                from IPCMonitor import PyDynamicMonitorProxy
+            except ImportError:
+                self._load_success = False
+                return
+            self._proxy = PyDynamicMonitorProxy()
+
+    def get_proxy(self):
+        self._load_proxy()
+        return self._proxy