mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/profiler/profiling.py

@@ -17,12 +17,13 @@ import os
 import stat
 import time
 import json
+from json import JSONDecodeError
 import glob
-import subprocess
-import csv
 import socket
-import shutil
+import multiprocessing
 from enum import Enum
+from typing import List
+from sys import getsizeof
 import numpy as np
 
 from mindspore import log as logger, context
@@ -30,34 +31,42 @@ 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
+    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
+from mindspore.profiler.common.util import get_file_path, ProfilerPathManager
+from mindspore.profiler.common.process_pool import MultiProcessPool
 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
+from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent
 from mindspore.profiler.parser.cpu_gpu_timeline_generator import GpuTimelineGenerator, CpuTimelineGenerator
 from mindspore.profiler.parser.ascend_timeline_generator import AscendTimelineGenerator
-from mindspore.profiler.parser.memory_usage_parser import MemoryUsageParser
 from mindspore.profiler.parser.minddata_parser import MinddataParser
 from mindspore.profiler.parser.minddata_analyzer import MinddataProfilingAnalyzer
 from mindspore.profiler.parser.minddata_pipeline_parser import \
     MinddataPipelineParser
-from mindspore.profiler.parser.step_trace_parser import GpuStepTraceParser, AscendStepTraceParser
-from mindspore.profiler.parser.msadvisor_analyzer import Msadvisor
+from mindspore.profiler.parser.step_trace_parser import GpuStepTraceParser
 from mindspore.profiler.parser.profiler_info import ProfilerInfo
 from mindspore.common.api import _pynative_executor
 from mindspore.profiler.parser.ascend_msprof_exporter import AscendMsprofExporter
-from mindspore.profiler.parser.ascend_msprof_generator import AscendMsprofDataGenerator, AscendMsprofDataGeneratorOld
+from mindspore.profiler.parser.ascend_msprof_generator import AscendMsprofDataGenerator
 from mindspore.profiler.parser.ascend_fpbp_generator import AscendFPBPGenerator
 from mindspore.profiler.parser.ascend_op_generator import AscendOPGenerator
 from mindspore.profiler.parser.ascend_steptrace_generator import AscendStepTraceGenerator
 from mindspore.profiler.parser.ascend_flops_generator import AscendFlopsGenerator
 from mindspore.profiler.parser.ascend_cluster_generator import AscendClusterGenerator
-from mindspore.profiler.parser.ascend_hccl_generator import AscendHCCLGenerator, AscendHCCLGeneratorOld
+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
+from mindspore.profiler.parser.ascend_analysis.file_manager import FileManager
+from mindspore.profiler.parser.ascend_analysis.path_manager import PathManager
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.common.util import timeit
+
 
 INIT_OP_NAME = 'Default/InitDataSetQueue'
 
@@ -68,10 +77,24 @@ AICORE_METRICS_DICT = {
     3: "MemoryL0",
     4: "ResourceConflictRatio",
     5: "MemoryUB",
+    6: "L2Cache",
     -1: "None"
 }
 
 
+class ModelTraingMode(Enum):
+    PYNATIVE = 0
+    GRAPH = 1
+    KERNEL_BY_KERNEL = 2
+    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']
@@ -81,16 +104,20 @@ class DeviceSupportParam(Enum):
     ]
     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',
-        'profile_framework'
+        'parallel_strategy', 'profile_communication', 'aicore_metrics', 'l2_cache', 'hbm_ddr', 'pcie', 'op_time',
+        'ascend_job_id', 'profile_framework', 'with_stack', 'profiler_level', 'data_simplification'
     ]
 
 
 ALWAYS_VALID_PARAM = [
     'start', 'start_profile', 'output_path', 'data_process', 'parallel_strategy', 'l2_cache',
-    'ascend_job_id', 'op_time', 'profile_framework'
+    'hbm_ddr', 'pcie', 'ascend_job_id', 'op_time', 'profile_framework', 'profiler_level'
 ]
 
+ANALYSIS_ASYNC_MODE = 'async'
+ANALYSIS_SYNC_MODE = 'sync'
+DEFAULT_MODEL_ID = 4294967295
+
 
 def _environment_check():
     if c_expression.security.enable_security():
@@ -136,182 +163,36 @@ def _calculate_dataset_item(row, execution_time_map, ts_map):
         logger.warning("Can not map the start time for item: %s.", row)
 
 
