mindspore 2.0.0a0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/profiler/profiling.py

@@ -18,6 +18,8 @@ import stat
 import time
 import json
 import glob
+import subprocess
+from enum import Enum
 
 from mindspore import log as logger, context
 from mindspore.communication.management import GlobalComm, get_rank, get_group_size
@@ -48,6 +50,7 @@ from mindspore.profiler.parser.hccl_parser import HcclParser
 from mindspore.profiler.parser.op_intermediate_parser import OPIntermediateParser
 from mindspore.profiler.parser.msadvisor_analyzer import Msadvisor
 from mindspore.profiler.parser.profiler_info import ProfilerInfo
+from mindspore.common.api import _pynative_executor
 
 INIT_OP_NAME = 'Default/InitDataSetQueue'
 
@@ -62,6 +65,18 @@ AICORE_METRICS_DICT = {
 }
 
 
+class DeviceSupportParam(Enum):
+    """The device target enum."""
+    CPU = ['start', 'start_profile', 'output_path', 'timeline_limit']
+    GPU = ['start', 'start_profile', 'output_path', 'data_process', 'timeline_limit', 'sync_enable', 'op_time']
+    ASCEND = ['start', 'start_profile', 'output_path', 'data_process', 'timeline_limit', 'profile_memory',
+              'parallel_strategy', 'profile_communication', 'aicore_metrics', 'l2_cache', 'op_time', 'ascend_job_id']
+
+
+ALWAYS_VALID_PARAM = ['start', 'start_profile', 'output_path', 'data_process', 'parallel_strategy', 'l2_cache',
+                      'ascend_job_id', 'op_time']
+
+
 def _environment_check():
     if c_expression.security.enable_security():
         raise RuntimeError("Profiler is not supported when MindSpore is compiled with \'-s on\'.")
@@ -78,15 +93,19 @@ class Profiler:
 
     Args:
         output_path (str, optional): Output data path. Default: "./data".
+        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 device
-            training. Default: False.
+            training. When using this parameter, `op_time` must be set to True. Default: False.
         profile_memory (bool, optional): (Ascend only) Whether to collect tensor memory data, collect when True.
-            Default: False.
+            When using this parameter, `op_time` must be set to True. Default: False.
+        parallel_strategy (bool, optional): (Ascend only) Whether to collect parallel policy performance data.
+            Default value: true.
         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. The value must be in
-            [-1, 0, 1, 2, 3, 4, 5], Default: 0, the data items contained in each metric are as follows:
+        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], Default: 0, the
+            data items contained in each metric are as follows:
 
             - -1: Does not collect AICORE data.
             - 0: ArithmeticUtilization contains mac_fp16/int8_ratio, vec_fp32/fp16/int32_ratio, vec_misc_ratio etc.
@@ -105,7 +124,11 @@ class Profiler:
               Then the operator is returned to the CPU after execution, and the end timestamp is recorded,
               The duration of the operator is the difference between the two timestamps.
             - False: The asynchronous way. The duration of the operator is that of sending from the CPU to the GPU.
-              This method can reduce the impact of adding profiler on training time.
+              This method can reduce the impact of adding profiler on overall training time.
+        data_process (bool, optional): (Ascend/GPU) Whether to collect data to prepare performance data.
+            Default value: True.
+        timeline_limit (int, optional): Set the maximum storage size of the timeline file (unit M). When using this
+            parameter, `op_time` must be set to True. Default value: 500.
 
     Raises:
         RuntimeError: When the version of CANN does not match the version of MindSpore,
@@ -165,16 +188,6 @@ class Profiler:
     _ascend_job_id = ""
 
     def __init__(self, **kwargs):
-        self._msprof_enable = os.getenv("PROFILER_SAMPLECONFIG")
-        if self._msprof_enable:
-            return
-        if kwargs.get("env_enable"):
-            self._profiler_init(kwargs)
-            return
-        if Profiler._has_initialized:
-            msg = "Do not init twice in the profiler."
-            raise RuntimeError(msg)
-        Profiler._has_initialized = True
         self._dev_id = None
         self._cpu_profiler = None
         self._gpu_profiler = None
