mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/profiler/profiling.py

@@ -34,13 +34,11 @@ from mindspore.context import get_auto_parallel_context
 from mindspore.communication.management import GlobalComm, get_rank, get_group_size, get_local_rank
 import mindspore._c_expression as c_expression
 import mindspore._c_dataengine as cde
-from mindspore._c_expression import _framework_profiler_enable_mi
 from mindspore.profiler.common.exceptions.exceptions import ProfilerFileNotFoundException, \
     ProfilerIOException, ProfilerException, ProfilerRawFileException, ProfilerParamTypeErrorException
 from mindspore.profiler.common.exceptions.exceptions import ProfilerPathErrorException
 from mindspore.profiler.common.exceptions.exceptions import ProfilerDirNotFoundException
-from mindspore.profiler.common.util import get_file_path, ProfilerPathManager
-from mindspore.profiler.common.process_pool import MultiProcessPool
+from mindspore.profiler.common.util import get_file_path
 from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
 from mindspore.profiler.parser.framework_parser import GpuFrameWorkParser, DynamicFrameWorkParser
 from mindspore.profiler.parser.integrator import Integrator, DeviceTarget
@@ -65,8 +63,6 @@ from mindspore.profiler.parser.ascend_flops_generator import AscendFlopsGenerato
 from mindspore.profiler.parser.ascend_cluster_generator import AscendClusterGenerator
 from mindspore.profiler.parser.ascend_hccl_generator import AscendHCCLGenerator
 from mindspore.profiler.parser.ascend_communicate_generator import AscendCommunicationGenerator
-from mindspore.profiler.parser.ascend_memory_generator import AscendMemoryGenerator
-from mindspore.profiler.parser.ascend_integrate_generator import AscendIntegrateGenerator
 
 INIT_OP_NAME = 'Default/InitDataSetQueue'
 
@@ -89,12 +85,6 @@ class ModelTraingMode(Enum):
     UNKNOWN = 3
 
 
-class ProfilerLevel(Enum):
-    Level0 = "Level0"
-    Level1 = "Level1"
-    Level2 = "Level2"
-
-
 class DeviceSupportParam(Enum):
     """The device target enum."""
     CPU = ['start', 'start_profile', 'output_path', 'timeline_limit', 'profile_framework', 'op_time']
@@ -105,21 +95,16 @@ class DeviceSupportParam(Enum):
     ASCEND = [
         'start', 'start_profile', 'output_path', 'data_process', 'timeline_limit', 'profile_memory',
         'parallel_strategy', 'profile_communication', 'aicore_metrics', 'l2_cache', 'hbm_ddr', 'pcie', 'op_time',
-        'ascend_job_id', 'profile_framework', 'host_stack', 'profiler_level', 'data_simplification'
+        'ascend_job_id', 'profile_framework'
     ]
 
 
 ALWAYS_VALID_PARAM = [
     'start', 'start_profile', 'output_path', 'data_process', 'parallel_strategy', 'l2_cache',
-    'hbm_ddr', 'pcie', 'ascend_job_id', 'op_time', 'profile_framework', 'profiler_level'
+    'hbm_ddr', 'pcie', 'ascend_job_id', 'op_time', 'profile_framework'
 ]
 
 
-ANALYSIS_ASYNC_MODE = 'async'
-ANALYSIS_SYNC_MODE = 'sync'
-DEFAULT_MODEL_ID = 4294967295
-
-
 def _environment_check():
     if c_expression.security.enable_security():
         raise RuntimeError("Profiler is not supported when MindSpore is compiled with \'-s on\'.")