-def _calculate_dataset_execution_time(input_file, output_file):
-    r"""
-    Parse the host info into timeline file, so as to show on UI.
-
-    Args:
-        input_file: the original host_info file, in csv format.
-        output_file: the output file, in csv format.
-    """
-    input_file = validate_and_normalize_path(input_file)
-    # execution_time_map is used to store the ExecutionCalculator for each stage.
-    execution_time_map = {}
-    # ts_map is used to store the start time of each event_stage_tid_pid.
-    ts_map = {}
-    with open(input_file, 'r') as f:
-        for row in csv.DictReader(f):
-            try:
-                module_name = row['module_name']
-                if module_name != 'Dataset':
-                    continue
-                _calculate_dataset_item(row, execution_time_map, ts_map)
-            except KeyError as e:
-                logger.error("Error occur when analyse line: %s, Details is: %s", row, e)
-                continue
-    if ts_map:
-        logger.warning("Only start time is record for these items:")
-        for k, v in ts_map.items():
-            logger.warning("event_stage_tid_pid: %s, time: %d us.", k, v)
-    output_file = validate_and_normalize_path(output_file)
-    flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
-    modes = stat.S_IWUSR | stat.S_IRUSR
-    with os.fdopen(os.open(output_file, flags, modes), 'w') as f:
-        csv_writer = csv.writer(f)
-        csv_writer.writerow(['Operation', 'Stage', 'Occurrences', 'Avg. time (us)', 'Custom Info'])
-        for _, v in execution_time_map.items():
-            csv_writer.writerow([v.event, v.stage, v.count, v.average_execution, v.custom_info])
-    os.chmod(output_file, modes)
-    logger.info('Successfully calculate the execution time and write it to file: %s.', output_file)
-
-
-def _extract_timeline_item(row, time_line, ts_map):
-    """Process one row, try to extract a timeline item."""
-    start_end = row['start_end']
-    event_stage_tid_pid = row['event'] + '_' + row['stage'] + '_' + row['tid'] + '_' + row['pid']
-    # map start and end, put the mapped event into timeline.
-    if start_end == '1' and event_stage_tid_pid in ts_map:
-        title = row['event'] + '::' + row['stage']
-        event = {'name': title, 'cat': row['module_name']}
-        ts_end = int(row['time_stamp(us)'])
-        ts = ts_map[event_stage_tid_pid]
-        event['ts'] = ts
-        event['dur'] = ts_end - ts
-        event['ph'] = 'X'
-        event['pid'] = row['pid']
-        event['tid'] = row['tid']
-        event['args'] = {'parent_pid': row['parent_pid']}
-        time_line.append(event)
-        del ts_map[event_stage_tid_pid]
-    elif start_end == '0':
-        ts = int(row['time_stamp(us)'])
-        ts_map[event_stage_tid_pid] = ts
-    # Put the instance event into timeline.
-    elif start_end == '2':
-        title = row['event'] + '::' + row['stage']
-        event = {
-            'name': title, 'cat': row['module_name'], 'ts': int(row['time_stamp(us)']), 'ph': 'i',
-            'pid': row['pid'], 'tid': row['tid'], 'args': {'parent_pid': row['parent_pid']}
-        }
-        time_line.append(event)
-    else:
-        logger.warning("Can not map the start time for item: %s.", row)
-
-
-def _parse_host_info(input_file, output_timeline_file, output_memory_file, is_develop_user=True):
-    r"""
-    Parse the host info into timeline file, so as to show on UI.
-
-    Args:
-        input_file: the original host_info file, in csv format.
-        output_timeline_file: the output timeline file, in json format.
-        output_memory_file: the output memory_usage file, in csv format.
-        is_develop_user: some data only shown to develop users, other users no need to analyse it.
-    """
-    input_file = validate_and_normalize_path(input_file)
-    time_line = []
-    # ts_map is used to store the start time of each event_stage_tid_pid
-    ts_map = {}
-    memory_header = [
-        'tid', 'pid', 'parent_pid', 'module_name', 'event', 'stage', 'level', 'start_end', 'custom_info',
-        'memory_usage(kB)', 'time_stamp(us)'
-    ]
-    memory_info = []
-    with open(input_file, 'r') as f:
-        for row in csv.DictReader(f):
-            try:
-                level = row['level']
-                if level == '0' and not is_develop_user:
-                    continue
-                if int(row['time_stamp(us)']) > 0:
-                    _extract_timeline_item(row, time_line, ts_map)
-                if int(row['memory_usage(kB)']) > 0:
-                    memory_info.append(row)
-            except KeyError as e:
-                logger.error("Error occur when analyse line: %s, Details is: %s", row, e)
-                continue
-    if memory_info:
-        with os.fdopen(os.open(output_memory_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as csv_file:
-            csv_writer = csv.DictWriter(csv_file, fieldnames=memory_header)
-            csv_writer.writeheader()
-            for item in memory_info:
-                csv_writer.writerow(item)
-        os.chmod(output_memory_file, stat.S_IREAD | stat.S_IWRITE)
-    else:
-        logger.warning("No memory_usage is record in file: %s", input_file)
-
-    if ts_map:
-        logger.warning("Only start time is record for these items:")
-        for k, v in ts_map.items():
-            logger.warning("event_stage_tid_pid: %s, time: %d us.", k, v)
-            last_dash = k.rfind('_')
-            if last_dash == -1:
-                logger.error("Can't find pid in the event_stage_tid_pid string: %s", k)
-                continue
-            second_last_dash = k.rfind('_', 0, last_dash - 1)
-            if second_last_dash == -1:
-                logger.error("Can't find tid in the event_stage_tid_pid string: %s", k)
-                continue
-            pid = k[last_dash + 1:]
-            tid = k[second_last_dash + 1: last_dash]
-            title = k[:second_last_dash]
-            unfinished_timeline = {'name': title, 'pid': pid, 'tid': tid, 'ph': 'B', 'ts': int(v)}
-            time_line.append(unfinished_timeline)
-
-    if time_line:
-        timeline_file = validate_and_normalize_path(output_timeline_file)
-        with os.fdopen(os.open(timeline_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as json_file:
-            json.dump(time_line, json_file)
-        os.chmod(timeline_file, stat.S_IREAD | stat.S_IWRITE)
-    else:
-        logger.warning("No valid time_stamp is record in file: %s", input_file)
-
-
-def _ascend_graph_msprof_generator(source_path, model_iteration_dict):
+def _ascend_graph_msprof_generator(mindstudio_profiler_output, model_iteration_dict):
     """Executing the msprof export mode."""
     try:
         ProfilerInfo.set_export_start_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
-        msprof_exporter = AscendMsprofExporter(source_path)
+        msprof_exporter = AscendMsprofExporter(mindstudio_profiler_output)
         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 as err:
-        logger.warning(err.message)
+    except (ProfilerException, TimeoutError, FileNotFoundError, RuntimeError) as err:
+        logger.warning(str(err))
         return False
 
 
-def _ascend_graph_msprof_analyse(source_path, flag):
+def _ascend_graph_msprof_analyse(mindstudio_profiler_output):
     """
     Ascend graph model msprof data analyse.
 
     Returns:
-        list[obj]: The list is : df_op_summary, df_op_statistic, df_step_trace
+        list[obj]: The list is : df_op_summary, df_op_statistic, df_step_trace, df_step_trace_model
     """
-    df_op_summary = []
-    df_op_statistic = []
-    df_step_trace = []
+    res = ([], [], [], [])
     try:
-        if flag:
-            msprof_analyser = AscendMsprofDataGenerator(os.path.join(source_path, 'summary'))
-        else:
-            msprof_analyser = AscendMsprofDataGeneratorOld(os.path.join(source_path, 'summary'))
-        df_op_summary, df_op_statistic, df_step_trace = msprof_analyser.parse()
+        msprof_analyser = AscendMsprofDataGenerator(mindstudio_profiler_output)
+        res = msprof_analyser.parse()
+        return res
     except ProfilerException as err:
         logger.warning(err.message)
     finally:
         pass
-    return df_op_summary, df_op_statistic, df_step_trace
+    return res
 
 
 class Profiler:
@@ -320,24 +201,33 @@ class Profiler:
     MindSpore users can import the mindspore.Profiler, initialize the Profiler object to start profiling,
     and use Profiler.analyse() to stop profiling and analyse the results.
     Users can visualize the results using the `MindSpore Insight
-    <https://www.mindspore.cn/mindinsight/docs/en/r2.2/index.html>`_ tool.
+    <https://www.mindspore.cn/mindinsight/docs/en/master/index.html>`_ tool.
     Now, Profiler supports AICORE operator, AICPU operator, HostCPU operator, memory,
     correspondence, cluster, etc data analysis.
 
     Args:
         output_path (str, optional): Output data path. Default: ``"./data"`` .
+        profiler_level (ProfilerLevel, optional): (Ascend only) The level of profiling. Default: ``None``.
+
+            - ProfilerLevel.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.
+            - ProfilerLevel.Level1: Collect more CANN layer AscendCL data and AICore performance metrics and
+              communication mini operator information based on Level0.
+            - ProfilerLevel.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 device
+            a multi devices training,collect when True. Setting this parameter has no effect during single card
             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`` .
-            When using this parameter, `op_time` must be set to True. Default: ``False`` .
+            When using this parameter, `op_time` must be set to True. Collecting operator memory data when the graph
+            compilation level is O2 requires collecting from the first step. Default: ``False`` .
         parallel_strategy (bool, optional): (Ascend only) Whether to collect parallel policy performance data.
-            Default value: ``True`` .
+            Default value: ``False`` .
         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],
+            parameter, `op_time` must be set to ``True`` , and the value must be in [-1, 0, 1, 2, 3, 4, 5, 6],
             Default: ``0`` , the data items contained in each metric are as follows:
 
             - -1: Does not collect AICORE data.
@@ -348,9 +238,15 @@ class Profiler:
             - 3: MemoryL0 contains l0a_read/write_bw, l0b_read/write_bw, l0c_read/write_bw etc.
             - 4: ResourceConflictRatio contains vec_bankgroup/bank/resc_cflt_ratio etc.
             - 5: MemoryUB contains ub_read/write_bw_mte, ub_read/write_bw_vector, ub\_/write_bw_scalar etc.
+            - 6: L2Cache contains write_cache_hit, write_cache_miss_allocate, r0_read_cache_hit, r1_read_cache_hit etc.
+              This function only support Atlas A2 training series products.
 
         l2_cache (bool, optional): (Ascend only) Whether to collect l2 cache data, collect when True.
             Default: ``False`` .
+        hbm_ddr (bool, optional): (Ascend only) Whether to collect On-Chip Memory/DDR read and write rate data,
+            collect when True. Default: ``False`` .
+        pcie (bool, optional): (Ascend only) Whether to collect PCIe bandwidth data, collect when True.
+            Default: ``False`` .
         sync_enable (bool, optional): (GPU only) Whether the profiler collects operators in a synchronous way.
             Default: ``True`` .
 
@@ -360,19 +256,32 @@ class Profiler:
             - 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 overall training time.
         data_process (bool, optional): (Ascend/GPU) Whether to collect data to prepare performance data.
-            Default value: ``True`` .
+            Default value: ``False`` .
         timeline_limit (int, optional): (Ascend/GPU) 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`` .
         profile_framework (str, optional): (Ascend/GPU) The host information to collect, it must be one of
-            ["all", "time", "memory", None], When is not set to None, a subdirectory host_info will be generated in the
-            specified profiler directory, which stores the collected memory and time files on the Host side.
-            Default: "all".
+            ["all", "time", None], When is not set to None, it would collect the host profiler data. When using this
+            parameter, the op_time parameter must be enabled.
+            Default: None.
 
-            - "all": Record both host timestamp and host memory usage.
-            - "time": Only record host timestamp.
-            - "memory": Only record host memory usage.
+            - "all": Record host timestamp.
+            - "time": The same as "all".
             - 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`` .
+        with_stack (bool, optional): (Ascend) Whether to collect frame host call stack data on the Python side. This
+            data is presented in the form of a flame graph in the timeline. When using this parameter, the op_time and
+            profile_framework parameters must be enabled. Default value: ``False`` .
+        analyse_only (bool, optional): (Ascend/GPU) Whether to parse only performance data and not collect performance
+            data. This parameter is experimental parameter and does not need to be set by the user.
+            Default value: ``False`` .
+        rank_id (int, optional): (Ascend/GPU) Set the rank id during parsing. This parameter is
+            experimental parameter and does not need to be set by the user. Default value: ``0`` .
+        env_enable (bool, optional): (Ascend/GPU) Whether to enable the collection of environment variables.
+            This parameter is experimental parameter and does not need to be set by the user.
+            Default value: ``False`` .
     Raises:
         RuntimeError: When the version of CANN does not match the version of MindSpore,
             MindSpore cannot parse the generated ascend_job_id directory structure.
@@ -386,6 +295,7 @@ class Profiler:
         >>> from mindspore import nn
         >>> import mindspore.dataset as ds
         >>> from mindspore import Profiler
+        >>> from mindspore.profiler import ProfilerLevel
         >>>
         >>> class Net(nn.Cell):
         ...     def __init__(self):
@@ -411,7 +321,7 @@ class Profiler:
         ...
         ...     # Init Profiler
         ...     # Note that the Profiler should be initialized before model.train
-        ...     profiler = Profiler()
+        ...     profiler = Profiler(profiler_level=ProfilerLevel.Level0)
         ...
         ...     # Train Model
         ...     net = Net()
@@ -420,16 +330,16 @@ class Profiler:
         ...     # Profiler end
         ...     profiler.analyse()
     """
-
-    _hwts_output_filename_target = "output_format_data_hwts_"
-    _opcompute_output_filename_target = "output_op_compute_time_"
-    _aicpu_op_output_filename_target = "output_data_preprocess_aicpu_"
-    _has_analysed = False
     _has_initialized = False
     _ascend_profiling_options = ""
     _ascend_job_id = ""
+    ENABLE_STATUS = "on"
+    DISABLE_STATUS = "off"
 
     def __init__(self, **kwargs):
+        if os.getenv("PROFILING_MODE"):
+            raise RuntimeError("Profiling is already enabled by PROFILING_MODE env.")
+
         self._dev_id = None
         self._cpu_profiler = None
         self._gpu_profiler = None
@@ -445,13 +355,19 @@ class Profiler:
         self._rank_size = 1
         self._rank_id = 0
         self._ascend_profiler = None
+        self.metadata = {}
+        self.max_str_len = 4096
+        self.max_meta_size = 50 * 1024
         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
-        self._l2_cache = "off"
+        self._l2_cache = self.DISABLE_STATUS
+        self._hbm_ddr = self.DISABLE_STATUS
+        self._pcie = self.DISABLE_STATUS
         self._data_process = True
         self._op_time = True
         self._profile_communication = False
@@ -462,25 +378,33 @@ class Profiler:
         self._sync_enable = True
         self._stop_time = 0
         self._dynamic_status = False
-        self._profile_framework = "all"
+        self._profile_framework = None
         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._with_stack = False
         if self._msprof_enable:
             return
-        self._start_time = int(time.time() * 1000000)
+        self._start_time = int(time.time() * 1e6)  # us
+        self._monotonic_time = int(time.monotonic() * 1e6)  # us
         logger.info("Profiling: start time: %d", self._start_time)
         if kwargs.get("env_enable"):
             self._profiler_init(kwargs)
             return
-
         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()
+        if self._analyse_only:
+            self._device_target = DeviceTarget.ASCEND.value
+            self._rank_id = kwargs.get("rank_id", 0)
+        else:
+            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()
 
     @staticmethod
     def _check_output_path(output_path):
@@ -496,9 +420,9 @@ class Profiler:
         return output_path
 
     @staticmethod
-    def _parse_start_log(input_file):
+    def _parse_job_start_time(prof_dir):
         """
-        Parse host start log file, get the start time of the job.
+        Get the start time of the job.
 
         Args:
              input_file (str): The file path of the host start log file.
@@ -506,34 +430,83 @@ class Profiler:
         Returns:
             str, job start time.
         """
-
-        job_start_time = 0
-        with open(input_file) as f:
-            job_start_time = json.load(f).get("collectionTimeBegin")
-
-        return job_start_time
-
-    @staticmethod
-    def _parse_info_json(info_file):
+        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')
+                return None
+            result = json.loads(outs)
+            if result.get('status', 1) == 1:
+                return None
+            jor_start_time = result.get('data', {}).get('collection_info', {}).get('Collection start time', None)
+            if jor_start_time is not None:
+                return float(jor_start_time.strip())
+            return None
+        except (RuntimeError, JSONDecodeError, AttributeError, TimeoutError, FileNotFoundError) as err:
+            logger.warning('Get the drvVersion error, use single-export mode instead. detail : %s', err)
+            return None
+
+    @classmethod
+    def offline_analyse(cls, path: str, pretty=False, step_list=None, data_simplification=True):
         """
-        Parse info log file, get the rank id and device id of the job.
+        Analyze training performance data offline, which is invoked after performance data collection is completed.
+
         Args:
-             input_file (str): The file path of the parse info log file.
+            path (str): The profiling data path which need to be analyzed offline.
+                There needs to be a profiler directory in this path.
+            pretty (bool, optional): Whether to pretty json files. Default: ``False``.
+            step_list (list, optional): A list of steps that need to be analyzed, the steps must be
+                consecutive integers. Default: ``None``. By default, all steps will be analyzed.
+            data_simplification (bool, optional): Whether to enable data simplification. Default: ``True``.
 
-        Returns:
-            rank id, device id
+        Examples:
+            >>> from mindspore import Profiler
+            >>> Profiler.offline_analyse("./profiling_path")
         """
-        with open(info_file, "r") as f:
-            info_dict = json.load(f)
-
-            rank_id = info_dict.get("rank_id", 0)
-            dev_info = info_dict.get("DeviceInfo", [])
-            dev_id = dev_info[0].get("id", -1)
-
+        real_path = os.path.realpath(path)
+        PathManager.check_input_directory_path(real_path)
+        profiler_parent_path_list = PathManager.get_profiler_parent_path_list(real_path)
+        if not isinstance(data_simplification, bool):
+            logger.warning(f"For offline_analyse, the parameter data_simplification must be bool, "
+                           f"but got type {type(data_simplification)}, it will be set to True.")
+            data_simplification = True
+        if not profiler_parent_path_list:
+            raise ProfilerPathErrorException(f'The provided path "{path}" must have a "profiler" directory for '
+                                             f'single-device profiler data, or multiple subdirectories each containing '
+                                             f'a "profiler" directory for multi-device profiler data. ')
+        # get rank id
+        rank_list = []
+        for parent_path in profiler_parent_path_list:
+            profiler_path = os.path.join(parent_path, Constant.PROFILER_DIR)
+            rank_id = ProfilerInfo.get_rank_id(profiler_path)
             if int(rank_id) < 0:
-                rank_id = 0
-
-            return str(rank_id), str(dev_id)
+                logger.error(f"Unable to get a valid rank ID in the profiler directory: {profiler_path}")
+            rank_list.append(rank_id)
+        # start offline analyse
+        if len(profiler_parent_path_list) == 1:
+            PathManager.check_directory_path_writeable(profiler_parent_path_list[0])
+            profiler = cls(analyse_only=True, rank_id=rank_list[0], data_simplification=data_simplification)
+            profiler.analyse(profiler_parent_path_list[0], pretty, step_list)
+        else:
+            # Multiprocess Parsing
+            multiprocessing.set_start_method("fork", force=True)
+            process_number = min(Constant.DEFAULT_PROCESS_NUMBER, len(profiler_parent_path_list))
+            pool = multiprocessing.Pool(processes=process_number)
+            for idx, profiler_parent_path in enumerate(profiler_parent_path_list):
+                PathManager.check_directory_path_writeable(profiler_parent_path)
+                profiling_parser = cls(analyse_only=True, rank_id=rank_list[idx],
+                                       data_simplification=data_simplification)
+                pool.apply_async(profiling_parser.analyse, args=(profiler_parent_path, pretty, step_list))
+            pool.close()
+            pool.join()
 
     def op_analyse(self, op_name, device_id=None):
         """
@@ -560,12 +533,12 @@ class Profiler:
             >>> # Profiler init.
             >>> profiler = Profiler()
             >>> # Train Model or eval Model, taking LeNet5 as an example.
-            >>> # Refer to https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> # Refer to https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
             >>> net = LeNet5()
             >>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
             >>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
             >>> # Create the dataset taking MNIST as an example.
-            >>> # Refer to https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
+            >>> # Refer to https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/mnist.py
             >>> dataloader = create_dataset()
             >>> model = Model(net, loss, optimizer)
             >>> model.train(5, dataloader, dataset_sink_mode=False)
@@ -600,20 +573,73 @@ class Profiler:
                 return message
         return op_info
 
-    def analyse(self, offline_path=None, pretty=False):
+    def analyse(self, offline_path=None, pretty=False, step_list=None, mode="sync"):
         """
         Collect and analyze training performance data, support calls during and after training. The example shows above.
 
         Args:
-            offline_path (Union[str, None], optional): The data path which need to be analysed with offline mode.
+            offline_path (Union[str, None], optional): The data path which need to be analyzed with offline mode.
                 Offline mode isused in abnormal exit scenario. This parameter should be set to ``None``
                 for online mode. Default: ``None``.
             pretty (bool, optional): Whether to pretty json files. Default: ``False``.
-        """
-        self._pretty_json = pretty
-        self._analyse(offline_path=offline_path)
+            step_list (list, optional): A list of steps that need to be analyzed, the steps must be
+                consecutive integers. Default: ``None``. By default, all steps will be analyzed.
+            mode (str, optional): Analysis mode, it must be one of ["sync", "async"]. Default: ``sync``.
 
-    def _analyse(self, offline_path=None, model_iteration_dict=None):
+                - sync: analyse data in current process, it will block the current process.
+                - async: analyse data in subprocess, it will not block the current process. Since the parsing process
+                  will take up extra CPU resources, please enable this mode according to the actual resource situation.
+
+        Examples:
+            >>> from mindspore.train import Callback
+            >>> from mindspore import Profiler
+            >>> class StopAtStep(Callback):
+            ...     def __init__(self, start_step=1, stop_step=5):
+            ...         super(StopAtStep, self).__init__()
+            ...         self.start_step = start_step
+            ...         self.stop_step = stop_step
+            ...         self.profiler = Profiler(start_profile=False)
+            ...
+            ...     def step_begin(self, run_context):
+            ...         cb_params = run_context.original_args()
+            ...         step_num = cb_params.cur_step_num
+            ...         if step_num == self.start_step:
+            ...             self.profiler.start()
+            ...
+            ...     def step_end(self, run_context):
+            ...         cb_params = run_context.original_args()
+            ...         step_num = cb_params.cur_step_num
+            ...         if step_num == self.stop_step:
+            ...             self.profiler.stop()
+            ...
+            ...     def end(self, run_context):
+            ...         self.profiler.analyse(step_list=[2,3,4], mode="sync")
+        """
+        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):
         """
         Collect and analyze training performance data, support calls during and after training. The example shows above.
 
@@ -622,24 +648,24 @@ 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_rank_size(self._rank_size)
-        ProfilerInfo.set_heterogeneous(self._is_heterogeneous)
         if offline_path:
-            if self._is_offline_parser():
-                ProfilerInfo.set_analyse_start_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
-                self._ascend_graph_analyse()
-                ProfilerInfo.set_analyse_end_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
-                ProfilerInfo.save(self._output_path)
-            _offline_parse(offline_path)
+            # Loads the ProfilerInfo data, avoid overwriting the data collection prof_info_x.json.
+            ProfilerInfo.load_profiler_info_dict(os.path.join(offline_path, "profiler"))
+            ProfilerInfo.set_analyse_start_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+            self._ascend_graph_analyse(offline_path=offline_path)
+            ProfilerInfo.set_analyse_end_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+            ProfilerInfo.save(self._output_path)
             return
         if self._msprof_enable:
             return
@@ -654,21 +680,21 @@ 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()
+            if self._profile_framework:
+                logger.warning("The parameter 'profile_framework' is not support for CPU, so there no host profiler "
+                               "data.")
 
         if self._device_target and self._device_target == DeviceTarget.GPU.value:
             self._gpu_analyse()
 
         elif self._device_target and self._device_target == DeviceTarget.ASCEND.value:
             self._ascend_analyse()
-        if self._profile_framework:
-            if self._device_target != DeviceTarget.CPU.value:
-                self._host_info_analyse()
-            else:
-                logger.warning("The parameter 'profile_framework' is not support for CPU, so there no host_info"
-                               " directory in the output path.")
+
         logger.info("Profiling: all the data have been analyzed.")
         ProfilerInfo.set_analyse_end_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
         ProfilerInfo.save(self._output_path)
@@ -715,13 +741,11 @@ class Profiler:
         else:
             raise RuntimeError("The profiler has already started. Do not turn on again in the open state.")
 
-        # No need to start anything if parse profiling data offline
-        if self._is_offline_parser():
-            return
-
         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:
@@ -736,6 +760,14 @@ 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())) # ns
+        if context.get_context("mode") == context.GRAPH_MODE:
+            jit_config = context.get_jit_config()
+            jit_level = jit_config.get("jit_level", "")
+            ProfilerInfo.set_jit_level(jit_level)
+        if self._profile_framework:
+            _framework_profiler_enable_mi()
 
     def stop(self):
         """
@@ -778,10 +810,6 @@ class Profiler:
             raise RuntimeError("The profiler has not started, so can not stop. Please call the start() method "
                                "before calling the stop() method.")
 
-        # 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()
 
@@ -798,9 +826,101 @@ class Profiler:
             self._stop_time = int(time.time() * 10000000)
         ProfilerInfo.set_profiling_stop_time(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
         self._init_profiler_info()
+        ProfilerInfo.set_diff_time(self._start_time - self._monotonic_time)
         ProfilerInfo.save(self._output_path)
+        self._dump_metadata()
         logger.info("Profiling: stop time: %d", self._stop_time)
 
+    def add_metadata(self, key: str, value: str):
+        """
+        Report custom metadata key-value pair data.
+
+        Args:
+            key (str): The key to the metadata.
+            value (str): The value to the metadata.
+
+        Examples:
+            >>> from mindspore import Profiler
+            >>> # Profiler init.
+            >>> profiler = Profiler()
+            >>> # Call Profiler add_metadata
+            >>> profiler.add_metadata("test_key", "test_value")
+            >>> # Profiler end
+            >>> profiler.analyse()
+        """
+        if not isinstance(key, str) or not isinstance(value, str):
+            logger.warning("The key and value of metadata must be string. Skip this metadata.")
+            return
+        if not self._check_str_valid(key) or not self._check_str_valid(value):
+            logger.warning("Invalid input key or value. Skip this metadata.")
+            return
+        add_size = getsizeof(key) + getsizeof(value)
+        if getsizeof(self.metadata) + add_size < self.max_meta_size:
+            if key in self.metadata:
+                logger.warning(f"{key} is already saved as metadata, override it.")
+            self.metadata[key] = value
+        else:
+            logger.warning("Too many metadata added. Skip this metadata")
+
+    def add_metadata_json(self, key: str, value: str):
+        """
+        Report custom metadata key-value pair data with the value as a JSON string data.
+
+        Args:
+            key (str): The key to the metadata.
+            value (str): The json str format value to the metadata.
+
+        Examples:
+            >>> import json
+            >>> from mindspore import Profiler
+            >>> # Profiler init.
+            >>> profiler = Profiler()
+            >>> # Call Profiler add_metadata_json
+            >>> profiler.add_metadata_json("test_key", json.dumps({"key1": 1, "key2": 2}))
+            >>> # Profiler end, metadata will be saved in profiler_metadata.json
+            >>> profiler.analyse()
+        """
+        if not isinstance(key, str) or not isinstance(value, str):
+            logger.warning("The key and value of metadata must be string. Skip this metadata.")
+            return
+        if not self._check_str_valid(key) or not self._check_str_valid(value):
+            logger.warning("Invalid input key or value. Skip this metadata.")
+            return
+        add_size = getsizeof(key) + getsizeof(value)
+        if getsizeof(self.metadata) + add_size < self.max_meta_size:
+            try:
+                if key in self.metadata:
+                    logger.warning(f"{key} is already saved as metadata, override it.")
+                self.metadata[key] = json.loads(value)
+            except ValueError:
+                logger.warning("The metadata value must be json format string. Skip this metadata")
+        else:
+            logger.warning("Too many metadata added. Skip this metadata")
+
+    def _dump_metadata(self):
+        """Dump metadata to file."""
+        if not self.metadata:
+            return
+        FileManager.create_json_file(self._output_path, self.metadata, "profiler_metadata.json", indent=4)
+        self.metadata.clear()
+
+    def _check_str_valid(self, input_str: str):
+        """Check str length"""
+        if len(input_str) > self.max_str_len:
+            return False
+        return True
+
+    def _set_ascend_job_id(self, ascend_job_id):
+        """Set output_path for offline parsing performance data."""
+        if not ascend_job_id:
+            return
+        self._ascend_job_id = validate_and_normalize_path(ascend_job_id)
+        if not os.path.exists(self._ascend_job_id):
+            msg = f"Invalid ascend_job_id: {self._ascend_job_id}, Please pass the absolute path of the JOB dir"
+            logger.critical(msg)
+            raise ValueError(msg)
+        self._output_path, _ = os.path.split(self._ascend_job_id)
+
     def _profiler_init(self, kwargs):
         """Initialize variables when profiler is enabled by environment variables."""
         options = kwargs.get("env_enable")
@@ -814,7 +934,7 @@ class Profiler:
         self._profile_communication = options.get('profile_communication')
         self._op_time = options.get('op_time')
         self._device_target = context.get_context("device_target").lower()
-        self._profile_framework = options.get('profile_framework', 'all')
+        self._profile_framework = options.get('profile_framework', None)
         self._profiler_manager = c_expression.ProfilerManager.get_instance()
         self._cpu_profiler = c_expression.Profiler.get_instance("CPU")
         if self._data_process:
@@ -865,32 +985,32 @@ class Profiler:
 
     def _gpu_profiler_init(self, kwargs):
         """Gpu profiler init."""
+        self._parse_parameter_for_gpu(kwargs)
         # Setup and start MindData Profiling
         if self._data_process:
             self._md_profiler = cde.GlobalContext.profiling_manager()
             self._md_profiler.init()
-        self._parse_parameter_for_gpu(kwargs)
 
         gpu_profiler = c_expression.Profiler
         self._gpu_profiler = gpu_profiler.get_instance("GPU")
-        self._gpu_profiler.init(self._output_path)
-        self._gpu_profiler.sync_enable(self._sync_enable)
         if GlobalComm.WORLD_COMM_GROUP == "nccl_world_group":
             self._dev_id = str(get_rank())
         os.environ['DEVICE_ID'] = self._dev_id
         self._rank_id = self._dev_id
+        self._gpu_profiler.init(self._output_path, int(self._rank_id))
+        self._gpu_profiler.sync_enable(self._sync_enable)
 
     def _ascend_profiler_init(self, kwargs):
         """Ascend profiler init."""
+        self._parse_parameter_for_ascend(kwargs)
         # Setup and start MindData Profiling
         if self._data_process:
             self._md_profiler = cde.GlobalContext.profiling_manager()
             self._md_profiler.init()
         self._init_time = int(time.time() * 10000000)
         logger.info("Profiling: profiling init time: %d", self._init_time)
-        self._parse_parameter_for_ascend(kwargs)
-        os.environ['DEVICE_ID'] = self._dev_id
 
+        os.environ['DEVICE_ID'] = self._dev_id
         self._ascend_profiling_options = json.dumps(self._construct_profiling_options())
         # Characters longer than 2048 are ignored, resulting in profiling option resolution errors
         if len(self._ascend_profiling_options) > 2048:
@@ -906,7 +1026,7 @@ class Profiler:
         data_path = os.path.join(container_path, "data")
         data_path = validate_and_normalize_path(data_path)
         if not os.path.exists(data_path):
-            os.makedirs(data_path, exist_ok=True)
+            os.makedirs(data_path, exist_ok=True, mode=stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
 
     def _construct_profiling_options(self):
         """
@@ -919,18 +1039,22 @@ class Profiler:
             "output": self._output_path,
             "fp_point": fp_point,
             "bp_point": bp_point,
-            "training_trace": "on" if self._op_time else "off",
-            "task_trace": "on" if self._op_time else "off",
+            "training_trace": self.ENABLE_STATUS if self._op_time else self.DISABLE_STATUS,
+            "task_trace": self.ENABLE_STATUS if self._op_time else self.DISABLE_STATUS,
             "aic_metrics": AICORE_METRICS_DICT.get(self._aicore_metrics_id, "ArithmeticUtilization"),
-            "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",
+            "aicpu": self.ENABLE_STATUS if self._data_process or self._op_time else self.DISABLE_STATUS,
+            "profile_memory": self.ENABLE_STATUS if self._op_time and self._profile_memory else self.DISABLE_STATUS,
+            "hccl": self.ENABLE_STATUS if self._op_time and self._profile_communication else self.DISABLE_STATUS,
             "l2_cache": self._l2_cache,
-            "parallel_strategy": "on" if self._parallel_strategy else "off",
-            "op_time": "on" if self._op_time else "off",
-            "profile_framework": self._profile_framework
+            "hbm_ddr": self._hbm_ddr,
+            "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,
+            "with_stack": "on" if self._with_stack else "off"
         }