@@ -187,7 +200,7 @@ class Profiler:
         self._job_id_env = None
         self._filt_optype_names = ''
         self._output_path = ''
-        self._rank_size = 0
+        self._rank_size = 1
         self._rank_id = 0
         self._ascend_profiler = None
         self._timeline_size_limit_byte = 500 * 1024 * 1024  # 500MB
@@ -197,10 +210,7 @@ class Profiler:
         self._aicore_metrics_id = 0
         self._l2_cache = "off"
         self._data_process = True
-        self._parser_kwargs(kwargs)
-        # get device_id and device_target
-        self._get_devid_rankid_and_devtarget()
-        self._get_output_path(kwargs)
+        self._op_time = True
         self._profile_communication = False
         self._has_started = False
         self._has_started_twice = False
@@ -209,6 +219,20 @@ class Profiler:
         self._sync_enable = True
         self._stop_time = 0
         self._dynamic_status = False
+        self._msprof_enable = os.getenv("PROFILER_SAMPLECONFIG")
+        if self._msprof_enable:
+            return
+        if kwargs.get("env_enable"):
+            self._profiler_init(kwargs)
+            return
+        if Profiler._has_initialized:
+            msg = "Do not init twice in the profiler."
+            raise RuntimeError(msg)
+        Profiler._has_initialized = True
+        # get device_id and device_target
+        self._get_devid_rankid_and_devtarget()
+        self._parser_kwargs(kwargs)
+        self._get_output_path(kwargs)
         self._decide_device_target(kwargs)
         if self.start_profile:
             self.start()
@@ -227,7 +251,7 @@ class Profiler:
         return output_path
 
     @staticmethod
-    def _parse_host_start_log(input_file):
+    def _parse_start_log(input_file):
         """
         Parse host start log file, get the start time of the job.
 
@@ -238,12 +262,9 @@ class Profiler:
             str, job start time.
         """
 
-        job_start_time = ""
+        job_start_time = 0
         with open(input_file) as f:
-            for line in f.readlines():
-                if "clock_realtime" in line:
-                    # 16 means the first digit of the timestamp, len(line)-3 means the last.
-                    job_start_time = line[16:len(line) - 3]
+            job_start_time = json.load(f).get("collectionTimeBegin")
 
         return job_start_time
 
@@ -260,7 +281,7 @@ class Profiler:
         Raises:
             TypeError: If the op_name parameter type is incorrect.
             TypeError: If the device_id parameter type is incorrect.
-            RunTimeError: If MindSpore runs on Ascend, this interface cannot be used.
+            RuntimeError: If MindSpore runs on Ascend, this interface cannot be used.
 
         Supported Platforms:
             ``GPU`` ``CPU``
@@ -317,6 +338,10 @@ class Profiler:
         """
         if self._msprof_enable:
             return
+
+        # Stop data collection after all operators are executed.
+        _pynative_executor.sync()
+
         Profiler._has_initialized = False
         self._dynamic_status = self._profiler_manager.dynamic_status()
         _environment_check()
@@ -327,7 +352,6 @@ class Profiler:
         if self._device_target and self._device_target != DeviceTarget.CPU.value and cpu_op_file:
             self._is_heterogeneous = True
         ProfilerInfo.set_analyse_start_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
-        self._init_profiler_info()
         if self._device_target and self._device_target == DeviceTarget.CPU.value:
             self._cpu_analyse()
 
@@ -337,6 +361,7 @@ class Profiler:
         elif self._device_target and self._device_target == DeviceTarget.ASCEND.value:
             self._ascend_analyse()
         logger.info("Profiling: all the data have been analyzed.")
+        self._init_profiler_info()
         ProfilerInfo.set_analyse_end_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
         ProfilerInfo.set_rank_size(self._rank_size)
         ProfilerInfo.set_heterogeneous(self._is_heterogeneous)
@@ -376,10 +401,8 @@ class Profiler:
         """
         if self._msprof_enable:
             return
-        if not self.start_profile and context.get_context("mode") == context.PYNATIVE_MODE:
-            raise RuntimeError("Pynative mode does not support conditional collection of performance data.")
 