@@ -313,8 +298,9 @@ def _ascend_graph_msprof_generator(mindstudio_profiler_output, model_iteration_d
         flag = msprof_exporter.export(model_iteration_dict)
         ProfilerInfo.set_export_end_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
         return flag
-    except (ProfilerException, TimeoutError, FileNotFoundError, RuntimeError) as err:
-        logger.warning(str(err))
+
+    except ProfilerException as err:
+        logger.warning(err.message)
         return False
 
 
@@ -330,6 +316,7 @@ def _ascend_graph_msprof_analyse(mindstudio_profiler_output):
         msprof_analyser = AscendMsprofDataGenerator(mindstudio_profiler_output)
         res = msprof_analyser.parse()
         return res
+
     except ProfilerException as err:
         logger.warning(err.message)
     finally:
@@ -349,14 +336,6 @@ class Profiler:
 
     Args:
         output_path (str, optional): Output data path. Default: ``"./data"`` .
-        profiler_level (ProfilerLevel, optional): (Ascend only) The level of profiling. Default: ``None``.
-
-            - Profiler.Level0: Leanest level of profiling data collection, collects information about the elapsed
-              time of the computational operators on the NPU and communication large operator information.
-            - Profiler.Level1: Collect more CANN layer AscendCL data and AICore performance metrics and communication
-              mini operator information based on Level0.
-            - Profiler.Level2: Collect GE and Runtime information in CANN layer on top of Level1
-
         op_time (bool, optional): (Ascend/GPU) Whether to collect operators performance data. Default value: ``True``.
         profile_communication (bool, optional): (Ascend only) Whether to collect communication performance data in
             a multi devices training,collect when True. Setting this parameter has no effect during single card
@@ -368,7 +347,7 @@ class Profiler:
         start_profile (bool, optional): The start_profile parameter controls whether to enable or disable performance
             data collection based on conditions. Default: ``True`` .
         aicore_metrics (int, optional): (Ascend only) Types of AICORE performance data collected, when using this
-            parameter, `op_time` must be set to ``True`` , and the value must be in [-1, 0, 1, 2, 3, 4, 5, 6],
+            parameter, `op_time` must be set to ``True`` , and the value must be in [-1, 0, 1, 2, 3, 4, 5],
             Default: ``0`` , the data items contained in each metric are as follows:
 
             - -1: Does not collect AICORE data.
@@ -408,12 +387,6 @@ class Profiler:
             - "time": Only record host timestamp.
             - "memory": Only record host memory usage.
             - None: Not record host information.
-        data_simplification (bool, optional): (Ascend only) Whether to remove FRAMEWORK data and other redundant data.
-            If set to True, only the delivery of profiler and the original performance data in the PROF_XXX
-            directory are retained to save disk space.
-            Default value: ``True`` .
-        host_stack (bool, optional): (Ascend) Whether to collect frame host call stack data.
-            Default value: ``True`` .
 
     Raises:
         RuntimeError: When the version of CANN does not match the version of MindSpore,
@@ -475,7 +448,7 @@ class Profiler:
 
     def __init__(self, **kwargs):
         if os.getenv("PROFILING_MODE"):
-            raise RuntimeError("Profiling is already enabled by PROFILING_MODE env.")
+            raise RuntimeError("Profiling is already enabled by env.")
 
         self._dev_id = None
         self._cpu_profiler = None
@@ -495,7 +468,6 @@ class Profiler:
         self._timeline_size_limit_byte = 500 * 1024 * 1024  # 500MB
         self._parallel_strategy = True
         self._model_iteration_dict = None
-        self._analyse_mode = ANALYSIS_SYNC_MODE
         _environment_check()
         # default aicore_metrics type is ArithmeticUtilization
         self._aicore_metrics_id = 0
@@ -514,11 +486,8 @@ class Profiler:
         self._dynamic_status = False
         self._profile_framework = "all"
         self._msprof_enable = os.getenv("PROFILER_SAMPLECONFIG")
-        self.profiler_level = None
         self._pretty_json = False
         self._analyse_only = kwargs.get("analyse_only", False)
-        self._data_simplification = kwargs.get("data_simplification", True)
-        self._host_stack = True
         if self._msprof_enable:
             return
         self._start_time = int(time.time() * 1e6)  # us
@@ -578,15 +547,18 @@ class Profiler:
         Returns:
             str, job start time.
         """
+        AscendMsprofExporter.check_msprof_env()
+        script_path = AscendMsprofExporter.get_msprof_info_path()
+        if not script_path:
+            logger.warning("Can`t find get_msprof_info.py path, use single-export mode instead.")
+            return None
+
+        logger.info("get_msprof_info.py path is : %s", script_path)
+        host_dir = os.path.join(prof_dir, 'host')
+        cmd = ['python',
+               script_path,
+               '-dir', host_dir]
         try:
-            AscendMsprofExporter.check_msprof_env()
-            script_path = AscendMsprofExporter.get_msprof_info_path()
-            if not script_path:
-                logger.warning("Can`t find get_msprof_info.py path, use single-export mode instead.")
-                return None
-            logger.info("get_msprof_info.py path is : %s", script_path)
-            host_dir = os.path.join(prof_dir, 'host')
-            cmd = ['python', script_path, '-dir', host_dir]
             outs, _ = AscendMsprofExporter.run_cmd(cmd)
             if not outs:
                 logger.warning('Can`t find the msprof info result')
@@ -598,7 +570,7 @@ class Profiler:
             if jor_start_time is not None:
                 return float(jor_start_time.strip())
             return None
-        except (RuntimeError, JSONDecodeError, AttributeError, TimeoutError, FileNotFoundError) as err:
+        except (RuntimeError, JSONDecodeError, AttributeError) as err:
             logger.warning('Get the drvVersion error, use single-export mode instead. detail : %s', err)
             return None
 
@@ -730,7 +702,7 @@ class Profiler:
                 return message
         return op_info
 
-    def analyse(self, offline_path=None, pretty=False, step_list=None, mode="sync"):
+    def analyse(self, offline_path=None, pretty=False, step_list=None):
         """
         Collect and analyze training performance data, support calls during and after training. The example shows above.
 
@@ -741,38 +713,19 @@ class Profiler:
             pretty (bool, optional): Whether to pretty json files. Default: ``False``.
             step_list (list, optional): A list of steps that need to be analyzed. Default: ``None``.
                 By default, all steps will be analyzed.
-            mode (str, optional): Analysis mode, it must be one of ["sync", "async"]. Default: ``sync``.
-
-                - sync: analyse data in current process, it will block the current process.
-                - async: analyse data in subprocess, it will not the current process.Since the parsing process
-                  will take up extra CPU resources, please enable this mode according to the actual resource situation.
-
         """
-        try:
-            if isinstance(pretty, bool):
-                self._pretty_json = pretty
-            if mode not in [ANALYSIS_SYNC_MODE, ANALYSIS_ASYNC_MODE]:
-                logger.warning("For analyse, the parameter mode must be one of ['sync', 'async'], "
-                               "it will be set to 'sync'.")
-                mode = ANALYSIS_SYNC_MODE
-            model_iteration_dict = {}
-            if step_list is not None and not isinstance(step_list, list):
-                raise ProfilerParamTypeErrorException("Parameter step_list must be a list.")
-            if step_list:
-                if not all(isinstance(step_id, int) for step_id in step_list):
-                    raise ProfilerParamTypeErrorException("The elements of the parameter step_list must be integers.")
-                step_list.sort()
-                if step_list[-1] - step_list[0] != len(step_list) - 1:
-                    err_msg = "The elements of the parameter step_list must be continuous integers."
-                    raise ProfilerParamTypeErrorException(err_msg)
-                model_iteration_dict[DEFAULT_MODEL_ID] = step_list
-            if offline_path is not None and not isinstance(offline_path, str):
-                raise ProfilerParamTypeErrorException("For analyse, the type of parameter offline_path must be str.")
-            self._analyse(offline_path=offline_path, model_iteration_dict=model_iteration_dict, mode=mode)
-        except (ProfilerException, RuntimeError, OSError, TypeError, NameError) as err:
-            logger.error("Profiler analyse failed: %s", str(err))
-
-    def _analyse(self, offline_path=None, model_iteration_dict=None, mode=ANALYSIS_SYNC_MODE):
+        if isinstance(pretty, bool):
+            self._pretty_json = pretty
+        model_iteration_dict = {}
+        if step_list is not None and not isinstance(step_list, list):
+            raise ProfilerParamTypeErrorException("Parameter step_list must be a list.")
+        if step_list:
+            if not isinstance(step_list[0], int):
+                raise ProfilerParamTypeErrorException("The elements of the parameter step_list must be integers.")
+            model_iteration_dict.setdefault(4294967295, []).append(step_list[0])
+        self._analyse(offline_path=offline_path, model_iteration_dict=model_iteration_dict)
+
+    def _analyse(self, offline_path=None, model_iteration_dict=None):
         """
         Collect and analyze training performance data, support calls during and after training. The example shows above.
 
@@ -781,17 +734,15 @@ class Profiler:
                 Offline mode isused in abnormal exit scenario. This parameter should be set to ``None``
                 for online mode. Default: ``None``.
             model_iteration_dict: Dictionary with model id as the key and iteration id as the value, Default: ``None``.
-            mode (str, optional): Analysis mode. Whether to analyse data in subprocess. Default: ``sync``.
-                By default, analyse data in current process.
         """
         self._model_iteration_dict = model_iteration_dict
         self._init_profiler_info()
         self._is_support_step_info_collect()
-        self._analyse_mode = mode
         parallel_mode = get_auto_parallel_context("parallel_mode")
         stage_num = get_auto_parallel_context("pipeline_stages")
 
         ProfilerInfo.set_parallel_info(parallel_mode, stage_num)
+        ProfilerInfo.set_heterogeneous(self._is_heterogeneous)
         if offline_path:
             ProfilerInfo.set_analyse_start_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
             self._ascend_graph_analyse(offline_path=offline_path)
@@ -812,8 +763,6 @@ class Profiler:
         cpu_op_file = glob.glob(os.path.join(self._output_path, 'cpu_op_type_info_*'))
         if self._device_target and self._device_target != DeviceTarget.CPU.value and cpu_op_file:
             self._is_heterogeneous = True
-
-        ProfilerInfo.set_heterogeneous(self._is_heterogeneous)
         ProfilerInfo.set_analyse_start_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
         if self._device_target and self._device_target == DeviceTarget.CPU.value:
             self._cpu_analyse()
@@ -878,8 +827,6 @@ class Profiler:
         self._cpu_profiler.step_profiling_enable(True)
         if self._op_time:
             self._cpu_profiler.enable_op_time()
-        if self._profile_memory:
-            self._cpu_profiler.enable_profile_memory()
 
         if self._device_target and self._device_target == DeviceTarget.GPU.value:
             if self._data_process:
@@ -894,9 +841,8 @@ class Profiler:
                 self._md_profiler.start()
             self._ascend_graph_start()
         ProfilerInfo.set_profiling_start_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
-        ProfilerInfo.set_system_cnt(c_expression.get_clock_syscnt())
         ProfilerInfo.set_system_time(int(c_expression.get_clock_time() * 1e3)) # cast us to ns
-        _framework_profiler_enable_mi()
+        ProfilerInfo.set_system_cnt(c_expression.get_clock_syscnt())
 
     def stop(self):
         """
@@ -1099,9 +1045,7 @@ class Profiler:
             "pcie": self._pcie,
             "parallel_strategy": self.ENABLE_STATUS if self._parallel_strategy else self.DISABLE_STATUS,
             "op_time": self.ENABLE_STATUS if self._op_time else self.DISABLE_STATUS,
-            "profile_framework": self._profile_framework,
-            "profiler_level": self.profiler_level.value if self.profiler_level else self.DISABLE_STATUS,
-            "host_stack": "on" if self._host_stack else "off"
+            "profile_framework": self._profile_framework
         }
 
         return profiling_options