-
+        ProfilerInfo.set_profiling_options(profiling_options)
         return profiling_options
 
     def _parse_parameter_for_gpu(self, kwargs):
@@ -961,7 +1085,7 @@ class Profiler:
             self._profile_communication = False
 
         if self._profile_communication:
-            hccl_option = {"output": self._output_path, "task_trace": "on"}
+            hccl_option = {"output": self._output_path, "task_trace": self.ENABLE_STATUS}
             os.environ['PROFILING_OPTIONS'] = json.dumps(hccl_option)
 
         self._profile_memory = kwargs.pop("profile_memory", False)
@@ -978,7 +1102,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], but got {self._aicore_metrics_id}, it will be set to 0.")
+                           f"[-1, 0, 1, 2, 3, 4, 5, 6], 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)
@@ -986,38 +1110,43 @@ class Profiler:
             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:
-            self._l2_cache = "off"
-
-        self._parallel_strategy = kwargs.pop("parallel_strategy", True)
+        self._l2_cache = self.ENABLE_STATUS if l2_cache_enable else self.DISABLE_STATUS
+
+        hbm_ddr_enable = kwargs.pop("hbm_ddr", False)
+        if not isinstance(hbm_ddr_enable, bool):
+            logger.warning(f"For '{self.__class__.__name__}', the parameter hbm_ddr must be bool, "
+                           f"but got type {type(hbm_ddr_enable)}, it will be set to False.")
+            hbm_ddr_enable = False
+        self._hbm_ddr = self.ENABLE_STATUS if hbm_ddr_enable else self.DISABLE_STATUS
+
+        pcie_enable = kwargs.pop("pcie", False)
+        if not isinstance(pcie_enable, bool):
+            logger.warning(f"For '{self.__class__.__name__}', the parameter pcie must be bool, "
+                           f"but got type {type(pcie_enable)}, it will be set to False.")
+            pcie_enable = False
+        self._pcie = self.ENABLE_STATUS if pcie_enable else self.DISABLE_STATUS
+
+        self._parallel_strategy = kwargs.pop("parallel_strategy", False)
         if not isinstance(self._parallel_strategy, bool):
             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":
