mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0rc1__cp310-cp310-win_amd64.whl

mindspore/profiler/__init__.py

@@ -16,26 +16,30 @@
 This module provides Python APIs to enable the profiling of MindSpore neural networks.
 Users can import the mindspore.profiler.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 MindInsight tool.
 Now, Profiler supports AICORE operator, AICPU operator, HostCPU operator, memory,
 correspondence, cluster, etc data analysis.
 """
 __all__ = [
-    "tensor_board_trace_handler",
+    "tensorboard_trace_handler",
     "schedule",
     "Profiler",
     "EnvProfiler",
     "ProfilerLevel",
     "ProfilerActivity",
     "AicoreMetrics",
+    "ExportType",
     "DynamicProfilerMonitor",
-    "mstx"
+    "mstx",
+    "_ExperimentalConfig",
+    "profile"
 ]
 
 from mindspore.profiler.mstx import Mstx as mstx
 from mindspore.profiler.profiler import Profiler
-from mindspore.profiler.profiler import tensor_board_trace_handler
+from mindspore.profiler.profiler import tensorboard_trace_handler
 from mindspore.profiler.schedule import Schedule as schedule
 from mindspore.profiler.envprofiler import EnvProfiler
-from mindspore.profiler.common.constant import ProfilerLevel, ProfilerActivity, AicoreMetrics
+from mindspore.profiler.common.constant import ProfilerLevel, ProfilerActivity, AicoreMetrics, ExportType
 from mindspore.profiler.dynamic_profiler import DynamicProfilerMonitor
+from mindspore.profiler.experimental_config import _ExperimentalConfig
+from mindspore.profiler.profiler import Profile as profile

mindspore/profiler/analysis/parser/ascend_cann_parser.py

@@ -23,7 +23,7 @@ from mindspore import log as logger
 from mindspore.profiler.analysis.parser.base_parser import BaseParser
 from mindspore.profiler.common.file_manager import FileManager
 from mindspore.profiler.common.path_manager import PathManager
-from mindspore.profiler.common.constant import ProfilerLevel
+from mindspore.profiler.common.constant import ProfilerLevel, ExportType
 from mindspore.profiler.common.ascend_msprof_exporter import AscendMsprofExporter
 from mindspore.profiler.common.log import ProfilerLogger
 
@@ -50,6 +50,7 @@ class AscendMsprofParser(BaseParser):
         )
         self._ascend_ms_dir = self._kwargs.get("ascend_ms_dir")
         self._profiler_level = kwargs.get("profiler_level")
+        self._export_type = kwargs.get("export_type")
         ProfilerLogger.init(self._ascend_ms_dir)
         self._logger = ProfilerLogger.get_instance()
         self.op_summary = None
@@ -89,7 +90,8 @@ class AscendMsprofParser(BaseParser):
         Raises:
             RuntimeError: If no op summary files are found or read file failed.
         """