@@ -1151,7 +1095,7 @@ class Profiler:
 
         if self._aicore_metrics_id not in AICORE_METRICS_DICT:
             logger.warning(f"For '{self.__class__.__name__}', the parameter aicore_metrics must be in "
-                           f"[-1, 0, 1, 2, 3, 4, 5, 6], but got {self._aicore_metrics_id}, it will be set to 0.")
+                           f"[-1, 0, 1, 2, 3, 4, 5], but got {self._aicore_metrics_id}, it will be set to 0.")
             self._aicore_metrics_id = 0
 
         l2_cache_enable = kwargs.pop("l2_cache", False)
@@ -1181,22 +1125,6 @@ class Profiler:
                            f"but got type {type(self._parallel_strategy)}, it will be set to True.")
             self._parallel_strategy = True
 
-        self.profiler_level = kwargs.pop("profiler_level", None)
-        if self.profiler_level and not isinstance(self.profiler_level, ProfilerLevel):
-            logger.warning(f"For '{self.__class__.__name__}', the parameter profiler_level must be one of "
-                           f"[ProfilerLevel.Level0, ProfilerLevel.Level1, ProfilerLevel.Level2], but got type "
-                           f"{type(self.profiler_level)}, it will be set to ProfilerLevel.Level0.")
-            self.profiler_level = ProfilerLevel.Level0
-        elif self.profiler_level == ProfilerLevel.Level0:
-            self._data_process = False
-            self._aicore_metrics_id = -1
-            logger.warning(f"For '{self.__class__.__name__}', when profiler_level set Level0, data_process will be set "
-                           f"to False and aicore_metrics set to -1.")
-        elif self.profiler_level == ProfilerLevel.Level1:
-            self._data_process = False
-            logger.warning(f"For '{self.__class__.__name__}', when profiler_level set Level1, data_process will be set "
-                           f"to False.")
-
     def _ascend_analyse(self):
         """Collect and analyse ascend performance data."""
         self._rank_size = 1