-            logger.warning(f"For '{self.__class__.__name__}', Profiling is not supported if set environment "
-                           f"'GRAPH_OP_RUN' value to 1, which means model training task is not sink.")
-
-    def _set_ascend_job_id(self, ascend_job_id):
-        """Set output_path for offline parsing performance data."""
-        if not ascend_job_id:
-            return
-        self._ascend_job_id = validate_and_normalize_path(ascend_job_id)
-        if not os.path.exists(self._ascend_job_id):
-            msg = f"Invalid ascend_job_id: {self._ascend_job_id}, Please pass the absolute path of the JOB dir"
-            logger.critical(msg)
-            raise ValueError(msg)
-        self._output_path, _ = os.path.split(self._ascend_job_id)
-
-    def _is_offline_parser(self):
-        """Return whether offline parser or online parser."""
-        if self._device_target and self._device_target == DeviceTarget.ASCEND.value:
-            return bool(self._ascend_job_id)
-        return False
+                           f"but got type {type(self._parallel_strategy)}, it will be set to False.")
+            self._parallel_strategy = False
+
+        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."""
@@ -1029,23 +1158,21 @@ class Profiler:
             self._rank_size = get_group_size()
         else:
             self._rank_size = int(os.getenv('RANK_SIZE', '1'))
+        ProfilerInfo.set_rank_size(self._rank_size)
 
         if self._has_started:
             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, source_path):
+    def _minddata_analyse(self):
         """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:
