mindspore 2.2.11__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc1__cp37-cp37m-manylinux1_x86_64.whl

mindspore/parallel/parameter_broadcast.py

@@ -0,0 +1,152 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Parameter broadcast"""
+from __future__ import absolute_import
+
+__all__ = ["parameter_broadcast"]
+
+import numpy as np
+
+
+def parameter_broadcast(net, layout, cur_rank=0, initial_rank=0):
+    """
+    Broadcast parameter to other rank in data parallel dimension.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        net (Cell): The network where the parameters will be broadcasted.
+        layout (Dict): Parameter layout dictionary. Come from
+            :func:`mindspore.nn.Cell.parameter_layout_dict`
+            or read from file(for example: "strategy.ckpt" saved by using the
+            `strategy_ckpt_config` parameter of :func:`mindspore.set_auto_parallel_context`).
+            The key is param name, the value is the layout of this parameter.
+        cur_rank (int, optional): current rank id. Default: ``0``.
+        initial_rank (int, optional): Start rank id for each pipeline. Default: ``0``.
+
+    Raises:
+        ValueError: `cur_rank` is not rank id of current rank.
+        ValueError: `initial_rank` is not the start rank id of current pipeline stage.
+        ValueError: Parameter name in `layout` can not be found in
+            :func:`mindspore.nn.Cell.parameters_dict`.
+
+    Examples:
+        >>> import os
+        >>> import mindspore as ms
+        >>> import mindspore.dataset as ds
+        >>> from mindspore import nn, ops
+        >>> from mindspore.communication import init
+        >>> from mindspore.common.initializer import initializer
+        >>> from mindspore.train import Model
+        >>> from mindspore.parallel.parameter_broadcast import parameter_broadcast
+        >>> from mindspore.train.serialization import load_checkpoint, load_param_into_net
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> ms.set_context(max_device_memory="28GB")
+        >>> ms.set_auto_parallel_context(parallel_mode=ms.ParallelMode.SEMI_AUTO_PARALLEL)
+        >>> init()
+        >>> ms.set_seed(1)
+        >>> class Network(nn.Cell):
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.flatten = ops.Flatten()
+        ...         self.fc1_weight = ms.Parameter(initializer("normal", [28*28, 512], ms.float32))
+        ...         self.fc2_weight = ms.Parameter(initializer("normal", [512, 512], ms.float32))
+        ...         self.fc3_weight = ms.Parameter(initializer("normal", [512, 10], ms.float32))
+        ...         self.matmul1 = ops.MatMul()
+        ...         self.relu1 = ops.ReLU()
+        ...         self.matmul2 = ops.MatMul()
+        ...         self.relu2 = ops.ReLU()
+        ...         self.matmul3 = ops.MatMul()
+        ...     def construct(self, x):
+        ...         x = self.flatten(x)
+        ...         x = self.matmul1(x, self.fc1_weight)
+        ...         x = self.relu1(x)
+        ...         x = self.matmul2(x, self.fc2_weight)
+        ...         x = self.relu2(x)
+        ...         logits = self.matmul3(x, self.fc3_weight)
+        ...         return logits
+        >>> net = Network()
+        >>> net.matmul1.shard(((2, 4), (4, 1)))
+        >>> net.relu1.shard(((4, 1),))
+        >>> net.matmul2.shard(((1, 8), (8, 1)))
+        >>> net.relu2.shard(((8, 1),))
+        >>> # Create the dataset taking MNIST as an example. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/mnist.py
+        >>> dataset = create_dataset()
+        >>> optim = nn.SGD(net.trainable_params(), 1e-2)
+        >>> loss = nn.CrossEntropyLoss()
+        >>> model = Model(net, loss_fn=loss, optimizer=optim)
+        >>> model.train(1, dataset)
+        >>> ms.save_checkpoint(net, "./simple.ckpt", False)
+        >>> layout = model.train_network.parameter_layout_dict
+        >>> param_dict = load_checkpoint("./simple.ckpt")
+        >>> load_param_into_net(net, param_dict)
+        >>> rank_id = os.environ["RANK_ID"]
+        >>> parameter_broadcast(model.train_network, layout, int(rank_id), 0)
+        >>> class LossCallBack(Callback):
+        ...     def step_end(self, run_context):
+        ...         cb_params = run_context.original_args()
+        ...         print("step end, cur step num: ", cb_params.cur_step_num, flush=True)
+        >>> model.train(1, dataset, callbacks=[LossCallBack()])
+    """
+    if not layout:
+        return
+    import mindspore as ms
+    from mindspore import Tensor
+    from mindspore.communication import get_rank, create_group, get_group_size
+    from mindspore.train._utils import get_parameter_redundancy, remove_param_redundancy
+    from mindspore.nn.wrap.cell_wrapper import AllreduceGraph
+    origin_parallel_mode = ms.get_auto_parallel_context("parallel_mode")
+    if origin_parallel_mode not in ("semi_auto_parallel", "auto_parallel"):
+        return
+    if cur_rank != get_rank():
+        raise ValueError(f"For parameter broadcast, the cur_rank: {cur_rank} is wrong.")
+    if initial_rank % (get_group_size() / ms.get_auto_parallel_context("pipeline_stages")) != 0:
+        raise ValueError(f"For parameter broadcast, the initial_rank: {initial_rank} is wrong.")
+    param_redundancy = get_parameter_redundancy(layout, initial_rank)
+    if not param_redundancy:
+        return
+    single_params = remove_param_redundancy(param_redundancy)
+    if not single_params:
+        return
+    param_redundancy_reversed = {}
+    for key, redundancy in param_redundancy.items():
+        for item in redundancy:
+            if len(item) == 1:
+                continue
+            if cur_rank in item:
+                param_redundancy_reversed.setdefault(item, []).append(key)
+    if not param_redundancy_reversed:
+        return
+    if not cur_rank not in single_params:
+        return
+    net_param_dict = net.parameters_dict()
+    ms.set_auto_parallel_context(parallel_mode="hybrid_parallel")
+    for group, params in param_redundancy_reversed.items():
+        create_group(str(group), list(group))
+        allreduce_input = []
+        for param in params:
+            if param not in net_param_dict:
+                raise ValueError("For parameter broadcast, the param: {param} can not be found.")
+            real_param = net_param_dict[param]
+            if param not in single_params[cur_rank]:
+                real_param.set_data(Tensor(np.zeros(real_param.shape), dtype=real_param.dtype))
+            allreduce_input.append(real_param)
+        if not allreduce_input:
+            continue
+        allreduce_graph = AllreduceGraph(allreduce_input, str(group))
+        allreduce_graph()
+    ms.set_auto_parallel_context(parallel_mode=origin_parallel_mode)

mindspore/parallel/shard.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -14,11 +14,108 @@
 # ============================================================================
 """pynative shard"""
 
+import copy
 import mindspore as ms
 from mindspore import log as logger
 from mindspore._c_expression import Shard_
 
 
+class Layout():
+    """
+    Parallel layout describes the detailed sharding information.
+
+    Note:
+        - It is valid only in semi auto parallel or auto parallel mode.
+        - The multiplication result of the `device_matrix` must be equal to the device count in a pipeline stage.
+        - When the layout function is invoked to constructs a sharding strategy, each alias name is only allowed to be
+          used once to shard a tensor.
+
+    Args:
+        device_matrix (tuple): Describe the shape of devices arrangement, its element type is int.
+        alias_name (tuple): The alias name for each axis of device_matrix, its length shoits element type is string.
+
+    Raises:
+        TypeError: `device_matrix` is not a tuple type.
+        TypeError: `alias_name` is not a tuple type.
+        ValueError: `device_matrix` length is not equal to `alias_name` length.
+        TypeError: The element of `device_matrix` is not int type.
+        TypeError: The element of `alias_name` is not a str type.
+        ValueError: The element of `alias_name` is an empty str.
+        ValueError: The element of `alias_name` is "None".
+        ValueError: `alias_name` contains repeated element.
+
+    Examples:
+        >>> from mindspore import Layout
+        >>> layout = Layout((2, 2, 2), ("dp", "sp", "mp"))
+        >>> layout0 = layout("dp", "mp")
+        >>> print(layout0.to_dict())
+        {"device_matrix": (2, 2, 2), "tensor_map": (2, 0)}
+    """
+
+    def __init__(self, device_matrix, alias_name):
+        if not isinstance(device_matrix, tuple):
+            raise TypeError(f'device_matrix must be tuple type, but got:{type(device_matrix)}')
+        if not isinstance(alias_name, tuple):
+            raise TypeError(f'alias_name must be tuple type, but got:{type(alias_name)}')
+        if len(device_matrix) != len(alias_name):
+            raise ValueError(f'device_matrix length should be equal to alias_name length')
+        for in_ele in device_matrix:
+            if not isinstance(in_ele, int):
+                raise TypeError(f'The element of device_matrix must be int type, but got:{type(in_ele)}')
+        for in_ele in alias_name:
+            if not isinstance(in_ele, str):
+                raise TypeError(f'The element of alias_name must be str type, but got:{type(in_ele)}')
+            if not in_ele:
+                raise ValueError(f"The element of alias_name can not be empty.")
+            if in_ele == "None":
+                raise ValueError(f"The element of alias_name can not set 'None', because 'None' means no sharding.")
+        if len(set(alias_name)) != len(alias_name):
+            raise ValueError(f'Each element of alias_name {alias_name} should be different')
+        self._device_shape = device_matrix
+        self._alias_name = alias_name
+        self._tensor_map = None
+
+    def __call__(self, *tensor_map):
+        self._tensor_map = ()
+        writed_map = ()
+        for ele in tensor_map:
+            if isinstance(ele, tuple):
+                ele_map = ()
+                for item in ele:
+                    if item == "None":
+                        ele_map += (-1,)
+                        continue
+                    if item not in self._alias_name:
+                        raise ValueError(f'The axis {item} is not found in {self._alias_name}')
+                    if item in writed_map:
+                        raise ValueError(f'The axis {item} has been set more than one in {self._alias_name}')
+                    ele_map += (len(self._alias_name) - 1 - self._alias_name.index(item),)
+                    writed_map += (item,)
+                self._tensor_map += (ele_map,)
+                continue
+            if ele == "None":
+                self._tensor_map += (-1,)
+                continue
+            if ele not in self._alias_name:
+                raise ValueError(f'The axis {ele} is not found in {self._alias_name}')
+            if ele in writed_map:
+                raise ValueError(f'The axis {ele} has been set more than one in {self._alias_name}')
+            self._tensor_map += (len(self._alias_name) - 1 - self._alias_name.index(ele),)
+            writed_map += (ele,)
+        return copy.deepcopy(self)
+
+    def to_dict(self):
+        """
+        Transform layout to a dictionary.
+        """
+        if self._device_shape is None:
+            raise ValueError("The device_shape of layout is None")
+        if self._tensor_map is None:
+            raise ValueError("The tensor_map of layout is None")
+        return {"device_matrix": self._device_shape, "tensor_map": self._tensor_map}
+
+
+
 class Shard(Shard_):
     """Shard operation"""
 
@@ -231,7 +328,7 @@ def shard(fn, in_strategy, out_strategy=None, parameter_plan=None, device="Ascen
 
     Tutorial Examples:
         - `Functional Operator Sharding
-          <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/pynative_shard_function_parallel.html>`_
+          <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/parallel/pynative_shard_function_parallel.html>`_
     """
     if not isinstance(fn, (ms.nn.Cell)):
         logger.warning("'fn' is not a mindspore.nn.Cell, and its definition cannot involve Parameter; "

mindspore/profiler/common/util.py

@@ -317,3 +317,23 @@ def get_options(options):
 def combine_stream_task_id(stream_id, task_id):
     """Combine Stream ID and task ID into unique values."""
     return f'{stream_id}_{task_id}'
+
+
+def get_newest_file(file_list):
+    '''
+    Find the newest files
+    :param file_list:
+    :return:
+    '''
+    newest_file_list = []
+    newest_timestamp = '0'
+    for file_path in file_list:
+        timestamp = file_path.split('.')[0].split('/')[-1].split('_')[-1]
+        newest_timestamp = max(timestamp, newest_timestamp)
+
+    for file_path in file_list:
+        if file_path.split('.')[0].split('/')[-1].split('_')[-1] == newest_timestamp:
+            newest_file_list.append(file_path)
+
+    newest_file_list.sort()
+    return newest_file_list

mindspore/profiler/envprofiling.py

@@ -68,7 +68,7 @@ def construct_profiling_options():
         logger.error(
             "The format of MS_PROFILER_OPTIONS is incorrect. "
             "The MS_PROFILER_OPTIONS parameter configuration may refer to "
-            "'https://www.mindspore.cn/mindinsight/docs/zh-CN/r2.2/performance_profiling_ascend.html'."
+            "'https://www.mindspore.cn/mindinsight/docs/zh-CN/master/performance_profiling_ascend.html'."
         )
         return error_config
     conbine_options = combine_profile_options(profiling_options)

mindspore/{_extends/parallel_compile/tbe_compiler → profiler/parser/ascend_analysis}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

mindspore/profiler/parser/ascend_analysis/constant.py

@@ -0,0 +1,66 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Constant value for ascend profiling parser."""
+
+
+class Constant:
+    """Constant values"""
+    INVALID_VALUE = -1
+    NULL_VALUE = 0
+
+    # dir name
+    FRAMEWORK_DIR = "FRAMEWORK"
+    OUTPUT_DIR = "ASCEND_PROFILER_OUTPUT"
+
+    # file authority
+    FILE_AUTHORITY = 0o640
+    DIR_AUTHORITY = 0o700
+    MAX_FILE_SIZE = 1024 * 1024 * 1024 * 10
+    MAX_CSV_SIZE = 1024 * 1024 * 1024 * 5
+    MAX_PATH_LENGTH = 4096
+    MAX_WORKER_NAME_LENGTH = 226
+    MAX_FILE_NAME_LENGTH = 255
+    PROF_WARN_SIZE = 1024 * 1024 * 1024
+
+    # tlv constant struct
+    FIX_SIZE_BYTES = "fix_size_bytes"
+    NS_TO_US = 1000
+
+    # field name
+    SEQUENCE_UNMBER = "Sequence number"
+    FORWORD_THREAD_ID = "Fwd thread id"
+    OP_NAME = "op_name"
+    INPUT_SHAPES = "Input Dims"
+    INPUT_DTYPES = "Input type"
+    CALL_STACK = "Call stack"
+    MODULE_HIERARCHY = "Module Hierarchy"
+    FLOPS = "flops"
+    NAME = "name"
+
+    # trace constant
+    PROCESS_NAME = "process_name"
+    PROCESS_LABEL = "process_labels"
+    PROCESS_SORT = "process_sort_index"
+    THREAD_NAME = "thread_name"
+    THREAD_SORT = "thread_sort_index"
+    FLOW_START_PH = "s"
+    FLOW_END_PH = "f"
+
+    ACL_OP_EXE_NAME = ("AscendCL@aclopCompileAndExecute".lower(), "AscendCL@aclopCompileAndExecuteV2".lower())
+    AI_CORE = "AI_CORE"
+
+    # profiler begin info
+    CANN_BEGIN_TIME = "collectionTimeBegin"
+    CANN_BEGIN_MONOTONIC = "clockMonotonicRaw"

mindspore/profiler/parser/ascend_analysis/file_manager.py

@@ -0,0 +1,77 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Profiler file manager"""
+import json
+import os.path
+from typing import List
+
+from mindspore import log as logger
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+
+
+class FileManager:
+    """Profiler file manager"""
+
+    MAX_PATH_LENGTH = 4096
+    MAX_FILE_NAME_LENGTH = 255
+    DATA_FILE_AUTHORITY = 0o640
+    DATA_DIR_AUTHORITY = 0o700
+
+    @classmethod
+    def read_file_content(cls, path: str, mode: str = "r"):
+        """Read the content in the input file."""
+        if not os.access(path, os.R_OK):
+            msg = f"The file {os.path.basename(path)} is not readable!"
+            raise RuntimeError(msg)
+
+        if not os.path.isfile(path):
+            raise RuntimeError(f"The file {os.path.basename(path)} is invalid!")
+        file_size = os.path.getsize(path)
+        if file_size <= 0:
+            return ""
+        if file_size > Constant.MAX_FILE_SIZE:
+            msg = f"File too large file to read: {path}"
+            logger.warning(msg)
+            return ''
+        try:
+            with open(path, mode) as file:
+                return file.read()
+        except Exception as err:
+            raise RuntimeError(f"Failed to read file: {path}") from err
+
+    @classmethod
+    def make_dir_safety(cls, dir_path: str):
+        """Make directory with least authority"""
+        dir_path = validate_and_normalize_path(dir_path)
+
+        if os.path.exists(dir_path):
+            return
+        try:
+            os.makedirs(dir_path, mode=cls.DATA_DIR_AUTHORITY, exist_ok=True)
+        except Exception as err:
+            msg = f"Failed to make directory: {dir_path}"
+            raise RuntimeError(msg) from err
+
+    @classmethod
+    def create_json_file(cls, output_path: str, json_data: List, file_name: str) -> None:
+        """Create json file with least authority"""
+        if not json_data:
+            return
+        cls.make_dir_safety(output_path)
+        file_path = os.path.join(output_path, file_name)
+        flags = os.O_WRONLY | os.O_CREAT
+        with os.fdopen(os.open(file_path, flags, cls.DATA_FILE_AUTHORITY), 'w') as fp:
+            json.dump(json_data, fp, ensure_ascii=False)

mindspore/profiler/parser/ascend_analysis/function_event.py

@@ -0,0 +1,146 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Function event data struct."""
+from typing import Dict, Optional, List
+from enum import Enum
+from decimal import Decimal
+import struct
+from abc import ABC, abstractmethod
+
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.profiler_info_parser import ProfilerInfoParser
+
+
+class BaseEvent(ABC):
+    """Base class of CANNEvent and MindSporeOpEvent"""
+
+    HOST_TO_DEVICE = "HostToDevice"
+    START_FLOW = "s"
+    END_FLOW = "f"
+
+    def __init__(self, data: Dict):
+        if not isinstance(data, dict):
+            raise TypeError("Input data must be dict.")
+        # common attributes
+        self._orig_data = data
+        self.name: str = ""
+        self.pid: int = 0
+        self.tid: int = 0
+        self.ts: Decimal = Decimal(0)
+        self.end_us: Decimal = Decimal(0)
+        self.dur: float = 0.0
+        self.args: Dict = {}
+        self.parent: Optional[BaseEvent] = None
+        self.children: List[BaseEvent] = []
+        self._init_params()
+
+    @abstractmethod
+    def _init_params(self):
+        err_msg = "Protected function _init_params need to be implemented."
+        raise NotImplementedError(err_msg)
+
+
+class CANNEvent(BaseEvent):
+    """Function event collected on the CANN side"""
+
+    def __init__(self, data: Dict):
+        self.unique_id = ""
+        self.is_ai_core = False
+        super().__init__(data)
+
+    @property
+    def is_comm_op(self):
+        return self.name.startswith("hcom_")
+
+    def _init_params(self):
+        """Initialize the attribute value of CANNEvent."""
+        self.ts = Decimal(str(self._orig_data.get("ts", 0)))
+        self.pid = self._orig_data.get("pid", 0)
+        self.tid = self._orig_data.get("tid", 0)
+        self.dur = self._orig_data.get("dur", 0.0)
+        self.end_us = self.ts + Decimal(str(self.dur))
+        self.name = self._orig_data.get("name", "")
+        self.id = self._orig_data.get("id", 0)
+        self.args = self._orig_data.get("args", {})
+        self.unique_id = f"{self.pid}-{self.tid}-{str(self.ts)}"
+        self.is_ai_core = self.args.get("Task Type") == Constant.AI_CORE
+
+    def is_flow_start_event(self) -> bool:
+        """Determine whether the event is flow start event or not."""
+        return self._orig_data.get("cat") == self.HOST_TO_DEVICE and \
+            self._orig_data.get("ph") == self.START_FLOW
+
+    def is_flow_end_event(self) -> bool:
+        """Determine whether the event is flow end event or not."""
+        return self._orig_data.get("cat") == self.HOST_TO_DEVICE and \
+            self._orig_data.get("ph") == self.END_FLOW
+
+    def is_x_event(self) -> bool:
+        """Determine whether the event x event or not."""
+        return self._orig_data.get("ph") == "X"
+
+
+class MindSporeOpEnum(Enum):
+    START_NS = 0
+    END_NS = 1
+    SEQUENCE_UNMBER = 2
+    PROCESS_ID = 3
+    START_THREAD_ID = 4
+    END_THREAD_ID = 5
+    FORWORD_THREAD_ID = 6
+    IS_ASYNC = 7
+
+
+class MindSporeOpEvent(BaseEvent):
+    """
+    Function event collected on the mindspore frame side.
+
+    Args:
+        data(Dict): The mindspore frame side data decoded by TLVDecoder.
+    """
+    _tlv_type_dict = {
+        Constant.OP_NAME: 3, Constant.INPUT_SHAPES: 5, Constant.INPUT_DTYPES: 4,
+        Constant.CALL_STACK: 6, Constant.MODULE_HIERARCHY: 7, Constant.FLOPS: 8
+    }
+    _fix_data_format = "<3q4Q?"
+
+    def __init__(self, data: Dict):
+        self.is_mindspore_op = True
+        super().__init__(data)
+
+    def _init_params(self):
+        """Initialize the attribute value of MindSporeOpEvent."""
+        fix_size_data = struct.unpack(self._fix_data_format, self._orig_data.get(Constant.FIX_SIZE_BYTES))
+        self.pid = int(fix_size_data[MindSporeOpEnum.PROCESS_ID.value])
+        self.tid = int(fix_size_data[MindSporeOpEnum.START_THREAD_ID.value])
+        self.name = str(self._orig_data.get(self._tlv_type_dict.get(Constant.OP_NAME), ""))
+        self.ts = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.START_NS.value])
+        self.end_us = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.END_NS.value])
+        self.dur = self.end_us - self.ts
+        self.args = self.__get_args(fix_size_data)
+
+    def __get_args(self, fix_size_data) -> Dict:
+        """Get the rest information saved in args"""
+        args = {
+            Constant.SEQUENCE_UNMBER: int(fix_size_data[MindSporeOpEnum.SEQUENCE_UNMBER.value]),
+            Constant.FORWORD_THREAD_ID: int(fix_size_data[MindSporeOpEnum.FORWORD_THREAD_ID.value])}
+        for type_name, type_id in self._tlv_type_dict.items():
+            if type_name == Constant.OP_NAME or type_id not in self._orig_data.keys():
+                continue
+            if type_name in set([Constant.INPUT_SHAPES, Constant.INPUT_DTYPES, Constant.CALL_STACK]):
+                args[type_name] = self._orig_data.get(type_id).replace(";", ";\r\n")
+            else:
+                args[type_name] = self._orig_data.get(type_id)
+        return args