mindstudio-probe 8.3.2__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/core/{data_dump → dump/data_dump}/data_processor/factory.py

@@ -1,20 +1,24 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 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
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# 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.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 from msprobe.core.common.const import Const
-from msprobe.core.data_dump.data_processor.base import BaseDataProcessor
+from msprobe.core.dump.data_dump.data_processor.base import BaseDataProcessor
+from msprobe.core.common.file_utils import check_file_or_directory_path
+from msprobe.core.common.log import logger
+from msprobe.core.common.exceptions import MsprobeException
 
 
 class DataProcessorFactory:
@@ -34,7 +38,7 @@ class DataProcessorFactory:
     def get_module_processor(cls, framework):
         processor_class = cls._module_processor.get(framework)
         if not processor_class:
-            raise ValueError(f"ModuleProcesser not found for framework: {framework}")
+            raise ValueError(f"ModuleProcessor not found for framework: {framework}")
         return processor_class
 
     @classmethod
@@ -42,7 +46,15 @@ class DataProcessorFactory:
         cls.register_processors(config.framework)
         task = Const.KERNEL_DUMP if config.level == "L2" else config.task
         key = (config.framework, task)
-        processor_class = cls._data_processor.get(key)
+        bench_path = getattr(config, "bench_path", None)
+        if config.task == Const.TENSOR and bench_path is not None and not isinstance(bench_path, str):
+            logger.error_log_with_exp("bench_path is invalid, it should be a string",
+                                      MsprobeException(MsprobeException.INVALID_PARAM_ERROR))
+        elif config.task == Const.TENSOR and bench_path is not None and isinstance(bench_path, str):
+            check_file_or_directory_path(bench_path, True)
+            processor_class = cls._data_processor.get(("pytorch", Const.DIFF_CHECK))
+        else:
+            processor_class = cls._data_processor.get(key)
         if not processor_class:
             raise ValueError(f"Processor not found for framework: {config.framework}, task: {config.task}")
         return processor_class(config, data_writer)
@@ -50,32 +62,28 @@ class DataProcessorFactory:
     @classmethod
     def register_processors(cls, framework):
         if framework == Const.PT_FRAMEWORK:
-            from msprobe.core.data_dump.data_processor.pytorch_processor import (
+            from msprobe.core.dump.data_dump.data_processor.pytorch_processor import (
                 StatisticsDataProcessor as PytorchStatisticsDataProcessor,
                 TensorDataProcessor as PytorchTensorDataProcessor,
-                OverflowCheckDataProcessor as PytorchOverflowCheckDataProcessor,
-                FreeBenchmarkDataProcessor as PytorchFreeBenchmarkDataProcessor,
+                DiffCheckDataProcessor as PytorchDiffCheckDataProcessor,
                 KernelDumpDataProcessor as PytorchKernelDumpDataProcessor
             )
-            from msprobe.pytorch.dump.module_dump.module_processer import ModuleProcesser
+            from msprobe.pytorch.dump.module_dump.module_processor import ModuleProcessor
             cls.register_processor(Const.PT_FRAMEWORK, Const.STATISTICS, PytorchStatisticsDataProcessor)
             cls.register_processor(Const.PT_FRAMEWORK, Const.TENSOR, PytorchTensorDataProcessor)
-            cls.register_processor(Const.PT_FRAMEWORK, Const.OVERFLOW_CHECK, PytorchOverflowCheckDataProcessor)
-            cls.register_processor(Const.PT_FRAMEWORK, Const.FREE_BENCHMARK, PytorchFreeBenchmarkDataProcessor)
             cls.register_processor(Const.PT_FRAMEWORK, Const.KERNEL_DUMP, PytorchKernelDumpDataProcessor)
+            cls.register_processor(Const.PT_FRAMEWORK, Const.DIFF_CHECK, PytorchDiffCheckDataProcessor)
             cls.register_processor(Const.PT_FRAMEWORK, Const.STRUCTURE, BaseDataProcessor)
-            cls.register_module_processor(Const.PT_FRAMEWORK, ModuleProcesser)
+            cls.register_module_processor(Const.PT_FRAMEWORK, ModuleProcessor)
         elif framework == Const.MS_FRAMEWORK:
-            from msprobe.core.data_dump.data_processor.mindspore_processor import (
+            from msprobe.core.dump.data_dump.data_processor.mindspore_processor import (
                 StatisticsDataProcessor as MindsporeStatisticsDataProcessor,
                 TensorDataProcessor as MindsporeTensorDataProcessor,
-                OverflowCheckDataProcessor as MindsporeOverflowCheckDataProcessor,
                 KernelDumpDataProcessor as MindsporeKernelDumpDataProcessor
             )
-            from msprobe.mindspore.cell_processor import CellProcessor
+            from msprobe.mindspore.dump.cell_processor import CellProcessor
             cls.register_processor(Const.MS_FRAMEWORK, Const.STATISTICS, MindsporeStatisticsDataProcessor)
             cls.register_processor(Const.MS_FRAMEWORK, Const.TENSOR, MindsporeTensorDataProcessor)
-            cls.register_processor(Const.MS_FRAMEWORK, Const.OVERFLOW_CHECK, MindsporeOverflowCheckDataProcessor)
             cls.register_processor(Const.MS_FRAMEWORK, Const.KERNEL_DUMP, MindsporeKernelDumpDataProcessor)
             cls.register_processor(Const.MS_FRAMEWORK, Const.STRUCTURE, BaseDataProcessor)
             cls.register_module_processor(Const.MS_FRAMEWORK, CellProcessor)

msprobe/core/{data_dump → dump/data_dump}/data_processor/mindspore_processor.py

@@ -1,21 +1,23 @@
-# Copyright 2024-2025 Huawei Technologies Co., Ltd
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 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
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# 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.
-# ============================================================================
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import os
 import zlib
 from concurrent.futures import ThreadPoolExecutor
+import inspect
 
 import mindspore as ms
 from mindspore import mint, ops, hal
@@ -24,13 +26,11 @@ from mindspore._c_expression.typing import Number
 import numpy as np
 
 from msprobe.core.common.const import Const
-from msprobe.core.data_dump.data_processor.base import (BaseDataProcessor, TensorStatInfo,
-                                                        ModuleForwardInputsOutputs, ModuleBackwardInputsOutputs)
-from msprobe.core.common.file_utils import path_len_exceeds_limit
+from msprobe.core.dump.data_dump.data_processor.base import (BaseDataProcessor, TensorStatInfo)
 from msprobe.mindspore.common.utils import convert_bf16_to_fp32, save_tensor_as_npy
 from msprobe.mindspore.common.log import logger
-from msprobe.mindspore.dump.hook_cell.api_register import get_api_register
-from msprobe.mindspore.common.utils import is_mindtorch
+from msprobe.mindspore.dump.dump_processor.hook_cell.api_register import get_api_register
+from msprobe.mindspore.common.utils import is_mindtorch, cast_to_float_if_fp8
 
 has_adump = True
 try:
@@ -175,12 +175,31 @@ class MindsporeDataProcessor(BaseDataProcessor):
         return p2pop_info
 
     def _analyze_tensor(self, tensor, suffix):
+        dtype = str(tensor.dtype)
+        tensor = cast_to_float_if_fp8(tensor)
         tensor_stat = self.get_stat_info(tensor)
         tensor_json = {
             'type': 'mindspore.Tensor',
-            'dtype': str(tensor.dtype),
+            'dtype': dtype,
             'shape': tensor.shape
         }
+        if hasattr(tensor, "layout") and tensor.layout is not None:
+            layout_dic = {}
+            if hasattr(tensor.layout, "device_matrix") and tensor.layout.device_matrix is not None:
+                layout_dic['Device Matrix'] = tensor.layout.device_matrix
+            if hasattr(tensor.layout, "alias_name") and tensor.layout.alias_name is not None:
+                layout_dic['Alias Name'] = tensor.layout.alias_name
+                interleaved = "Yes" if ("interleaved_parallel" in tensor.layout.alias_name) else "No"
+                layout_dic['Interleaved'] = interleaved
+            if hasattr(tensor.layout, "partial") and tensor.layout.partial is not None:
+                layout_dic['Partial'] = tensor.layout.partial
+            if hasattr(tensor.layout, "tensor_map") and tensor.layout.tensor_map is not None:
+                layout_dic['Tensor Map'] = tensor.layout.tensor_map
+            if hasattr(tensor.layout, "rank_list") and tensor.layout.rank_list is not None:
+                layout_dic['Rank List'] = tensor.layout.rank_list
+            tensor_json['layout'] = layout_dic
+        if hasattr(tensor, "hsdp_effective_shard_size") and tensor.hsdp_effective_shard_size is not None:
+            tensor_json['hsdp_shard_size'] = tensor.hsdp_effective_shard_size
 
         # 将统计值存入全局 buffer，并返回占位索引
         stat_values = [
@@ -213,6 +232,7 @@ class MindsporeDataProcessor(BaseDataProcessor):
         dump_data_name, file_path = self.get_save_file_path(suffix)
         single_arg = MindsporeDataProcessor._analyze_tensor(self, tensor, suffix)
         single_arg.update({"data_name": dump_data_name})
+        tensor = cast_to_float_if_fp8(tensor)
         if self.config.async_dump:
             self._async_dump_cache[file_path] = tensor.copy()
         else:
@@ -242,102 +262,6 @@ class TensorDataProcessor(MindsporeDataProcessor):
         return self._analyze_and_save_ndarray(ndarray, suffix)
 
 
-class OverflowCheckDataProcessor(MindsporeDataProcessor):
-    __slots__ = ["cached_tensors_and_file_paths"]
-
-    def __init__(self, config, data_writer):
-        super().__init__(config, data_writer)
-        self.has_overflow = False
-        self.cached_api_info = {}
-        self.cached_tensors_and_file_paths = {}
-        self.real_overflow_nums = 0
-        self.overflow_nums = config.overflow_nums
-
-    @property
-    def is_terminated(self):
-        if self.overflow_nums == -1:
-            return False
-        if self.real_overflow_nums >= self.overflow_nums:
-            return True
-        return False
-
-    def analyze_forward_input(self, name, module, module_input_output: ModuleForwardInputsOutputs):
-        self.has_overflow = False
-        self.cached_api_info = super().analyze_forward_input(name, module, module_input_output)
-        return None
-
-    def analyze_forward_output(self, name, module, module_input_output: ModuleForwardInputsOutputs):
-        api_info_struct = super().analyze_forward_output(name, module, module_input_output)
-        if name in self.cached_api_info and name in api_info_struct:
-            self.cached_api_info[name].update(api_info_struct[name])
-        elif name in api_info_struct:
-            self.cached_api_info = api_info_struct
-        self.maybe_save_overflow_data()
-        return self.cached_api_info if self.has_overflow else None
-
-    def analyze_forward(self, name, module, module_input_output: ModuleForwardInputsOutputs):
-        self.has_overflow = False
-        api_info_struct = super().analyze_forward(name, module, module_input_output)
-        self.maybe_save_overflow_data()
-        return api_info_struct if self.has_overflow else None
-
-    def analyze_backward(self, name, module, module_input_output: ModuleBackwardInputsOutputs):
-        self.has_overflow = False
-        api_info_struct = super().analyze_backward(name, module, module_input_output)
-        self.maybe_save_overflow_data()
-        return api_info_struct if self.has_overflow else None
-
-    def analyze_params(self, name, param_name, grad):
-        self.has_overflow = False
-        api_info_struct = super().analyze_params(name, param_name, grad)
-        self.maybe_save_overflow_data()
-        return api_info_struct if self.has_overflow else None
-
-    def maybe_save_overflow_data(self):
-        if self.has_overflow:
-            for file_path, tensor in self.cached_tensors_and_file_paths.items():
-                save_tensor_as_npy(tensor, file_path)
-            self.real_overflow_nums += 1
-            if self.overflow_nums != -1 and self.real_overflow_nums >= self.overflow_nums:
-                logger.info(f"[{Const.TOOL_NAME}] Reached the preset overflow times, "
-                            f"current overflow times: {self.real_overflow_nums}.")
-        self.cached_tensors_and_file_paths = {}
-
-    def _analyze_maybe_overflow_tensor(self, tensor_json):
-        tensor_stat_index = tensor_json.get(Const.TENSOR_STAT_INDEX)
-        if tensor_stat_index is None:
-            logger.warning("tensor_stat_index does not exist in tensor_json.")
-            return
-        max_tensor = self.data_writer.get_buffer_values_max(tensor_stat_index)
-        min_tensor = self.data_writer.get_buffer_values_min(tensor_stat_index)
-        if max_tensor is None or min_tensor is None:
-            return
-
-        def check_inf_nan(value):
-            # Use .item() if it's a tensor-like structure
-            if hasattr(value, "item"):
-                value = value.item()
-            return np.isinf(value) or np.isnan(value)
-
-        if check_inf_nan(max_tensor):
-            self.has_overflow = True
-            return
-
-        if check_inf_nan(min_tensor):
-            self.has_overflow = True
-
-    def _analyze_tensor(self, tensor, suffix):
-        dump_data_name, file_path = self.get_save_file_path(suffix)
-        if not path_len_exceeds_limit(file_path):
-            self.cached_tensors_and_file_paths.update({file_path: tensor})
-        else:
-            logger.warning(f'The file path {file_path} length exceeds limit.')
-        single_arg = super()._analyze_tensor(tensor, suffix)
-        self._analyze_maybe_overflow_tensor(single_arg)
-        single_arg.update({"data_name": dump_data_name})
-        return single_arg
-
-
 class KernelDumpDataProcessor(MindsporeDataProcessor):
     def __init__(self, config, data_writer):
         super().__init__(config, data_writer)