@@ -1213,15 +1141,18 @@ class Profiler:
             self.stop()
         else:
             logger.info("No need to stop profiler because profiler has been stopped.")
-        self._ascend_profiler.finalize()
         # export op data before analyse
         self._ascend_graph_analyse()
 
-    def _minddata_analyse(self):
+    def _minddata_analyse(self, source_path):
         """Analyse mindadata for ascend graph model."""
         if not self._data_process:
             return
         store_id = self._rank_id if self._device_target == DeviceTarget.ASCEND.value else self._dev_id
+        # Parsing minddata AICPU profiling
+        if self._device_target == DeviceTarget.ASCEND.value:
+            logger.info("Profiling: analyzing the minddata AICPU data.")
+            MinddataParser.execute(source_path, self._output_path, store_id)
 
         # parse minddata pipeline operator and queue
         try:
@@ -1241,16 +1172,6 @@ class Profiler:
         finally:
             pass
 
-    def _minddata_aicpu_analyse(self, source_path, job_id):
-        """Analyse minddata aicpu after ascend."""
-        if not self._data_process:
-            return
-        store_id = self._rank_id if self._device_target == DeviceTarget.ASCEND.value else self._dev_id
-        # Parsing minddata AICPU profiling
-        if self._device_target == DeviceTarget.ASCEND.value:
-            logger.info("Profiling: analyzing the minddata AICPU data.")
-            MinddataParser.execute(source_path, self._output_path, job_id, store_id)
-
     def _ascend_fpbp_analyse(self, op_summary, steptrace):
         """
         Ascned graph model op analyse.
@@ -1305,8 +1226,8 @@ class Profiler:
             op_analyser.parse()
             op_analyser.write(op_intermediate_detail_path, op_intermediate_type_path,
                               aicpu_intermediate_detail_path, framework_raw_path, output_timeline_data_path)
-        except (ProfilerException, RuntimeError) as err:
-            logger.warning(str(err))
+        except ProfilerException as err:
+            logger.warning(err.message)
         finally:
             pass
 
@@ -1333,12 +1254,12 @@ class Profiler:
         try:
             logger.info("Profiling: analyzing the timeline data")
             timeline_analyser = AscendTimelineGenerator(self._output_path, source_path, mindstudio_profiler_output,
-                                                        self._rank_id, self._rank_size, context.get_context('mode'),
-                                                        self._model_iteration_dict.get(DEFAULT_MODEL_ID))
+                                                        self._rank_id, self._rank_size, context.get_context('mode'))
             timeline_analyser.parse_cluster_data(op_summary, steptrace)
             timeline_analyser.parse_timeline_data(pretty=self._pretty_json)
             timeline_analyser.write_timeline_display()
             timeline_analyser.write_timeline_summary()
+
         except (ProfilerIOException, ProfilerFileNotFoundException, RuntimeError) as err:
             logger.warning('Fail to write timeline data: %s', err)
         finally:
@@ -1376,8 +1297,8 @@ class Profiler:
             flops_analyser.parse()
             flops_analyser.write(flops_path, flops_summary_path)
 
-        except (ProfilerException, RuntimeError) as err:
-            logger.warning(str(err))
+        except ProfilerException as err:
+            logger.warning(err.message)
         finally:
             pass
 
@@ -1418,23 +1339,8 @@ class Profiler:
         target_timeline_path = os.path.join(ascend_profiler_output_path, f"trace_view.json")
         shutil.copy(source_timeline_path, target_timeline_path)
 
-        src_op_mem_file = os.path.join(self._output_path, f"operator_memory_{dev_id}.csv")
-        if os.path.exists(src_op_mem_file):
-            dst_op_mem_file = os.path.join(ascend_profiler_output_path, f"operator_memory.csv")
-            shutil.copy(src_op_mem_file, dst_op_mem_file)
-
-        ms_output_path = os.path.abspath(
-            os.path.join(source_path, os.path.pardir, 'mindstudio_profiler_output'))
-        static_op_mem_path = os.path.join(ms_output_path, f"static_op_mem_*.csv")
-        src_static_op_mem_path = glob.glob(static_op_mem_path)
-        if src_static_op_mem_path:
-            dst_static_op_mem_file = os.path.join(ascend_profiler_output_path, f"static_op_mem.csv")
-            shutil.copy(src_static_op_mem_path[0], dst_static_op_mem_file)
-
         self._ascend_graph_cluster_analyse(source_path, ascend_profiler_output_path)
         self._ascend_graph_communicate_analyse(source_path, ascend_profiler_output_path)
-        AscendIntegrateGenerator(source_path, ascend_profiler_output_path).parse()
-        AscendMemoryGenerator(self._output_path, self._rank_id, source_path, ascend_profiler_output_path).parse()
 
     def _ascend_graph_cluster_analyse(self, source_path, ascend_profiler_output_path):
         """Analyse step trace time info"""
@@ -1526,7 +1432,7 @@ class Profiler:
             return []
         kernel_map = {}
         for kernel in kernels:
-            key = kernel.name if kernel.name.startswith('hcom_') else (kernel.name, str(kernel.ts))
+            key = kernel.name if kernel.is_comm_op else (kernel.name, str(kernel.ts))
             kernel_map[key] = kernel.parent
         launch_ops = [None] * len(op_summary)
         for index, summary in enumerate(op_summary):
@@ -1542,13 +1448,10 @@ class Profiler:
         return launch_ops
 
     def _ascend_graph_analyse(self, offline_path=None):
-        if offline_path or self._analyse_mode == ANALYSIS_SYNC_MODE:
-            self._ascend_graph_analyse_inner(offline_path)
-        else:
-            MultiProcessPool().add_async_job(self._ascend_graph_analyse_inner)
-
-    def _ascend_graph_analyse_inner(self, offline_path=None):
         """Ascend graph mode analyse."""
+        if not offline_path:
+            self._ascend_profiler.finalize()
+
         job_id = self._get_profiling_job_id(offline_path)
         if not job_id:
             return
@@ -1556,10 +1459,10 @@ class Profiler:
 
         self._check_output_path(output_path=self._output_path)
         source_path = os.path.join(self._output_path, job_id)
-        self._minddata_analyse()
+        self._minddata_analyse(source_path)
         if self._op_time:
-            mindstudio_profiler_output = os.path.abspath(
-                os.path.join(source_path, os.path.pardir, 'mindstudio_profiler_output'))
+            mindstudio_profiler_output = os.path.abspath(os.path.join(source_path, os.path.pardir,
+                                                                      'mindstudio_profiler_output'))
             flag = _ascend_graph_msprof_generator(mindstudio_profiler_output, self._model_iteration_dict)
             if not flag:
                 logger.warning('Current driver package not support all export mode, use single export mode, '
@@ -1586,12 +1489,7 @@ class Profiler:
             self._ascend_ms_analyze(mindstudio_profiler_output)
             self._ascend_graph_hccl_analyse(mindstudio_profiler_output, steptrace)
             self._ascend_graph_msadvisor_analyse(job_id)
-            self._minddata_aicpu_analyse(self._output_path, job_id)
             ProfilerInfo.set_graph_ids(graph_ids)
-        try:
-            ProfilerPathManager.simplify_data(self._output_path, self._data_simplification)
-        except RuntimeError as err:
-            logger.error('Profilier simplify data failed, %s', str(err))
 
     def _ascend_graph_start(self):
         """Ascend graph mode start profiling."""
@@ -1620,7 +1518,7 @@ class Profiler:
         else:
             logger.info("No need to stop profiler because profiler has been stopped.")
 
-        self._minddata_analyse()
+        self._minddata_analyse(self._output_path)
 
         try:
             self._analyse_step_relation_info()
@@ -1990,21 +1888,6 @@ class Profiler:
             logger.warning(f"For '{self.__class__.__name__}', the parameter profile_framework must be one of ['memory',"
                            f" 'time', 'all', None], but got {self._profile_framework}, it will be set to 'all'.")
             self._profile_framework = "all"
-        if not isinstance(self._data_simplification, bool):
-            logger.warning(f"For '{self.__class__.__name__}', the parameter data_simplification must be bool, "
-                           f"but got type {type(self._data_simplification)}, it will be set to True.")
-            self._data_simplification = True
-
-        if not isinstance(self._data_simplification, bool):
-            logger.warning(f"For '{self.__class__.__name__}', the parameter data_simplification must be bool, "
-                           f"but got type {type(self._data_simplification)}, it will be set to True.")
-            self._data_simplification = True
-
-        self._host_stack = kwargs.pop("host_stack", True)
-        if not isinstance(self._host_stack, bool):
-            logger.warning(f"For '{self.__class__.__name__}', the parameter host_stack must be bool, but got "
-                           f"type {type(self._host_stack)}, it will be set to True.")
-            self._host_stack = True
 
     def _host_info_analyse(self):
         """