-        self._start_time = int(time.time() * 10000000)
+        self._start_time = int(time.time() * 1000000)
         logger.info("Profiling: start time: %d", self._start_time)
 
         if not self._has_started:
@@ -402,7 +425,9 @@ class Profiler:
         if self._device_target and self._device_target == DeviceTarget.GPU.value:
             if self._data_process:
                 self._md_profiler.start()
-            self._gpu_profiler.step_profiling_enable(True)
+                self._gpu_profiler.data_process_enable(True)
+            if self._op_time:
+                self._gpu_profiler.step_profiling_enable(True)
         elif self._device_target and self._device_target == DeviceTarget.ASCEND.value:
             if self._data_process:
                 self._md_profiler.start()
@@ -441,6 +466,7 @@ class Profiler:
         """
         if self._msprof_enable:
             return
+
         if self._has_started:
             self._has_started = False
         else:
@@ -450,6 +476,10 @@ class Profiler:
         # No need to stop anything if parse profiling data offline
         if self._is_offline_parser():
             return
+
+        # Stop data collection after all operators are executed.
+        _pynative_executor.sync()
+
         if self._data_process:
             self._md_profiler.stop()
             self._md_profiler.save(self._output_path)
@@ -466,18 +496,15 @@ class Profiler:
     def _profiler_init(self, kwargs):
         """Initialize variables when profiler is enabled by environment variables."""
         options = kwargs.get("env_enable")
-        self._filt_optype_names = ''
         self._has_started = True
-        self._stop_time = 0
-        self._is_heterogeneous = False
-        self._rank_size = 1
         self._start_time = options.get("start_time")
         self._output_path = options.get('file_output_path')
         self._profile_memory = options.get('profile_memory')
         self._parallel_strategy = options.get('parallel_strategy')
-        self._timeline_size_limit_byte = options.get('timeline_limit')
+        self._timeline_size_limit_byte = options.get('timeline_limit') * 1024 * 1024
         self._data_process = options.get('data_process')
         self._profile_communication = options.get('profile_communication')
+        self._op_time = options.get('op_time')
         self._device_target = context.get_context("device_target").lower()
         self._profiler_manager = c_expression.ProfilerManager.get_instance()
         self._cpu_profiler = c_expression.Profiler.get_instance("CPU")
@@ -495,7 +522,8 @@ class Profiler:
         mode = "graph"
         if context.get_context("mode") == context.PYNATIVE_MODE:
             mode = "pynative"
-        ProfilerInfo.init_info(mode, self._rank_id)
+        store_id = self._dev_id if self._device_target == DeviceTarget.GPU.value else self._rank_id
+        ProfilerInfo.init_info(mode, store_id)
 
     def _decide_device_target(self, kwargs):
         """Complete Profiler initialization according to device_target"""
@@ -522,14 +550,6 @@ class Profiler:
             raise TypeError(f"For '{self.__class__.__name__}', the parameter start_profile must be bool, "
                             f"but got type {type(self.start_profile)}")
 
-        self._profile_communication = kwargs.pop("profile_communication", False)
-        if self._profile_communication:
-            logger.warning(f"The parameter profile_communication is not supported on CPU currently.")
-
-        self._profile_memory = kwargs.pop("profile_memory", False)
-        if self._profile_memory:
-            logger.warning(f"The parameter profile_memory is not supported on CPU currently.")
-
     def _gpu_profiler_init(self, kwargs):
         """Gpu profiler init."""
         # Setup and start MindData Profiling
@@ -579,13 +599,6 @@ class Profiler:
         """
         Construct profiling options to determine which profiling data should be collected.
         """
-        profile_memory = "off"
-        if self._profile_memory:
-            profile_memory = "on"
-        profiler_communication = "off"
-        if self._profile_communication:
-            profiler_communication = "on"
-
         fp_point = os.environ.get("PROFILING_FP_START", "")
         bp_point = os.environ.get("PROFILING_BP_END", "")
 
@@ -593,37 +606,30 @@ class Profiler:
             "output": self._output_path,
             "fp_point": fp_point,
             "bp_point": bp_point,
-            "training_trace": "on",
-            "task_trace": "on",
+            "training_trace": "on" if self._op_time else "off",
+            "task_trace": "on" if self._op_time else "off",
             "aic_metrics": AICORE_METRICS_DICT.get(self._aicore_metrics_id, "ArithmeticUtilization"),
-            "aicpu": "on",
-            "profile_memory": profile_memory,
-            "hccl": profiler_communication,
+            "aicpu": "on" if self._data_process or self._op_time else "off",
+            "profile_memory": "on" if self._op_time and self._profile_memory else "off",
+            "hccl": "on" if self._op_time and self._profile_communication else "off",
             "l2_cache": self._l2_cache,
             "parallel_strategy": "on" if self._parallel_strategy else "off",
+            "op_time": "on" if self._op_time else "off"
         }
 
         return profiling_options
 
     def _parse_parameter_for_gpu(self, kwargs):
         """Parse parameter in Proflier when the device target is GPU."""
-
         self.start_profile = kwargs.pop("start_profile", True)
         if not isinstance(self.start_profile, bool):
             raise TypeError(f"For '{self.__class__.__name__}', the parameter start_profile must be bool, "
                             f"but got type {type(self.start_profile)}")
 
-        self._profile_communication = kwargs.pop("profile_communication", False)
-        if self._profile_communication:
-            logger.warning(f"The parameter profile_communication is not supported on GPU currently.")
-
-        self._profile_memory = kwargs.pop("profile_memory", False)
-        if self._profile_memory:
-            logger.warning(f"The parameter profile_memory is not supported on GPU currently.")
-
         self._sync_enable = kwargs.pop("sync_enable", True)
         if not isinstance(self._sync_enable, bool):
             logger.warning("The parameter sync_enable is an invalid value, it will be set to True.")
+            self._sync_enable = True
 
     def _parse_parameter_for_ascend(self, kwargs):
         """Parse parameter in Proflier when the device target is Ascend."""
@@ -636,8 +642,9 @@ class Profiler:
 
         self._profile_communication = kwargs.pop("profile_communication", False)
         if not isinstance(self._profile_communication, bool):
-            raise TypeError(f"For '{self.__class__.__name__}', the parameter profile_communication must be bool, "
-                            f"but got type {type(self._profile_communication)}")
+            logger.warning(f"For '{self.__class__.__name__}', the parameter profile_communication must be bool, "
+                           f"but got type {type(self._profile_communication)}, it will be set to False.")
+            self._profile_communication = False
 
         if self._profile_communication:
             hccl_option = {"output": self._output_path, "task_trace": "on"}
@@ -648,21 +655,26 @@ class Profiler:
 
         self._profile_memory = kwargs.pop("profile_memory", False)
         if not isinstance(self._profile_memory, bool):
-            raise TypeError(f"For '{self.__class__.__name__}', the parameter profile_memory must be bool, "
-                            f"but got type '{type(self._profile_memory)}'")
+            logger.warning(f"For '{self.__class__.__name__}', the parameter profile_memory must be bool, "
+                           f"but got type {type(self._profile_memory)}, it will be set to False.")
+            self._profile_memory = False
 
         self._aicore_metrics_id = kwargs.pop("aicore_metrics", 0)
         if not isinstance(self._aicore_metrics_id, int):
-            raise TypeError(f"For '{self.__class__.__name__}', the parameter aicore_metrics must be int, "
-                            f"but got type {type(self._aicore_metrics_id)}")
+            logger.warning(f"For '{self.__class__.__name__}', the parameter aicore_metrics must be int, "
+                           f"but got type {type(self._aicore_metrics_id)}, it will be set to 0.")
+            self._aicore_metrics_id = 0
+
         if self._aicore_metrics_id not in AICORE_METRICS_DICT:
-            raise ValueError(f"For '{self.__class__.__name__}', the parameter aicore_metrics must be in "
-                             f"[-1, 0, 1, 2, 3, 4, 5], but got {self._aicore_metrics_id}")
+            logger.warning(f"For '{self.__class__.__name__}', the parameter aicore_metrics must be in "
+                           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)
         if not isinstance(l2_cache_enable, bool):
-            raise TypeError(f"For '{self.__class__.__name__}', the parameter l2_cache must be bool, "
-                            f"but got type {type(l2_cache_enable)}")
+            logger.warning(f"For '{self.__class__.__name__}', the parameter l2_cache must be bool, "
+                           f"but got type {type(l2_cache_enable)}, it will be set to False.")
+            l2_cache_enable = False
         if l2_cache_enable:
             self._l2_cache = "on"
         else:
@@ -670,15 +682,9 @@ class Profiler:
 
         self._parallel_strategy = kwargs.pop("parallel_strategy", True)
         if not isinstance(self._parallel_strategy, bool):
-            raise TypeError(f"For '{self.__class__.__name__}', the parameter parallel_strategy must be bool, "
-                            f"but got type {type(self._parallel_strategy)}")
-
-        self._sync_enable = kwargs.pop("sync_enable", False)
-        if self._sync_enable:
-            logger.warning(f"The parameter sync_enable is not supported on Ascend currently.")
-
-        if kwargs:
-            logger.warning("%s are invalid params which don't work.", kwargs)
+            logger.warning(f"For '{self.__class__.__name__}', the parameter parallel_strategy must be bool, "
+                           f"but got type {type(self._parallel_strategy)}, it will be set to True.")
+            self._parallel_strategy = True
 
         task_sink = os.getenv("GRAPH_OP_RUN")
         if task_sink and task_sink == "1":
@@ -742,18 +748,45 @@ class Profiler:
             logger.info("No need to stop profiler because profiler has been stopped.")
         self._ascend_graph_analyse()
 
-        # Call MSAdvisor function
+    def _ascend_timeline_analyse(self, aicpu_data_parser, optime_parser, source_path):
+        """Analyse timeline info."""
         try:
-            msadvisor = Msadvisor(self._get_profiling_job_id(), self._rank_id, self._output_path)
-            logger.info("MSAdvisor starts running.")
-            msadvisor.analyse()
-        except (ProfilerFileNotFoundException, ValueError, FileNotFoundError, OSError) as err:
-            if context.get_context("mode") == context.PYNATIVE_MODE:
-                logger.warning("Pynative mode does not support MSAdvisor analyzer currently.")
-            else:
-                logger.warning("MSAdvisor running failed. %s", err)
+            self._analyse_timeline(aicpu_data_parser, optime_parser, source_path)
+        except (ProfilerIOException, ProfilerFileNotFoundException, RuntimeError) as err:
+            logger.warning('Fail to write timeline data: %s', err)
+        finally:
+            pass
+
+    def _ascend_step_trace_analyse(self, source_path, framework_parser):
+        """Analyse step trace info."""
+        points, is_training_mode_flag = None, False
+        try:
+            if self._is_support_step_info_collect() and not self._dynamic_status:
+                points, is_training_mode_flag = self._analyse_step_trace(source_path, framework_parser)
+        except ProfilerException as err:
+            logger.warning(err.message)
         finally:
             pass
+        return points, is_training_mode_flag
+
+    def _ascend_dynamic_net_analyse(self):
+        """Analyse dynamic shape network info."""
+        if self._profile_communication:
+            logger.warning(
+                "The profile_communication parameter cannot be set on the dynamic shape network.")
+        if self._profile_memory:
+            logger.warning("The profile_memory parameter cannot be set on the dynamic shape network.")
+        logger.warning(
+            "[Profiler]Dynamic Shape network does not support collecting step trace performance data currently.")
+        dynamic_parser = DynamicFrameWorkParser(self._output_path, self._rank_id)
+        dynamic_parser.write_dynamic_shape_data()
+
+    def _ascend_flops_analyse(self, source_path, op_task_dict, is_training_mode_flag):
+        """Get op FLOPs from aicore.data.x.slice.0 file, and compute FLOPS, write output_op_flops_x.txt."""
+        flops_parser = FlopsParser(source_path, self._output_path, op_task_dict, self._dev_id, self._rank_id,
+                                   is_training_mode_flag)
+        logger.info("Profiling: analyzing the operation FLOPs.")
+        flops_parser.execute()
 
     def _ascend_graph_memory_analyse(self, points):
         """Analyse memory usage info."""
@@ -785,6 +818,26 @@ class Profiler:
         finally:
             pass
 
+    def _ascend_graph_msadvisor_analyse(self, job_id):
+        """Call MSAdvisor function."""
+        logger.info("MSAdvisor starts running.")
+        msadvisor = Msadvisor(job_id, self._rank_id, self._output_path)
+        try:
+            msadvisor.analyse()
+        except FileNotFoundError as err:
+            logger.warning("MSAdvisor: command not found,"
+                           "please check if installed ascend-toolkit and set environment path correctly. %s", err)
+        except OSError as err:
+            logger.warning("Cannot execute binary file: Exec format error. %s", err)
+        except subprocess.CalledProcessError:
+            logger.warning("MSAdvisor running failed, please check MSAdvisor running log.")
+        except (ValueError, ProfilerFileNotFoundException) as err:
+            logger.warning("MSAdvisor running failed. %s", err)
+        finally:
+            pass
+        if context.get_context("mode") == context.PYNATIVE_MODE:
+            logger.warning("Pynative mode does not support MSAdvisor analyzer currently.")
+
     def _ascend_graph_op_analyse(self, source_path):
         """
         Ascend graph model hwts analyse.