@@ -1065,6 +1192,16 @@ 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.
@@ -1088,7 +1225,7 @@ class Profiler:
             pass
         return points
 
-    def _ascend_op_analyse(self, op_summary, op_statistic, dynamic_status):
+    def _ascend_op_analyse(self, op_summary, op_statistic, dynamic_status, launch_ops: List):
         """
         Ascend graph model hwts analyse.
 
@@ -1115,12 +1252,12 @@ class Profiler:
             else:
                 output_timeline_data_path = None
 
-            op_analyser = AscendOPGenerator(op_summary, op_statistic, dynamic_status)
+            op_analyser = AscendOPGenerator(op_summary, op_statistic, dynamic_status, launch_ops)
             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 as err:
-            logger.warning(err.message)
+        except (ProfilerException, RuntimeError) as err:
+            logger.warning(str(err))
         finally:
             pass
 
@@ -1142,19 +1279,22 @@ class Profiler:
         finally:
             pass
 
-    def _ascend_timeline_analyse(self, op_summary, steptrace):
+    def _ascend_timeline_analyse(self, op_summary, steptrace, source_path, mindstudio_profiler_output) -> List:
         """Analyse timeline info."""
         try:
             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'))
-            timeline_analyser.init_timeline(op_summary, steptrace, pretty=self._pretty_json)
-            timeline_analyser.write_timeline(self._timeline_size_limit_byte)
+            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))
+            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:
             pass
+        return timeline_analyser.get_kernel_event_list()
 
     def _ascend_dynamic_net_analyse(self, op_summary):
         """Analyse dynamic shape network info."""
@@ -1168,7 +1308,7 @@ class Profiler:
         dynamic_parser = DynamicFrameWorkParser(self._output_path, self._rank_id, pretty=self._pretty_json)
         dynamic_parser.write_dynamic_shape_data(op_summary)
 
-    def _ascend_flops_analyse(self, op_summary):
+    def _ascend_flops_analyse(self, op_summary, launch_ops):
         """Get op FLOPs from op_summary, write output_op_flops_x.csv."""
         if 'vector_fops' not in op_summary.dtype.names and 'cube_fops' not in op_summary.dtype.names:
             logger.warning("[Profiler] Can not found cube fops and vector fops data in the op summary.")
@@ -1183,16 +1323,16 @@ class Profiler:
             flops_path = validate_and_normalize_path(flops_path)
             flops_summary_path = validate_and_normalize_path(flops_summary_path)
 
-            flops_analyser = AscendFlopsGenerator(op_summary, pretty=self._pretty_json)
+            flops_analyser = AscendFlopsGenerator(op_summary, launch_ops, pretty=self._pretty_json)
             flops_analyser.parse()
             flops_analyser.write(flops_path, flops_summary_path)
 
-        except ProfilerException as err:
-            logger.warning(err.message)
+        except (ProfilerException, RuntimeError) as err:
+            logger.warning(str(err))
         finally:
             pass
 
-    def _ascend_graph_memory_analyse(self, points):
+    def _ascend_graph_memory_analyse(self):
         """Analyse memory usage info."""
         if not self._profile_memory:
             return
@@ -1201,7 +1341,7 @@ class Profiler:
                            "PyNative mode currently.")
         try:
             logger.info("Profiling: analyzing the memory usage info.")
-            self._analyse_memory_usage(points)
+            self._analyse_memory_usage()
         except (ProfilerIOException, ProfilerFileNotFoundException, ProfilerRawFileException) as err:
             logger.warning(err.message)
         finally:
@@ -1209,30 +1349,52 @@ class Profiler:
 
     def _ascend_ms_analyze(self, source_path):
         """Ascend ms generate"""
-        time_stamp = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
+
+        timestamp = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
         if self._rank_id:
-            ascend_ms_path = f"rank-{self._rank_id}_{time_stamp}_ascend_ms"
+            ascend_ms_path = f"rank-{self._rank_id}_{timestamp}_ascend_ms"
         else:
-            ascend_ms_path = f"{socket.gethostname()}--{os.getpid()}_{time_stamp}_ascend_ms"
-        self._ascend_ms_path = os.path.join(self._output_path, ascend_ms_path)
-        if not os.path.exists(self._ascend_ms_path):
-            os.makedirs(self._ascend_ms_path, exist_ok=True)
-            os.chmod(self._ascend_ms_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
+            ascend_ms_path = f"{socket.gethostname()}--{os.getpid()}_{timestamp}_ascend_ms"
+        ascend_ms_path = os.path.join(self._output_path, ascend_ms_path)
 
         dev_id = self._rank_id if self._device_target == DeviceTarget.ASCEND.value else self._dev_id
-        ascend_profiler_output_path = os.path.join(self._ascend_ms_path, 'ASCEND_PROFILER_OUTPUT')
-        os.makedirs(ascend_profiler_output_path, exist_ok=True)
+        ascend_profiler_output_path = os.path.join(ascend_ms_path, 'ASCEND_PROFILER_OUTPUT')
+        PathManager.make_dir_safety(ascend_profiler_output_path)
 
         source_profiler_info_path = os.path.join(self._output_path, f"profiler_info_{dev_id}.json")
-        target_profiler_info_path = os.path.join(self._ascend_ms_path, f"profiler_info_{dev_id}.json")
-        shutil.copy(source_profiler_info_path, target_profiler_info_path)
+        target_profiler_info_path = os.path.join(ascend_ms_path, f"profiler_info_{dev_id}.json")
+        PathManager.copy_file(source_profiler_info_path, target_profiler_info_path)
+
+        source_profiler_metadata_path = os.path.join(self._output_path, f"profiler_metadata.json")
+        target_profiler_metadata_path = os.path.join(ascend_ms_path, f"profiler_metadata.json")
+        PathManager.copy_file(source_profiler_metadata_path, target_profiler_metadata_path)
 
         source_timeline_path = os.path.join(self._output_path, f"ascend_timeline_display_{dev_id}.json")
         target_timeline_path = os.path.join(ascend_profiler_output_path, f"trace_view.json")
-        shutil.copy(source_timeline_path, target_timeline_path)
+        PathManager.copy_file(source_timeline_path, target_timeline_path)
+
+        src_op_mem_file = os.path.join(self._output_path, f"operator_memory_{dev_id}.csv")
+        dst_op_mem_file = os.path.join(ascend_profiler_output_path, f"operator_memory.csv")
+        PathManager.copy_file(src_op_mem_file, dst_op_mem_file)
+
+        ms_output_path = os.path.realpath(
+            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")
+            PathManager.copy_file(src_static_op_mem_path[0], dst_static_op_mem_file)
+
+        src_op_statistics_path = os.path.join(ms_output_path, "op_statistic_*.csv")
+        src_op_statistics_path = glob.glob(src_op_statistics_path)
+        if src_op_statistics_path:
+            dst_op_statistics_path = os.path.join(ascend_profiler_output_path, f"op_statistic.csv")
+            PathManager.copy_file(src_op_statistics_path[0], dst_op_statistics_path)
 
         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"""