@@ -2014,7 +1897,7 @@ class Profiler:
         host_dir = os.path.join(self._output_path, 'host_info')
         host_dir = validate_and_normalize_path(host_dir)
         if not os.path.exists(host_dir):
-            logger.warning("Host info directory: %s not exist.", host_dir)
+            logger.error("Host info directory: %s not exist.", host_dir)
             return
         csv_file_name = 'host_info_' + str(self._rank_id) + '.csv'
         json_file_name = 'timeline_' + str(self._rank_id) + '.json'
@@ -2035,7 +1918,7 @@ def _offline_parse(offline_path):
     host_dir = os.path.join(offline_path, 'profiler', 'host_info')
     host_dir = validate_and_normalize_path(host_dir)
     if not os.path.exists(host_dir):
-        logger.warning("Host info directory: %s not exist.", host_dir)
+        logger.error("Host info directory: %s not exist.", host_dir)
         return
     files = os.listdir(host_dir)
     for file in files:

mindspore/rewrite/api/node.py

@@ -142,7 +142,7 @@ class Node:
         Examples:
             >>> from mindspore.rewrite import SymbolTree, ScopedValue
             >>> import mindspore.nn as nn
-            >>> from mindspore import ops
+            >>> import mindspore.ops as ops
             >>> # Define the network structure of LeNet5. Refer to
             >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
             >>> net = LeNet5()