@@ -828,29 +881,37 @@ class Profiler:
         logger.info("Profiling: analyzing the data preprocess data.")
         aicpu_data_parser.execute()
 
+        # analyse op compute time info
+        try:
+            self._analyser_op_info()
+        except ProfilerException as err:
+            logger.warning(err.message)
+        finally:
+            pass
         return [framework_parser, aicpu_data_parser, optime_parser, op_task_dict]
 
-    def _ascend_graph_minddata_analyse(self, source_path):
+    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
-        logger.info("Profiling: analyzing the minddata AICPU data.")
-        MinddataParser.execute(source_path, self._output_path, self._rank_id)
+        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:
-            pipeline_parser = MinddataPipelineParser(self._output_path, self._rank_id, self._output_path)
-            logger.info("Profiling: analyzing the minddata pipeline operator and queue.")
-            pipeline_parser.parse()
+            MinddataPipelineParser(self._output_path, store_id, self._output_path).parse()
         except ProfilerException as err:
             logger.warning(err.message)
         finally:
             pass
 
         # Analyze minddata information
+        logger.info("Profiling: analyzing the minddata information.")
         try:
-            md_analyzer = MinddataProfilingAnalyzer(self._output_path, self._rank_id, self._output_path)
-            logger.info("Profiling: analyzing the minddata information.")
-            md_analyzer.analyze()
+            MinddataProfilingAnalyzer(self._output_path, store_id, self._output_path).analyze()
         except ProfilerException as err:
             logger.warning(err.message)
         finally:
@@ -865,59 +926,18 @@ class Profiler:
 
         self._check_output_path(output_path=self._output_path)
         source_path = os.path.join(self._output_path, job_id)
-        framework_parser, aicpu_data_parser, optime_parser, op_task_dict = self._ascend_graph_op_analyse(source_path)
-        self._ascend_graph_minddata_analyse(source_path)
-
-        # analyse op compute time info
-        try:
-            logger.info("Profiling: analyzing the operation compute time.")
-            self._analyser_op_info()
-        except ProfilerException as err:
-            logger.warning(err.message)
-        finally:
-            pass
-
-        if self._dynamic_status and self._profile_communication:
-            raise RuntimeError("The profile_communication parameter cannot be set on the dynamic shape network.")
-        if self._dynamic_status and self._profile_memory:
-            raise RuntimeError("The profile_memory parameter cannot be set on the dynamic shape network.")
-        if self._dynamic_status:
-            logger.warning(
-                "[Profiler]Dynamic Shape network does not support collecting step trace performance data currently.")
-
-        # analyse step trace info
-        points = None
-        is_training_mode_flag = False
-
-        try:
-            if self._is_support_step_info_collect() and not self._dynamic_status:
-                points, is_training_mode_flag = self._analyse_step_trace(source_path, framework_parser)
-        except ProfilerException as err:
-            logger.warning(err.message)
-        finally:
-            pass
-
-        # analyse timeline info
-        try:
-            logger.info("Profiling: analyzing the timeline data.")
-            self._analyse_timeline(aicpu_data_parser, optime_parser, source_path)
-        except (ProfilerIOException, ProfilerFileNotFoundException, RuntimeError) as err:
-            logger.warning('Fail to write timeline data: %s', err)
-        finally:
-            pass
-
-        if self._dynamic_status:
-            dynamic_parser = DynamicFrameWorkParser(self._output_path, self._rank_id)
-            dynamic_parser.write_dynamic_shape_data()
-
-        # Get op FLOPs from aicore.data.x.slice.0 file, and compute FLOPS, write output_op_flops_x.txt
-        flops_parser = FlopsParser(source_path, self._output_path, op_task_dict, self._dev_id, self._rank_id,
-                                   is_training_mode_flag)
-        logger.info("Profiling: analyzing the operation FLOPs.")
-        flops_parser.execute()
-
-        self._ascend_graph_memory_analyse(points)
-        self._ascend_graph_hccl_analyse()
+        self._minddata_analyse(source_path)
+        if self._op_time:
+            framework_parser, aicpu_data_parser, optime_parser, op_task_dict = self._ascend_graph_op_analyse(
+                source_path)
+            points, is_training_mode_flag = self._ascend_step_trace_analyse(source_path, framework_parser)
+            self._ascend_timeline_analyse(aicpu_data_parser, optime_parser, source_path)
+            if self._dynamic_status:
+                self._ascend_dynamic_net_analyse()
+            self._ascend_flops_analyse(source_path, op_task_dict, is_training_mode_flag)
+            self._ascend_graph_memory_analyse(points)
+            self._ascend_graph_hccl_analyse()
+            self._ascend_graph_msadvisor_analyse(job_id)
 
     def _ascend_graph_start(self):
         """Ascend graph mode start profiling."""