@@ -1243,7 +1405,7 @@ class Profiler:
             step_trace_time_path = os.path.join(ascend_profiler_output_path, f'step_trace_time.csv')
             step_trace_time_path = validate_and_normalize_path(step_trace_time_path)
 
-            cluster_analyse = AscendClusterGenerator(os.path.join(source_path, 'timeline'))
+            cluster_analyse = AscendClusterGenerator(source_path)
             cluster_analyse.parse()
             cluster_analyse.write(step_trace_time_path)
         except (ProfilerIOException, ProfilerFileNotFoundException, ProfilerRawFileException) as err:
@@ -1262,10 +1424,11 @@ class Profiler:
             communication_file_path = os.path.join(ascend_profiler_output_path, f'communication.json')
             communication_file_path = validate_and_normalize_path(communication_file_path)
 
-            communication_matrix_file_path = os.path.join(ascend_profiler_output_path, f"communication_matrix.json")
+            communication_matrix_file_path = os.path.join(ascend_profiler_output_path,
+                                                          f"communication_matrix.json")
             communication_matrix_file_path = validate_and_normalize_path(communication_matrix_file_path)
 
-            analyze_path = os.path.join(os.path.dirname(source_path), 'analyze')
+            analyze_path = os.path.realpath(os.path.join(source_path, os.path.pardir, 'analyze'))
             communicate_analyser = AscendCommunicationGenerator(analyze_path)
             communicate_analyser.parse()
             communicate_analyser.write(communication_file_path, communication_matrix_file_path)
@@ -1274,7 +1437,7 @@ class Profiler:
         finally:
             pass
 
-    def _ascend_graph_hccl_analyse(self, source_path, steptrace, flag):
+    def _ascend_graph_hccl_analyse(self, mindstudio_profiler_output, steptrace):
         """Analyse hccl profiler info."""
         if not self._profile_communication:
             return
@@ -1288,10 +1451,7 @@ class Profiler:
 
             hccl_raw_path = os.path.join(self._output_path, f'hccl_raw_{dev_id}.csv')
             hccl_raw_path = validate_and_normalize_path(hccl_raw_path)
-            if flag:
-                hccl_analyse = AscendHCCLGenerator(os.path.join(source_path, 'timeline'), steptrace)
-            else:
-                hccl_analyse = AscendHCCLGeneratorOld(os.path.join(source_path, 'timeline'))
+            hccl_analyse = AscendHCCLGenerator(mindstudio_profiler_output, steptrace)
             hccl_analyse.parse()
             hccl_analyse.write(hccl_raw_path)
 
@@ -1300,62 +1460,87 @@ 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, pretty=self._pretty_json)
-        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 _get_kernel_op_map(self, op_summary, kernels: List[CANNEvent]) -> List:
+        """Get the mapping between framework operator and device kernel."""
+        if not kernels:
+            return []
+        kernel_map = {}
+        for kernel in kernels:
+            key = kernel.name if kernel.name.startswith('hcom_') else (kernel.name, str(kernel.ts))
+            kernel_map[key] = kernel.parent
+        launch_ops = [None] * len(op_summary)
+        for index, summary in enumerate(op_summary):
+            ts = str(summary['Task Start Time(us)']).strip("\t")
+            name = summary['Op Name']
+            key = name if name.startswith("hcom_") else (name, ts)
+            launch_op = kernel_map.get(key)
+            if not launch_op:
+                continue
+            launch_ops[index] = launch_op.name
+        return launch_ops
 