mindspore/rewrite/common/namespace.py

@@ -17,14 +17,14 @@ import os
 import sys
 import inspect
 import types
-from mindspore._extends.parse.namespace import ModuleNamespace
+from mindspore._extends.parse.namespace import CellNamespace
 from mindspore.nn import CellList, SequentialCell
 
 
-_ms_common_ns = ModuleNamespace('mindspore.common')
-_ms_nn_ns = ModuleNamespace('mindspore.nn')
-_ms_ops_ns = ModuleNamespace('mindspore.ops.operations')
-_ms_functional_ns = ModuleNamespace('mindspore.ops.functional')
+_ms_common_ns = CellNamespace('mindspore.common')
+_ms_nn_ns = CellNamespace('mindspore.nn')
+_ms_ops_ns = CellNamespace('mindspore.ops.operations')
+_ms_functional_ns = CellNamespace('mindspore.ops.functional')
 
 # Elements in _subtree_black_list will not be converted to symbol tree.
 # Only str and types are stored in _subtree_black_list.

mindspore/rewrite/parsers/assign_parser.py

@@ -664,8 +664,6 @@ class AssignParser(Parser):
         if method_object is not None:
             if inspect.ismethod(method_object):
                 self.process_class_method(func_scope_name, func_name, method_object)
-            elif isinstance(inspect.getattr_static(self.stree.get_origin_network(), func_name), staticmethod):
-                self.insert_callfunction_node(func_scope_name, func_name, None, None, False)
             else:
                 self.process_function(func_scope_name, func_name, method_object, False)
             return