@@ -940,27 +960,10 @@ class Profiler:
         else:
             logger.info("No need to stop profiler because profiler has been stopped.")
 
-        reduce_op_type = self._get_step_reduce_op_type()
-        timeline_generator = self._generate_timeline(reduce_op_type)
-
-        # parse minddata pipeline operator and queue for GPU
-        try:
-            pipeline_parser = MinddataPipelineParser(self._output_path, self._dev_id, self._output_path)
-            logger.info("Profiling: analyzing the minddata pipeline operator and queue for GPU.")
-            pipeline_parser.parse()
-        except ProfilerException as err:
-            logger.warning(err.message)
+        self._minddata_analyse(self._output_path)
 
-        # Analyze minddata information
         try:
-            md_analyzer = MinddataProfilingAnalyzer(self._output_path, self._dev_id, self._output_path)
-            logger.info("Profiling: analyzing the minddata information.")
-            md_analyzer.analyze()
-        except ProfilerException as err:
-            logger.warning(err.message)
-
-        try:
-            self._analyse_step_relation_info(timeline_generator)
+            self._analyse_step_relation_info()
         except ProfilerException as err:
             logger.warning(err.message)
         finally:
@@ -985,8 +988,12 @@ class Profiler:
                 "scenarios currently.")
         return analyse_step_trace
 