-    def _ascend_graph_analyse(self):
-        """Ascend graph mode analyse."""
-        self._ascend_profiler.finalize()
+    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)
 
-        job_id = self._get_profiling_job_id()
+    @timeit("Profiler analyse done")
+    def _ascend_graph_analyse_inner(self, offline_path=None):
+        """Ascend graph mode analyse."""
+        job_id = self._get_profiling_job_id(offline_path)
         if not job_id:
             return
         logger.info("Profiling: job id is %s ", job_id)
 
         self._check_output_path(output_path=self._output_path)
         source_path = os.path.join(self._output_path, job_id)
-        self._minddata_analyse(source_path)
+        self._minddata_analyse()
         if self._op_time:
-            flag = _ascend_graph_msprof_generator(source_path, self._model_iteration_dict)
+            mindstudio_profiler_output = os.path.realpath(
+                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, '
                                'this may lead to performance degradation. Suggest upgrading the driver package.')
             ProfilerInfo.set_export_flag(flag)
-            op_summary, op_statistic, steptrace = _ascend_graph_msprof_analyse(source_path, flag)
-            self._ascend_op_analyse(op_summary, op_statistic, self._dynamic_status)
-            self._ascend_timeline_analyse(op_summary, steptrace)
+            op_summary, op_statistic, steptrace, steptrace_model \
+                = _ascend_graph_msprof_analyse(mindstudio_profiler_output)
+            kernels = self._ascend_timeline_analyse(op_summary, steptrace, source_path, mindstudio_profiler_output)
+
+            if isinstance(op_statistic, np.ndarray) and op_statistic.shape[0] == 0 or \
+                    not isinstance(op_statistic, np.ndarray) and not op_statistic:
+                logger.warning('Op statistic data is empty!')
+                return
+
+            launch_ops = self._get_kernel_op_map(op_summary, kernels)
+            self._ascend_op_analyse(op_summary, op_statistic, self._dynamic_status, launch_ops)
             graph_ids = np.unique(op_summary['Model ID']).tolist()
-            points = self._ascend_fpbp_analyse(op_summary, steptrace)
+            self._ascend_fpbp_analyse(op_summary, steptrace)
             if len(graph_ids) == 1:
                 self._ascend_step_trace_analyse(steptrace)
+            else:
+                self._ascend_step_trace_analyse(steptrace_model)
             if self._dynamic_status:
                 self._ascend_dynamic_net_analyse(op_summary)
-            self._ascend_flops_analyse(op_summary)
-            self._ascend_graph_memory_analyse(points)
-            self._ascend_ms_analyze(source_path)
-            self._ascend_graph_hccl_analyse(source_path, steptrace, flag)
-            self._ascend_graph_msadvisor_analyse(job_id)
+            self._ascend_flops_analyse(op_summary, launch_ops)
+            self._ascend_graph_memory_analyse()
+            self._ascend_ms_analyze(mindstudio_profiler_output)
+            self._ascend_graph_hccl_analyse(mindstudio_profiler_output, steptrace)
+            self._minddata_aicpu_analyse(self._output_path, job_id)
             ProfilerInfo.set_graph_ids(graph_ids)
+        try:
+            ProfilerInfo.set_data_simplification(self._data_simplification)
+            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."""
+        op_range_file = os.path.join(self._framework_path, "op_range_" + str(self._rank_id))
+        if os.path.exists(op_range_file):
+            os.remove(op_range_file)
+            logger.info("Clear old op range filer.")
         self._ascend_profiler.start()
 
     def _gpu_analyse(self):
@@ -1370,12 +1555,14 @@ class Profiler:
         else:
             self._rank_size = int(os.getenv('RANK_SIZE', '1'))
 
+        ProfilerInfo.set_rank_size(self._rank_size)
+
         if self._has_started:
             self.stop()
         else:
             logger.info("No need to stop profiler because profiler has been stopped.")
 
-        self._minddata_analyse(self._output_path)
+        self._minddata_analyse()
 
         try:
             self._analyse_step_relation_info()
@@ -1438,13 +1625,14 @@ class Profiler:
         if self._has_started:
             self.stop()
         else:
-            logger.info("No need to stop profiler because profiler has been stopped or profiler has not been started.")
+            logger.info("No need to stop profiler because profiler has been stopped.")
+
         if not self._op_time:
             return
         try:
             timeline_generator = CpuTimelineGenerator(self._output_path, self._rank_id, context.get_context("mode"))
             timeline_generator.init_timeline(pretty=self._pretty_json)
-            timeline_generator.write_timeline(self._timeline_size_limit_byte)
+            timeline_generator.write_timeline()
             timeline_generator.write_timeline_summary()
         except (ProfilerIOException, ProfilerFileNotFoundException, RuntimeError) as err:
             logger.warning('Fail to write timeline data: %s', err)
@@ -1453,15 +1641,13 @@ class Profiler:
             raise RuntimeError("Currently, the CPU platform does not support Pynative mode to collect performance "
                                "data.")
 
-    def _analyse_step_trace(self, source_path=None, framework_parser=None, is_training_mode_flag=True,
-                            is_gpu_kernel_async_launch_flag=False):
+    def _analyse_step_trace(self, is_training_mode_flag=True, is_gpu_kernel_async_launch_flag=False):
         """
         Analyse step trace data and save the result.
 
         Args:
-            source_path (str): The directory that contains the step trace original data.
-            framework_parser (FrameworkParser): The framework parse instance.
             is_training_mode_flag (bool): Whether in training mode or not.
+            is_gpu_kernel_async_launch_flag (bool): Whether gpu kernel launches are asynchronous
         """
         logger.info("Begin to parse step trace.")
         # construct output path
@@ -1492,68 +1678,35 @@ class Profiler:
                 logger.info("Finish saving the intermediate result: %s", step_trace_intermediate_file_path)
                 logger.info("The point info is: %s", point_info)
 
-                return point_info, is_training_mode_flag
-            return {}, is_training_mode_flag
-
-        # whether keep the first step
-        skip_first_step_flag = framework_parser.check_op_name(INIT_OP_NAME)
-        # recognize inference or training mode
-        is_training_mode_flag = framework_parser.check_op_name("Gradients")
-        # parser the step trace files and save the result to disk
-        source_path = validate_and_normalize_path(source_path)
-        parser = AscendStepTraceParser(input_dir=source_path,
-                                       output_file_path=step_trace_intermediate_file_path,
-                                       skip_first_step=skip_first_step_flag,
-                                       is_training_mode=is_training_mode_flag)
-        parser.set_task_id_op_name_dict(framework_parser.to_task_id_full_op_name_dict())
-        parser.parse_and_save()
-        point_info = parser.record_point_info(point_info_file_path)
-
-        # print parser result
-        parser.show()
-        logger.info("Finish saving the intermediate result: %s", step_trace_intermediate_file_path)
-        logger.info("The point info is: %s", point_info)
-
-        return point_info, is_training_mode_flag
-
     def _generate_timeline(self, reduce_op_type):
         """Used for gpu, generate timeline info, write to json format file."""
         try:
             timeline_generator = GpuTimelineGenerator(self._output_path, self._dev_id, self._rank_size,
                                                       context.get_context("mode"))
             timeline_generator.init_timeline(reduce_op_type)
-            self._timeline_meta = timeline_generator.write_timeline(self._timeline_size_limit_byte)
+            self._timeline_meta = timeline_generator.write_timeline()
             timeline_generator.write_timeline_summary()
+            timeline_generator.parse_fwk_data()
+            timeline_generator.write_fwk_timeline()
             return timeline_generator
         except (ProfilerIOException, ProfilerFileNotFoundException, RuntimeError) as err:
             logger.warning('Fail to write timeline data: %s', err)
             raise RuntimeError('Fail to write timeline data.') from err
 
-    def _analyse_memory_usage(self, points):
+    def _analyse_memory_usage(self):
         """Analyse memory usage data."""
         integrator = Integrator(self._output_path, self._rank_id)
-        aicore_detail_data = integrator.get_aicore_detail_data()
-        memory_parser = MemoryUsageParser(self._output_path, self._rank_id, pretty=self._pretty_json)
-        memory_parser.init_memory_usage_info(aicore_detail_data, points)
-        memory_parser.write_memory_files()
+        integrator.get_aicore_detail_data()
 
-    def _get_profiling_job_id(self):
+    def _get_profiling_job_id(self, offline_path):
         """Get profiling job id, which was generated by ada service.
 
         Returns:
-            str, profiling job id.
+            str, profiling job id, eg: PROF_XXX/device_*.
         """
 
-        if self._is_offline_parser():
-            # The self._ascend_job_id directory like "/../PROF***" or "/../JOB***".
-            job_id = self._ascend_job_id.rstrip('/').split('/')[-1]
-            if job_id.startswith('PROF'):
-                device_dir = [dir for dir in os.listdir(self._ascend_job_id) if dir.startswith('device')]
-                info_file_path = get_file_path(os.path.join(self._ascend_job_id, device_dir[0]), "info.json")
-                training_rank_id, _ = self._parse_info_json(info_file_path)
-                self._rank_id = int(training_rank_id)
-                return os.path.join(job_id, device_dir[0])
-            return job_id
+        if offline_path:
+            self._output_path = os.path.join(offline_path, 'profiler')
 
         job_id = ""
         job_dirs = filter(lambda item: item.startswith('JOB') or item.startswith('PROF') and os.path.isdir(
@@ -1562,16 +1715,12 @@ class Profiler:
             job_dirs, key=lambda x: os.path.getmtime(os.path.join(self._output_path, x)), reverse=True)
 
         for dir_name in sorted_job_dirs:
-            if dir_name.startswith('PROF'):
-                prof_dir = os.path.join(self._output_path, dir_name)
-                device_dir = [dir for dir in os.listdir(prof_dir) \
-                              if dir.startswith('device') and os.path.isdir(os.path.join(prof_dir, dir))]
-                job_dir = os.path.join(self._output_path, dir_name, device_dir[0])
-            else:
-                job_dir = os.path.join(self._output_path, dir_name)
+            prof_dir = os.path.join(self._output_path, dir_name)
+            device_dir = [dir for dir in os.listdir(prof_dir) \
+                          if dir.startswith('device') and os.path.isdir(os.path.join(prof_dir, dir))]
+            job_dir = os.path.join(self._output_path, dir_name, device_dir[0])
 
-            start_file_path = get_file_path(job_dir, "start_info")
-            if start_file_path is None:
+            if get_file_path(job_dir, "start_info") is None:
                 logger.warning("Find profiling job path %s, but host_start.log not exist, "
                                "profiler will ignore this job dir.", job_dir)
                 continue
@@ -1582,25 +1731,26 @@ class Profiler:
                                "profiler will ignore this job dir.", job_dir)
                 continue
 
-            job_start_time = self._parse_start_log(start_file_path)
-            _, training_device_id = self._parse_info_json(info_file_path)
+            prof_rank_id = ProfilerInfo.get_rank_id(self._output_path)
+            prof_device_id = ProfilerInfo.get_device_id(prof_dir)
+            job_start_time = self._parse_job_start_time(prof_dir)
 
-            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, "
-                             "profiler will ignore this job dir.", job_dir, self._dev_id, training_device_id)
-                continue
+            if offline_path:
+                self._start_time = int(job_start_time)
+            else:
+                if self._dev_id != prof_device_id and self._rank_id != prof_rank_id:
+                    logger.warning("Find profiling find job path %s, but not current training device id. "
+                                   "Current training rank id %s, but job path rank id: %s, "
+                                   "profiler will ignore this job dir.", job_dir, self._rank_id, prof_rank_id)
+                    continue
 
-            if int(job_start_time) < self._start_time:
-                logger.warning("Find profiling job path %s, but start_time(%d) is earlier than this training "
-                               "start_time(%d), profiler will ignore this job dir.",
-                               job_dir, int(job_start_time), self._start_time)
-                continue
+                if job_start_time < self._start_time:
+                    logger.warning("Find profiling job path %s, but start_time(%d) is earlier than this training "
+                                   "start_time(%d), profiler will ignore this job dir.",
+                                   job_dir, job_start_time, self._start_time)
+                    continue
 
-            if dir_name.startswith('PROF'):
-                job_id = os.path.join(dir_name, device_dir[0])
-            else:
-                job_id = dir_name
+            job_id = os.path.join(dir_name, device_dir[0])
             break
 
         if not job_id:
@@ -1700,15 +1850,21 @@ class Profiler:
                 self._output_path = validate_and_normalize_path(output_path)
         else:
             output_path = kwargs.pop("output_path")
+            if not isinstance(output_path, str):
+                logger.warning(
+                    f"The output_path must be a string, but got type {type(output_path)}, it will be set to 'data'.")
+                output_path = "data"
             self._output_path = validate_and_normalize_path(output_path)
 
         self._output_path = os.path.join(self._output_path, "profiler")
         if not os.path.exists(self._output_path):
-            os.makedirs(self._output_path, exist_ok=True)
-            os.chmod(self._output_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
+            os.makedirs(self._output_path, exist_ok=True, mode=stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
         else:
             logger.warning("The target dir already exists. "
                            "There may be some old profiling data, and they will be rewritten in the end.")
+        self._framework_path = os.path.join(self._output_path, "FRAMEWORK")
+        if not os.path.exists(self._framework_path):
+            os.makedirs(self._framework_path, exist_ok=True, mode=stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
 
     def _parser_kwargs(self, kwargs):
         """Parse kwargs vale."""
@@ -1729,11 +1885,11 @@ class Profiler:
                            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)
+        self._data_process = kwargs.pop("data_process", False)
         if not isinstance(self._data_process, bool):
             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
+                           f"but got type {type(self._data_process)}, it will be set to False.")
+            self._data_process = False
 
         timeline_limit = kwargs.pop("timeline_limit", 500)
         if isinstance(timeline_limit, bool) or not isinstance(timeline_limit, int):
@@ -1745,55 +1901,22 @@ class Profiler:
                 "[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
-        self._profile_framework = kwargs.pop("profile_framework", "all")
-        if self._profile_framework not in ["memory", "time", "all", None]:
-            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"
-
-    def _host_info_analyse(self):
-        """
-        Read data from the csv file, and write it into timeline file, so the timeline can be show on tracing tool.
-        """
-        logger.info("Profiling HostInfo start.")
-        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.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'
-        memory_file_name = 'host_memory_' + str(self._rank_id) + '.csv'
-        dataset_file_name = 'dataset_' + str(self._rank_id) + '.csv'
-        host_info_file = os.path.join(self._output_path, 'host_info', csv_file_name)
-        timeline_file = os.path.join(self._output_path, 'host_info', json_file_name)
-        memory_file = os.path.join(self._output_path, 'host_info', memory_file_name)
-        dataset_execution_file = os.path.join(self._output_path, 'host_info', dataset_file_name)
-        _parse_host_info(host_info_file, timeline_file, memory_file)
-        _calculate_dataset_execution_time(host_info_file, dataset_execution_file)
-        logger.info("Profile HostInfo finished.")
-
-
-def _offline_parse(offline_path):
-    """Parse data in abnormal scenario, only support for host_info at present."""
-    logger.info("Profiling HostInfo offline start.")
-    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.error("Host info directory: %s not exist.", host_dir)
-        return
-    files = os.listdir(host_dir)
-    for file in files:
-        if not file.startswith("host_info_") or not file.endswith(".csv"):
-            continue
-        rank_id = file.split('_')[-1].split('.')[0]
-        if not rank_id.isdigit():
-            logger.info("Cannot get rank_id from file: %s, skip it", file)
-            return
-        host_info_file = os.path.join(host_dir, file)
-        timeline_file = os.path.join(host_dir, f'timeline_{rank_id}.json')
-        memory_file = os.path.join(host_dir, f'host_memory_{rank_id}.csv')
-        dataset_execution_file = os.path.join(host_dir, f'dataset_{rank_id}.csv')
-        _parse_host_info(host_info_file, timeline_file, memory_file)
-        _calculate_dataset_execution_time(host_info_file, dataset_execution_file)
-    logger.info("Profile HostInfo offline finished.")
+        self._profile_framework = kwargs.pop("profile_framework", None)
+        if self._profile_framework not in ["time", "all", None]:
+            logger.warning(f"For '{self.__class__.__name__}', the parameter profile_framework must be one of ["
+                           f" 'time', 'all', None], but got {self._profile_framework}, it will be set to None.")
+            self._profile_framework = None
+
+        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._with_stack = kwargs.pop("with_stack", False)
+        if not isinstance(self._with_stack, bool):
+            logger.warning(f"For '{self.__class__.__name__}', the parameter with_stack must be bool, but got "
+                           f"type {type(self._with_stack)}, it will be set to False.")
+            self._with_stack = False
+        if self._with_stack and self._profile_framework not in ["time", "all"]:
+            logger.warning("When using the with_stack parameter, the profile_framework parameter must be enabled.")
+            self._with_stack = False