mindspore/rewrite/parsers/class_def_parser.py

@@ -20,7 +20,7 @@ import sys
 from textwrap import dedent
 from mindspore import log as logger
 from mindspore.nn import Cell
-from mindspore._extends.parse.namespace import ModuleNamespace
+from mindspore._extends.parse.namespace import CellNamespace
 from . import Parser, ParserRegister, reg_parser
 from ..node import NodeManager
 from ..symbol_tree import SymbolTree
@@ -47,7 +47,7 @@ class ClassDefParser(Parser):
     def __init__(self):
         """Constructor"""
         super(ClassDefParser, self).__init__()
-        self._cell_namespace = ModuleNamespace('mindspore.nn')
+        self._cell_namespace = CellNamespace('mindspore.nn')
 
     @staticmethod
     def _save_imports(stree):
@@ -114,14 +114,10 @@ class ClassDefParser(Parser):
             if key.startswith('__'):
                 # ignore inner functions
                 continue
-            is_staticmethod = isinstance(value, staticmethod)
-            if not is_staticmethod and callable(value) and key in function_defs:
+            if callable(value) and key in function_defs:
                 # ignore functions defined by self
                 continue
-            if is_staticmethod:
-                assign_code = f"self.{key} = obj.__class__.{key}"
-            else:
-                assign_code = f"self.__class__.{key} = obj.__class__.{key}"
+            assign_code = f"self.__class__.{key} = obj.__class__.{key}"
             assign_ast = ast.parse(assign_code).body[0]
             init_func_ast.body.append(assign_ast)
 