-    def _analyse_step_relation_info(self, timeline_generator):
+    def _analyse_step_relation_info(self):
         """Parse iteration related information."""
+        if not self._op_time:
+            return
+        reduce_op_type = self._get_step_reduce_op_type()
+        timeline_generator = self._generate_timeline(reduce_op_type)
         parser = GpuFrameWorkParser(self._output_path, self._dev_id)
         graph_ids = parser.get_graph_ids()
         ProfilerInfo.set_graph_ids(graph_ids)
@@ -1091,6 +1098,7 @@ class Profiler:
             optime_parser (OPComputeTimeParserParser): The parser instance for AI Core
                 operator execution time calculation.
         """
+        logger.info("Profiling: analyzing the timeline data.")
         timeline_analyser = AscendTimelineGenerator(self._output_path, self._dev_id, self._rank_id,
                                                     self._rank_size, context.get_context("mode"))
         # Get framework info
@@ -1171,13 +1179,13 @@ class Profiler:
             else:
                 job_dir = os.path.join(self._output_path, dir_name)
 
-            host_start_file_path = get_file_path(job_dir, "host_start.log")
-            if host_start_file_path is None:
+            start_file_path = get_file_path(job_dir, "start_info")
+            if start_file_path is None:
                 logger.warning("Find profiling job path %s, but host_start.log not exist, "
                                "profiler will ignore this job dir.", job_dir)
                 continue
 
-            training_device_id = host_start_file_path.split('.')[-1]
+            training_device_id = start_file_path.split('.')[-1]
             if self._dev_id != training_device_id:
                 logger.debug("Find profiling find job path %s, but not current training device id. "
                              "Current training device id %s, but job path device id: %s, "
@@ -1187,7 +1195,7 @@ class Profiler:
             if not os.listdir(os.path.join(job_dir, 'data')):
                 continue
 
-            job_start_time = self._parse_host_start_log(host_start_file_path)
+            job_start_time = self._parse_start_log(start_file_path)
             if not job_start_time:
                 logger.warning("Find profiling job path %s, but fail to get job start info, "
                                "profiler will ignore this job dir.", job_start_time)
@@ -1216,6 +1224,7 @@ class Profiler:
 
     def _analyser_op_info(self):
         """Analyse the operator information."""
+        logger.info("Profiling: analyzing the operation compute time.")
         integrator = Integrator(self._output_path, self._rank_id)
         integrator.integrate()
 
@@ -1335,15 +1344,38 @@ class Profiler:
 
     def _parser_kwargs(self, kwargs):
         """Parse kwargs vale."""
+        self._op_time = kwargs.get("op_time", True)
+
+        env_run_config = json.loads(os.getenv("MS_PROFILER_RUN_CONFIG", "{}"))
+        params = list(kwargs.keys())
+        if not env_run_config.get("start"):
+            for param in params:
+                if param not in DeviceSupportParam.__getattr__(f'{self._device_target}'.upper()).value:
+                    logger.warning("%s is an invalid param which doesn't work.", param)
+                    kwargs.pop(param)
+                elif not self._op_time and param not in ALWAYS_VALID_PARAM:
+                    logger.warning(f"When op_time is set to False, the parameter '{param}' setting is invalid.")
+
+        if not isinstance(self._op_time, bool):
+            logger.warning(f"For '{self.__class__.__name__}', the parameter op_time must be bool, "
+                           f"but got type {type(self._op_time)}, it will be set to True.")
+            self._op_time = True
+
         self._data_process = kwargs.pop("data_process", True)
         if not isinstance(self._data_process, bool):
-            raise TypeError(f"For '{self.__class__.__name__}', the parameter data_process must be bool, "
-                            f"but got type {type(self._data_process)}")
+            logger.warning(f"For '{self.__class__.__name__}', the parameter data_process must be bool, "
+                           f"but got type {type(self._data_process)}, it will be set to True.")
+            self._data_process = True
 
         timeline_limit = kwargs.pop("timeline_limit", 500)
-        if not isinstance(timeline_limit, int):
-            raise TypeError(f"For '{self.__class__.__name__}', the parameter timeline_limit must be int, "
-                            f"but got type {type(timeline_limit)}")
+        if isinstance(timeline_limit, bool) or not isinstance(timeline_limit, int):
+            logger.warning(f"For '{self.__class__.__name__}', the parameter timeline_limit must be int, "
+                           f"but got type {type(timeline_limit)}, it will be set to 500.")
+            timeline_limit = 500
+        if timeline_limit <= 0:
+            logger.warning(
+                "[Profiler]The 'timeline_limit' parameter must be greater than 0, it will be set to 500.")
+            timeline_limit = 500
         self._timeline_size_limit_byte = timeline_limit * 1024 * 1024
 
     def _analyse_hccl_info(self):