-        if self._profiler_level == ProfilerLevel.LevelNone.value:
+        if (self._profiler_level == ProfilerLevel.LevelNone.value or
+                self._export_type == [ExportType.Db.value]):
             return
         file_path_list = glob.glob(
             os.path.join(
@@ -117,6 +119,8 @@ class AscendMsprofParser(BaseParser):
         Raises:
             RuntimeError: If no msprof JSON files are found in the specified directory.
         """
+        if self._export_type == [ExportType.Db.value]:
+            return
         file_path_list = []
         for pattern in self._MSPROF_TIMELINE_FILE_PATTERN:
             file_path_list.extend(glob.glob(os.path.join(self._msprof_profile_output_path, pattern)))

mindspore/profiler/analysis/parser/ms_framework_parser.py

@@ -29,7 +29,7 @@ from mindspore.profiler.common.log import ProfilerLogger
 class FrameworkParser(BaseParser):
     """Parser for MindSpore framework profiling data."""
 
-    _OP_RANGE_FILE_NAME = "op_range_{}"
+    _OP_RANGE_FILE_NAME = "mindspore.op_range"
     _CPU_OP_TIMESTAMP_FILE_NAME = "cpu_op_execute_timestamp_{}.txt"
 
     def __init__(self, next_parser: Optional[BaseParser] = None, **kwargs):
@@ -43,7 +43,7 @@ class FrameworkParser(BaseParser):
         self._ascend_ms_dir = kwargs.get("ascend_ms_dir")
         self._op_range_path = os.path.join(
             self._framework_path,
-            self._OP_RANGE_FILE_NAME.format(self._rank_id)
+            self._OP_RANGE_FILE_NAME
         )
         self._cpu_op_path = os.path.join(
             self._framework_path,
@@ -118,13 +118,13 @@ class FrameworkParser(BaseParser):
             return op_range_list
 
         first_step = min(
-            op[FileConstant.FIX_SIZE_DATA][OpRangeStructField.STEP_ID.value]
+            op[FileConstant.FIX_SIZE_DATA][OpRangeStructField.STEP.value]
             for op in op_range_list
         )
         adjusted_step_list = [step - 1 + first_step for step in self._step_list]
         return [
             op for op in op_range_list
-            if op[FileConstant.FIX_SIZE_DATA][OpRangeStructField.STEP_ID.value] in adjusted_step_list
+            if op[FileConstant.FIX_SIZE_DATA][OpRangeStructField.STEP.value] in adjusted_step_list
         ]
 
     def _parse_cpu_op_data(self) -> List[str]:

mindspore/profiler/analysis/parser/timeline_assembly_factory/ascend_timeline_assembler.py

@@ -19,7 +19,7 @@ from collections import defaultdict
 
 from mindspore import context
 from mindspore import log as logger
-from mindspore.profiler.common.constant import EventConstant, TimelineLayerName, ProfilerLevel
+from mindspore.profiler.common.constant import EventConstant, TimelineLayerName, ProfilerLevel, JitLevel
 from mindspore.profiler.analysis.parser.timeline_event.base_event import BaseEvent
 from mindspore.profiler.analysis.parser.timeline_event.timeline_event_pool import TimelineEventPool
 from mindspore.profiler.analysis.parser.timeline_event.flow_event import FlowStartEvent, FlowEndEvent
@@ -40,6 +40,7 @@ class AscendTimelineAssembler(BaseTimelineAssembler):
         super().__init__()
         self._profiler_level = kwargs.get("profiler_level")
         self._context_mode = kwargs.get("context_mode")
+        self._jit_level = kwargs.get("jit_level")
         self._init_creators()
 
     def _init_creators(self):
@@ -127,11 +128,13 @@ class AscendTimelineAssembler(BaseTimelineAssembler):
         """Create flow events between framework and hardware events."""
         acl_to_npu_flow_dict = self._msprof_creator.get_acl_to_npu_flow_dict()
         fwk_launch_op_list = self.trace_view_container.kernel_launch_op_event
-        if not acl_to_npu_flow_dict:
+        # The graph mode O2 does not have the flow from CANN to hardware at each step
+        if not acl_to_npu_flow_dict and self._jit_level != JitLevel.GRAPH_LEVEL:
             logger.error("Cannot find connection between CANN layer and Ascend Hardware layer.")
             return []
-        if not fwk_launch_op_list:
-            logger.warning("Cannot find launch op in MindSpore framework. Please verify if it's in graph mode.")
+        # The graph model O2 does not have "KernelLaunch" or "LaunchTask" keywords
+        if not fwk_launch_op_list and self._jit_level != JitLevel.GRAPH_LEVEL:
+            logger.warning("Cannot find launch op in MindSpore framework.")
             return []
         if (set(acl_to_npu_flow_dict.keys()) != set(fwk_launch_op_list.keys()) and
                 self._context_mode == context.PYNATIVE_MODE):

mindspore/profiler/analysis/parser/timeline_assembly_factory/trace_view_container.py

@@ -15,6 +15,7 @@ from collections import defaultdict
 
 from mindspore.profiler.analysis.parser.timeline_event.timeline_event_pool import TimelineEventPool
 from mindspore.profiler.analysis.parser.timeline_event.base_event import BaseEvent
+from mindspore.profiler.common.constant import ProfilerStepNameConstant, TimelineLayerName
 
 
 class TraceViewContainer:
@@ -82,3 +83,24 @@ class TraceViewContainer:
     def get_all_pools(self) -> List[TimelineEventPool]:
         """Get all event pools."""
         return list(self.event_pools.values())
+
+    def get_step_id_time_dict(self) -> Dict:
+        """Get step id to time dict."""
+        # Retrieve all events from the trace container for the Mindspore timeline layer
+
+        mindspore_pool = self.get_pool_by_name(TimelineLayerName.MINDSPORE.value)
+        if not mindspore_pool:
+            return {}
+
+        events = mindspore_pool.get_all_events()
+
+        # Filter events that contain "ProfilerStep" and create a dictionary mapping (start_ts, end_ts) to step ID
+        step_id_to_time_dict = dict(sorted(
+            (
+                event.name.split("#")[-1], (event.ts, event.dur + event.ts)
+            )
+            for event in events
+            if ProfilerStepNameConstant.PROFILER_STEP in event.name
+        ))
+
+        return step_id_to_time_dict

mindspore/profiler/analysis/parser/timeline_creator/fwk_timeline_creator.py

@@ -43,10 +43,10 @@ class FwkTimelineCreator(BaseTimelineCreator):
     def _create_base_events(self, pool: TimelineEventPool, fwk_tlv_data: List[Dict]) -> None:
         """Create base events from framework TLV data."""
         for data in fwk_tlv_data:
-            if data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.START_NS.value] == 0:  # Filter abnormal data
+            if data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.START_TIME_NS.value] == 0:  # Filter abnormal data
                 continue
-            if (data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.START_NS.value] ==
-                    data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.END_NS.value]):  # dur == 0
+            if (data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.START_TIME_NS.value] ==
+                    data[FileConstant.FIX_SIZE_DATA][OpRangeStructField.END_TIME_NS.value]):  # dur == 0
                 event = FwkInstantEvent(data)
             else:
                 event = FwkCompleteEvent(data)

mindspore/profiler/analysis/parser/timeline_event/fwk_event.py

@@ -15,79 +15,235 @@
 """Framework event classes for timeline analysis."""
 from enum import Enum
 from decimal import Decimal
-from typing import Dict, Optional, List, Tuple
+from typing import Dict, Optional, List
 
+from mindspore import log as logger
 from mindspore.profiler.common.constant import EventConstant, FileConstant
 from mindspore.profiler.analysis.time_converter import TimeConverter
 from mindspore.profiler.analysis.parser.timeline_event.base_event import (
     BaseEvent,
     CompleteEvent,
     MetaEvent,
-    InstantEvent
+    InstantEvent,
 )
 
 
+class ProfilerStage(Enum):
+    """Profiler stage enumeration."""
+    DEFAULT = "Default"
+    PYTHON = "Python"
+    CAPTURE = "Capture"
+    RUN_GRAPH = "RunGraph"
+    RUN_GRAD = "RunGrad"
+    RUN_OP = "RunOp"
+    ASNUMPY = "Asnumpy"
+    COMPILE_GRAD_GRAPH = "CompileGradGraph"
+    WAIT_PIPELINE = "WaitPipeline"
+    SYNC_STREAM = "SyncStream"
+
+
+class ProfilerModule(Enum):
+    """Profiler module enumeration."""
+    DEFAULT = "Default"
+    GRAPH_EXECUTOR_PY = "GraphExecutorPy"
+    RUNTIME_FRAMEWORK = "RuntimeFramework"
+    PYNATIVE_FRAMEWORK = "PynativeFramework"
+    KERNEL = "Kernel"
+    PYTHON = "Python"
+    CAPTURE = "Capture"
+    OTHER = "Other"
+
+
+class ProfilerEvent(Enum):
+    """Profiler event enumeration."""
+    DEFAULT = "Default"
+    KERNEL_INFER = "KernelInfer"
+    KERNEL_RESIZE = "KernelResize"
+    KERNEL_INFER_AND_RESIZE = "KernelInferAndResize"
+    KERNEL_LAUNCH = "KernelLaunch"
+    KERNEL_LAUNCH_CALLBACK = "KernelLaunckCallback"
+    KERNEL_UPDATE = "KernelUpdate"
+    KERNEL_PREPARE_DATA = "KernelPrepareData"
+    GRAPH_LAUNCH = "GraphLaunch"
+    INPUT_PROCESS = "InputProcess"
+    OUTPUT_PROCESS = "OutputProcess"
+    WAIT_TASK_FINISH = "WaitTaskFinish"
+    PRE_LAUNCH = "PreLaunch"
+    POST_LAUNCH = "PostLaunch"
+    SEND_OUTPUT = "SendOutput"
+    MEMORY_ALLOC = "MemoryAlloc"
+    MEMORY_FREE = "MemoryFree"
+    COPY_DATA = "CopyData"
+    STREAM_SYNC = "StreamSync"
+    PROCESS_MULTI_STREAM = "ProcessMultiStream"
+    WAIT_KERNELS_INFER_FINISH = "WaitKernelsInferFinish"
+    WAIT_KERNELS_RESIZE_FINISH = "WaitKernelsResizeFinish"
+    WAIT_KERNELS_LAUNCH_FINISH = "WaitKernelsLaunchFinish"
+    # Inner event is not counted in the total time.
+    KERNEL_INFER_INNER = "KernelInferInner"
+    KERNEL_INFER_DATA_SYNC = "KernelInferDataSync"
+    KERNEL_RESIZE_INNER = "KernelResizeInner"
+    KERNEL_LAUNCH_INNER = "KernelLaunchInner"
+    BACKEND_GRAPH_RUN_INNER = "BackendGraphRunInner"
+    # PyNative Pipeline
+    RUN_OP = "RunOp"
+    PYNATIVE_FRONTEND_TASK = "PyNativeFrontendTask"
+    PYNATIVE_BACKEND_TASK = "PyNativeBackendTask"
+    PYNATIVE_DEVICE_TASK = "PyNativeDeviceTask"
+    PYNATIVE_LAUNCH_TASK = "PyNativeLaunchTask"
+    PYNATIVE_BPROP_TASK = "PyNativeBpropTask"
+    WAIT = "Wait"
+    # PyNative inner Event
+    PYNATIVE_GIL_ACQUIRE = "PyNativeGilAcquire"
+    PYNATIVE_CAST = "PyNativeCast"
+    PYNATIVE_INFER = "PyNativeInfer"
+    PYNATIVE_OP_COMPILE = "PyNativeOpCompile"
+    PYNATIVE_GRAD_EXPANDER = "PyNativeGradExpander"
+    PYNATIVE_GRAD_UPDATE_SENS = "PyNativeGradUpdateSens"
+    PYNATIVE_GRAD_CLEAR_TOP_CELL = "PyNativeGradClearTopCell"
+    PYNATIVE_GRAD_CLEAR_AUTO_GRAD_CELL = "PyNativeGradClearAutoGradCell"
+    # PyBoost
+    PYBOOST_INFER_OUTPUT = "PyBoostInferOutput"
+    PYBOOST_INFER_BY_OP_DEF = "PyBoostInferByOpDef"
+    PYBOOST_CREATE_OUTPUT_TENSOR = "PyBoostCreateOutputTensor"
+    PYBOOST_DEVICE_TASK = "PyBoostDeviceTask"
+    PYBOOST_MALLOC_INPUT = "PyBoostMallocInput"
+    PYBOOST_MALLOC_OUTPUT = "PyBoostMallocOutput"
+    PYBOOST_LAUNCH_ACLLNN = "PyBoostLaunchAclnn"
+    # pybind api
+    PYNATIVE_NEW_GRAPH = "PyNativeNewGraph"
+    PYNATIVE_END_GRAPH = "PyNativeEndGraph"
+    # Python
+    PYTHON_OBSERVED = "PythonObserved"
+    # Capture Event
+    CAPTURE_RUN_GRAPH = "CaptureRunGraph"
+    CAPTURE_PROCESS = "CaptureProcess"
+    CAPTURE_COMPILE = "CaptureCompile"
+    CAPTURE_GUARD = "CaptureGuard"
+    # AclNN
+    ACLNN_HIT_CACHE_STAGE_1 = "AclnnHitCacheStage1"
+    ACLNN_HIT_CACHE_STAGE_2 = "AclnnHitCacheStage2"
+    ACLNN_MISS_CACHE_STAGE_1 = "AclnnMissCacheStage1"
+    ACLNN_MISS_CACHE_STAGE_2 = "AclnnMissCacheStage2"
+    ACLNN_UPDATE_ADDRESS = "AclnnUpdateAddress"
+    ACLNN_RUN_OP = "AclnnRunOp"
+    # NoGraph grad
+    RUN_EXPANDER_FUNC = "RunExpanderFunc"
+    EMIT_OP = "EmitOp"
+    EXECUTE = "Execute"
+    RELEASE_RESOURCE = "ReleaseResource"
+    NATIVE_FUNC = "NativeFunc"
+
+
 class FwkFixSizeFormat:
     """Format definition for framework fixed-size data."""
 
-    # Fixed size data format: 3 long long (q) + 6 unsigned long long (Q) + bool (?) + padding (b)
-    OpRangeStruct = "<3q6Qb?"
+    OpRangeStruct = "<5Qi3Hb3?"
 
 
 class OpRangeStructField(Enum):
     """Field indices in operator range structure fixed-size data."""
-    START_NS = 0
-    END_NS = 1
-    SEQUENCE_NUMBER = 2
-    PROCESS_ID = 3
-    START_THREAD_ID = 4
-    END_THREAD_ID = 5
-    FORWARD_THREAD_ID = 6
-    ID = 7
-    STEP_ID = 8
+
+    THREAD_ID = 0
+    FLOW_ID = 1
+    STEP = 2
+    START_TIME_NS = 3
+    END_TIME_NS = 4
+    PROCESS_ID = 5
+    MODULE_INDEX = 6
+    EVENT_INDEX = 7
+    STAGE_INDEX = 8
     LEVEL = 9
-    IS_ASYNC = 10
-
-
-class FwkArgsDecoder:
-    """Decoder for framework event arguments in TLV (Type-Length-Value) format."""
-    TLV_TYPES = {
-        EventConstant.OP_NAME: 3,
-        EventConstant.INPUT_SHAPES: 5,
-        EventConstant.INPUT_DTYPES: 4,
-        EventConstant.CALL_STACK: 6,
-        EventConstant.MODULE_HIERARCHY: 7,
-        EventConstant.FLOPS: 8,
-        EventConstant.CUSTOM_INFO: 9
-    }
-
-    @classmethod
-    def decode(cls, origin_data: Dict, fix_size_data: Tuple) -> Dict:
-        """Decode event arguments from raw data."""
-        args = {
-            EventConstant.SEQUENCE_NUMBER: int(fix_size_data[OpRangeStructField.SEQUENCE_NUMBER.value]),
-            EventConstant.FORWARD_THREAD_ID: int(fix_size_data[OpRangeStructField.FORWARD_THREAD_ID.value])
-        }
-
-        for field_name, type_id in cls.TLV_TYPES.items():
-            if field_name == EventConstant.OP_NAME or type_id not in origin_data:
-                continue
-            value = origin_data.get(type_id)
-            if field_name in {EventConstant.INPUT_SHAPES, EventConstant.INPUT_DTYPES, EventConstant.CALL_STACK}:
-                args[field_name] = value.replace("|", "\r\n")
-            elif field_name == EventConstant.CUSTOM_INFO and value:
-                pairs = [pair.split(':') for pair in value.split(';') if pair]
-                info_dict = {k: v for k, v in pairs[0:2] if len(pairs) >= 2}
-                args[field_name] = info_dict
-            else:
-                args[field_name] = value
-
-        return args
-
-
-class FwkCompleteEvent(CompleteEvent):
+    IS_GRAPH_DATA = 10
+    IS_STAGE = 11
+    IS_STACK = 12
+    NAME = 13
+    FULL_NAME = 14
+    MODULE_GRAPH = 15
+    EVENT_GRAPH = 16
+    CUSTOM_INFO = 17
+
+
+class FwkProfileDataField:
+    """Framework profile data field."""
+
+    @staticmethod
+    def _get_enum_value(enum_class, index: int, enum_type: str) -> str:
+        """
+        Get enum value by index.
+        Args:
+            enum_class: The enum class to get value from.
+            index: The index of the enum value.
+            enum_type: The type name of enum for logging.
+        Returns:
+            The enum value string.
+        """
+        try:
+            return list(enum_class)[index].value
+        except IndexError:
+            logger.warning(f"Invalid {enum_type} index: {index}")
+            return enum_class.DEFAULT.value
+
+    @staticmethod
+    def get_stage_value(index: int) -> str:
+        """Get stage value."""
+        return FwkProfileDataField._get_enum_value(ProfilerStage, index, "stage")
+
+    @staticmethod
+    def get_module_value(index: int) -> str:
+        """Get module value."""
+        return FwkProfileDataField._get_enum_value(ProfilerModule, index, "module")
+
+    @staticmethod
+    def get_event_value(index: int) -> str:
+        """Get event value."""
+        return FwkProfileDataField._get_enum_value(ProfilerEvent, index, "event")
+
+
+class FwkEventMixin:
+    """Mixin class for common framework event functionality."""
+
+    def get_name(self) -> str:
+        """Get operator name."""
+        op_name = self._origin_data.get(OpRangeStructField.NAME.value, "")
+        is_stack = self.fix_size_data[OpRangeStructField.IS_STACK.value]
+        if is_stack:
+            return op_name
+
+        is_graph_data = self.fix_size_data[OpRangeStructField.IS_GRAPH_DATA.value]
+        is_stage = self.fix_size_data[OpRangeStructField.IS_STAGE.value]
+        full_name = self._origin_data.get(OpRangeStructField.FULL_NAME.value, "")
+
+        name = ""
+        if is_graph_data:
+            module_graph = self._origin_data.get(OpRangeStructField.MODULE_GRAPH.value, "")
+            event_graph = self._origin_data.get(OpRangeStructField.EVENT_GRAPH.value, "")
+            name = f"{module_graph}::{event_graph}::{op_name}"
+        elif is_stage:
+            stage_index = self.fix_size_data[OpRangeStructField.STAGE_INDEX.value]
+            name = FwkProfileDataField.get_stage_value(stage_index)
+        elif op_name != "flow":
+            module_index = self.fix_size_data[OpRangeStructField.MODULE_INDEX.value]
+            event_index = self.fix_size_data[OpRangeStructField.EVENT_INDEX.value]
+            module_name = FwkProfileDataField.get_module_value(module_index)
+            event_name = FwkProfileDataField.get_event_value(event_index)
+            name = f"{module_name}::{event_name}::{full_name}"
+        else:
+            name = full_name
+        return name
+
+    def get_custom_info(self) -> str:
+        """Get custom information."""
+        value = self._origin_data.get(OpRangeStructField.CUSTOM_INFO.value, None)
+        if value is None:
+            return ""
+        pairs = [pair.split(":") for pair in value.split(";") if pair]
+        info_dict = {k: v for k, v in pairs[0:2] if len(pairs) >= 2}
+        return str(info_dict)
+
+
+class FwkCompleteEvent(FwkEventMixin, CompleteEvent):
     """Framework complete event with duration."""
-    _args_decoder = FwkArgsDecoder()
 
     def __init__(self, data: Dict):
         """Initialize framework complete event."""
@@ -96,7 +252,7 @@ class FwkCompleteEvent(CompleteEvent):
         self._ts_cache = None
         self._te_cache = None
         self._dur_cache = None
-        self._args_cache = {}
+        self._name_cache = None
         self._parent: Optional[BaseEvent] = None
         self._children: List[BaseEvent] = []
 
@@ -118,14 +274,14 @@ class FwkCompleteEvent(CompleteEvent):
     @property
     def ts_raw(self) -> int:
         """Get raw start timestamp."""
-        return self.fix_size_data[OpRangeStructField.START_NS.value]
+        return self.fix_size_data[OpRangeStructField.START_TIME_NS.value]
 
     @property
     def ts(self) -> Decimal:
         """Get start time in us."""
         if not self._ts_cache:
             self._ts_cache = TimeConverter.convert_syscnt_to_timestamp_us(
-                self.fix_size_data[OpRangeStructField.START_NS.value]
+                self.fix_size_data[OpRangeStructField.START_TIME_NS.value]
             )
         return self._ts_cache
 
@@ -134,7 +290,7 @@ class FwkCompleteEvent(CompleteEvent):
         """Get end time in us."""
         if not self._te_cache:
             self._te_cache = TimeConverter.convert_syscnt_to_timestamp_us(
-                self.fix_size_data[OpRangeStructField.END_NS.value]
+                self.fix_size_data[OpRangeStructField.END_TIME_NS.value]
             )
         return self._te_cache
 
@@ -153,63 +309,67 @@ class FwkCompleteEvent(CompleteEvent):
     @property
     def tid(self) -> int:
         """Get thread ID."""
-        return int(self.fix_size_data[OpRangeStructField.START_THREAD_ID.value])
+        return int(self.fix_size_data[OpRangeStructField.THREAD_ID.value])
 
     @property
     def id(self) -> int:
         """Get event ID."""
-        return int(self.fix_size_data[OpRangeStructField.ID.value])
+        return int(self.fix_size_data[OpRangeStructField.FLOW_ID.value])
 
     @property
     def name(self) -> str:
         """Get operator name."""
-        return str(self._origin_data.get(self._args_decoder.TLV_TYPES.get(EventConstant.OP_NAME), ""))
+        if not self._name_cache:
+            self._name_cache = self.get_name()
+        return self._name_cache
 
     @property
     def step(self) -> int:
         """Get step ID."""
-        return int(self.fix_size_data[OpRangeStructField.STEP_ID.value])
+        return int(self.fix_size_data[OpRangeStructField.STEP.value])
+
+    @property
+    def is_stack(self) -> bool:
+        """Get is stack."""
+        return bool(self.fix_size_data[OpRangeStructField.IS_STACK.value])
+
+    @property
+    def cat(self) -> str:
+        """Get event category."""
+        return EventConstant.STACK_EVENT_CAT if self.is_stack else ""
 
     @property
     def level(self) -> int:
         """Get event level."""
         return int(self.fix_size_data[OpRangeStructField.LEVEL.value])
 
-    @property
-    def args(self) -> Dict:
-        """Get decoded event arguments."""
-        if not self._args_cache:
-            self._args_cache = self._args_decoder.decode(self._origin_data, self.fix_size_data)
-        return self._args_cache
-
     @property
     def custom_info(self) -> str:
         """Get custom information."""
-        return str(self.args.get(EventConstant.CUSTOM_INFO, ''))
+        return self.get_custom_info()
 
 
-class FwkInstantEvent(InstantEvent):
+class FwkInstantEvent(FwkEventMixin, InstantEvent):
     """Framework instant event without duration."""
-    _args_decoder = FwkArgsDecoder()
 
     def __init__(self, data: Dict):
         """Initialize framework instant event."""
         super().__init__(data)
         self.fix_size_data = self._origin_data[FileConstant.FIX_SIZE_DATA]
         self._ts_cache = None
-        self._args_cache = {}
+        self._name_cache = None
 
     @property
     def ts_raw(self) -> int:
         """Get raw start timestamp."""
-        return self.fix_size_data[OpRangeStructField.START_NS.value]
+        return self.fix_size_data[OpRangeStructField.START_TIME_NS.value]
 
     @property
     def ts(self) -> Decimal:
         """Get time in us."""
         if not self._ts_cache:
             self._ts_cache = TimeConverter.convert_syscnt_to_timestamp_us(
-                self.fix_size_data[OpRangeStructField.START_NS.value]
+                self.fix_size_data[OpRangeStructField.START_TIME_NS.value]
             )
         return self._ts_cache
 
@@ -221,34 +381,29 @@ class FwkInstantEvent(InstantEvent):
     @property
     def tid(self) -> int:
         """Get thread ID."""
-        return int(self.fix_size_data[OpRangeStructField.START_THREAD_ID.value])
+        return int(self.fix_size_data[OpRangeStructField.THREAD_ID.value])
 
     @property
     def name(self) -> str:
         """Get operator name."""
-        return str(self._origin_data.get(self._args_decoder.TLV_TYPES.get(EventConstant.OP_NAME), ""))
+        if not self._name_cache:
+            self._name_cache = self.get_name()
+        return self._name_cache
 
     @property
     def step(self) -> int:
         """Get step ID."""
-        return int(self.fix_size_data[OpRangeStructField.STEP_ID.value])
+        return int(self.fix_size_data[OpRangeStructField.STEP.value])
 
     @property
     def level(self) -> int:
         """Get event level."""
         return int(self.fix_size_data[OpRangeStructField.LEVEL.value])
 
-    @property
-    def args(self) -> Dict:
-        """Get decoded event arguments."""
-        if not self._args_cache:
-            self._args_cache = self._args_decoder.decode(self._origin_data, self.fix_size_data)
-        return self._args_cache
-
     @property
     def custom_info(self) -> str:
         """Get custom information."""
-        return str(self.args.get(EventConstant.CUSTOM_INFO, ''))
+        return self.get_custom_info()
 
 
 class FwkMetaEvent(MetaEvent):