mindspore/run_check/_check_version.py

@@ -259,7 +259,7 @@ class AscendEnvChecker(EnvChecker):
 
     def __init__(self, library_path):
         self.library_path = library_path
-        self.version = ["7.2", "7.3"]
+        self.version = ["7.2"]
         atlas_nnae_version = "/usr/local/Ascend/nnae/latest/compiler/version.info"
         atlas_toolkit_version = "/usr/local/Ascend/ascend-toolkit/latest/compiler/version.info"
         hisi_fwk_version = "/usr/local/Ascend/latest/compiler/version.info"

mindspore/scipy/fft.py

@@ -15,11 +15,13 @@
 """fft operations, the function docs are adapted from Scipy API."""
 from __future__ import absolute_import
 from __future__ import division
-__all__ = ['dct', 'idct']
+
 from mindspore.ops.auto_generate import DCT
 from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore.scipy.utils import _raise_value_error
 
+__all__ = ['dct', 'idct']
+
 
 def dct(x, type=2, n=None, axis=-1, norm=None):
     """

mindspore/scipy/linalg.py

@@ -14,8 +14,6 @@
 # ============================================================================
 """Linear algebra submodule"""
 from __future__ import absolute_import
-__all__ = ['block_diag', 'inv', 'cho_factor', 'cholesky',
-           'cho_solve', 'eigh', 'lu_factor', 'lu', 'solve_triangular']
 from .ops import LU, SolveTriangular
 from .utils import _nd_transpose, _value_check, _type_check, _dtype_check, _mstype_check, _square_check, _solve_check
 from .utils_const import _raise_value_error
@@ -27,6 +25,9 @@ from ..ops.operations.linalg_ops import Eigh
 from ..ops import functional as F
 from ..ops import operations as P
 
+__all__ = ['block_diag', 'inv', 'cho_factor', 'cholesky',
+           'cho_solve', 'eigh', 'lu_factor', 'lu', 'solve_triangular']
+
 
 def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False, overwrite_b=False, debug=None, check_finite=True):
     """