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

mindspore/profiler/parser/ascend_analysis/fwk_cann_parser.py

@@ -0,0 +1,108 @@
+# 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.
+# ============================================================================
+"""The parser for integrating data from the framework side and CANN side."""
+from collections import defaultdict
+from typing import List, Tuple, Optional
+from decimal import Decimal
+
+from mindspore import log as logger
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent, MindSporeOpEvent
+from mindspore.profiler.parser.ascend_analysis.fwk_file_parser import FwkFileParser
+from mindspore.profiler.parser.ascend_analysis.trace_event_manager import TraceEventManager
+from mindspore.profiler.parser.ascend_analysis.msprof_timeline_parser import MsprofTimelineParser
+from mindspore.profiler.parser.ascend_analysis.profiler_info_parser import ProfilerInfoParser
+
+
+class FwkCANNParser:
+    """The top-level trace view parser."""
+
+    _trace_view_save_path = "trace_view_{}.json"
+
+    def __init__(self, source_path: str, msprof_data: List, rank_id: int):
+        source_path = validate_and_normalize_path(source_path)
+        ProfilerInfoParser.init_source_path(source_path)
+        fwk_parser = FwkFileParser(source_path, rank_id)
+        msprof_timeline_parser = MsprofTimelineParser(msprof_data)
+        self._fwk_op_data = fwk_parser.get_op_range_data()
+        self._fwk_trace_data = fwk_parser.get_fwk_trace_data(self._fwk_op_data)
+        self._acl_to_npu = msprof_timeline_parser.get_acl_to_npu_data()
+        self.rank_id: int = rank_id
+        self.kernels: List[CANNEvent] = []
+
+    def generate_trace_data(self):
+        """
+        Generate trace view json timeline file which contains framework side and
+        device side data.
+        """
+        trace_data = self.__link_msop_kernel()
+        return self._fwk_trace_data + trace_data
+
+    def __link_msop_kernel(self) -> List:
+        """Associate the frame-side operator with the device-side kernel"""
+        trace_data = []
+        op_data_by_tid = defaultdict(list)
+        acl_to_npu_by_tid = {}
+        for op_data in self._fwk_op_data:
+            op_data_by_tid[op_data.tid].append(op_data)
+        for (ts, tid), event_list in self._acl_to_npu.items():
+            acl_to_npu_by_tid.setdefault(tid, defaultdict(list))[ts].extend(event_list)
+        if op_data_by_tid.keys() != acl_to_npu_by_tid.keys():
+            logger.warning("Failed to create link between mindspore operator and kernels.")
+
+        for tid in op_data_by_tid:
+            op_idx = 0
+            op_data_sorted = sorted(op_data_by_tid[tid], key=lambda x: x.ts)
+            acl_sorted = sorted(acl_to_npu_by_tid.get(tid, {}).items(), key=lambda x: x[0])
+            for ts, cann_event_list in acl_sorted:
+                op_idx, status = FwkCANNParser.__find_launch_op(ts, op_data_sorted, op_idx)
+                if not status:
+                    continue
+                for cann_event in cann_event_list:
+                    cann_event.parent = op_data_sorted[op_idx]
+                    op_data_sorted[op_idx].children.append(cann_event)
+                    flow_list = TraceEventManager.create_mindspore_to_npu_flow(op_data_sorted[op_idx], cann_event)
+                    self.kernels.append(cann_event)
+                    trace_data += flow_list
+        return trace_data
+
+    @staticmethod
+    def __find_launch_op(ts: Decimal, op_list: List[MindSporeOpEvent],
+                         left: Optional[int] = None, right: Optional[int] = None
+                         ) -> Tuple[int, bool]:
+        """
+        Searching the op_list in [left, right) range and find the operator
+        whose start time is larger than ts and end time is less than ts.
+
+        Args:
+            ts(Decimal): kernel start time
+            op_list(List): MindSporeOpEvent list
+            left & right(int): the searching index range is [left, right)
+
+        Return:
+            Tuple[int, bool]: the first element is the searched index, the second element
+                marks where the operator index is found or not.
+        """
+        left = 0 if (left is None or left < 0) else left
+        right = len(op_list) if (right is None or right < 0) else right
+        # The data in range [left, right) is considered.
+        while right > left:
+            if op_list[left].ts > ts:
+                return left, False
+            if op_list[left].end_us < ts:
+                left += 1
+            else:
+                return left, True
+        return left, False

mindspore/profiler/parser/ascend_analysis/fwk_file_parser.py

@@ -0,0 +1,80 @@
+# 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.
+# ============================================================================
+"""MindSpore framework oprange file parser"""
+
+import os
+from typing import List
+from collections import defaultdict
+
+from mindspore import log as logger
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.file_manager import FileManager
+from mindspore.profiler.parser.ascend_analysis.tlv_decoder import TLVDecoder
+from mindspore.profiler.parser.ascend_analysis.function_event import MindSporeOpEvent
+from mindspore.profiler.parser.ascend_analysis.trace_event_manager import TraceEventManager
+
+
+class FwkFileParser:
+    """Framework-side operator file parser."""
+
+    _op_range = "FRAMEWORK/op_range_{}"
+    _op_range_struct_size = 57
+
+    def __init__(self, source_path: str, rank_id: int):
+        """
+            source_path: The path of PROF_* directory
+        """
+        self.rank_id = rank_id
+        self._op_range_path = None
+        self.__init_framework_path(source_path)
+
+    def get_op_range_data(self) -> List[MindSporeOpEvent]:
+        """Read and decode all the mindspore oprange data."""
+        op_range_list = []
+        if os.path.exists(self._op_range_path):
+            op_range_bytes = FileManager.read_file_content(self._op_range_path, "rb")
+            op_range_list = TLVDecoder.decode(op_range_bytes, MindSporeOpEvent, self._op_range_struct_size)
+        else:
+            logger.error("Failed to find op_range data.")
+        return op_range_list
+
+    def get_fwk_trace_data(self, mindspore_op_data: List[MindSporeOpEvent] = None):
+        """Generate chrome trace format json data from decoded oprange data."""
+        if not mindspore_op_data:
+            mindspore_op_data = self.get_op_range_data()
+        tid_map = defaultdict(list)
+        fwk_x_event_list = [None] * len(mindspore_op_data)
+        index = 0
+
+        for mindspore_op in mindspore_op_data:
+            tid_map[mindspore_op.pid].append(mindspore_op.tid)
+            fwk_x_event_list[index] = TraceEventManager.create_x_event(mindspore_op, "cpu_op")
+            index += 1
+        fwk_m_event_list = []
+        for pid, tid_list in tid_map.items():
+            fwk_m_event_list.extend(TraceEventManager.create_m_event(pid, tid_list))
+        return fwk_x_event_list + fwk_m_event_list
+
+    def __init_framework_path(self, source_path: str):
+        """Init the oprange data path."""
+        source_path = validate_and_normalize_path(source_path)
+        if not os.path.exists(source_path):
+            raise FileNotFoundError("Input source_path does not exist!")
+        device_name = os.path.basename(source_path)
+        if not device_name.startswith("device") and not os.path.isdir(source_path):
+            raise RuntimeError("Input source_path is invalid!")
+        prof_path = os.path.dirname(source_path)
+        prof_root = os.path.dirname(prof_path)
+        self._op_range_path = os.path.join(prof_root, self._op_range.format(self.rank_id))

mindspore/profiler/parser/ascend_analysis/msprof_timeline_parser.py

@@ -0,0 +1,52 @@
+# 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.
+# ============================================================================
+"""msprof timeline file parser"""
+from collections import defaultdict
+from typing import List, Dict, Tuple
+
+from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent
+
+
+class MsprofTimelineParser:
+    """Msprof timeline file parser."""
+
+    ACL_TO_NPU = "acl_to_npu"
+    START_FLOW = "s"
+    END_FLOW = "f"
+    TIMELINE = "timeline"
+
+    def __init__(self, msprof_data: List):
+        self.timeline_data = msprof_data
+
+    def get_acl_to_npu_data(self) -> Dict[Tuple, List[CANNEvent]]:
+        """Get all the acl to npu flow events."""
+        flow_start_dict, flow_end_dict = {}, {}
+        cann_event_list: List[CANNEvent] = []
+        for data in self.timeline_data:
+            cann_event = CANNEvent(data)
+            cann_event_list.append(cann_event)
+            if cann_event.is_flow_start_event():
+                flow_start_dict[cann_event.id] = (cann_event.ts, cann_event.tid)
+            elif cann_event.is_flow_end_event():
+                flow_end_dict[cann_event.unique_id] = cann_event.id
+        acl_to_npu_dict = defaultdict(list)
+        for cann_event in cann_event_list:
+            if not cann_event.is_x_event():
+                continue
+            corr_id = flow_end_dict.get(cann_event.unique_id)
+            acl_ts_tid = flow_start_dict.get(corr_id)
+            if corr_id is not None and acl_ts_tid is not None:
+                acl_to_npu_dict[acl_ts_tid].append(cann_event)
+        return acl_to_npu_dict

mindspore/profiler/parser/ascend_analysis/profiler_info_parser.py

@@ -0,0 +1,104 @@
+# 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 host information parser"""
+import os
+import json
+from decimal import Decimal
+from subprocess import CalledProcessError, TimeoutExpired
+from subprocess import Popen, PIPE
+
+from mindspore import log as logger
+import mindspore._c_expression as c_expression
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+
+
+class ProfilerInfoParser:
+    """Parse files that record information, such as profiler_info.json"""
+
+    _localtime_diff = Decimal(0)
+    _freq = 100.0
+    _time_offset = 0
+    _start_cnt = 0
+    _msprof_cmd = "msprof"
+    _time_out = 1
+    # profiler information related files
+    _source_prof_path = None
+    _loaded_frequency = False
+
+    @classmethod
+    def init_source_path(cls, source_path: str):
+        """initialize the path of PROF_* directory."""
+        source_path = validate_and_normalize_path(source_path)
+        prof_path = os.path.dirname(source_path)
+        dir_name = os.path.basename(source_path)
+        if not dir_name.startswith("device") or not os.path.exists(source_path):
+            raise RuntimeError("Input source path is invalid!")
+        cls._source_prof_path = prof_path
+
+    @classmethod
+    def get_local_time(cls, syscnt: int) -> Decimal:
+        """Convert syscnt to local time."""
+        if not cls._loaded_frequency:
+            localtime_stamp = c_expression.get_clock_time()
+            syscnt_stamp = c_expression.get_clock_syscnt()
+            outs, _ = cls.__run_cmd(['which', cls._msprof_cmd])
+            if not outs:
+                raise FileNotFoundError("Failed to find msprof command!")
+            msprof_path = os.path.realpath(outs.strip())
+            sup_path = msprof_path.split('tools')[0]
+            script_path = os.path.join(sup_path, 'tools/profiler/profiler_tool/analysis/interface/get_msprof_info.py')
+            py_cmd = ['python', script_path, '-dir', os.path.join(cls._source_prof_path, 'host')]
+            outs, _ = cls.__run_cmd(py_cmd)
+            if not outs:
+                raise RuntimeError("Failed to get msprof information!")
+            result = json.loads(outs)
+            cpu_info = result.get('data', {}).get('host_info', {}).get('cpu_info', [{}])[0]
+            try:
+                cls._freq = float(cpu_info.get("Frequency", cls._freq))
+            except ValueError:
+                pass
+            cls._start_cnt = syscnt_stamp
+            cls._time_offset = localtime_stamp
+            cls._loaded_frequency = True
+        start_ns = cls.__get_timestamp(syscnt)
+        start_us = Decimal(start_ns) / Constant.NS_TO_US
+        return start_us
+
+    @classmethod
+    def __run_cmd(cls, cmd):
+        """run shell command"""
+        try:
+            proc = Popen(cmd, stdout=PIPE, stderr=PIPE, text=True)
+        except (FileNotFoundError, PermissionError, CalledProcessError) as exc:
+            raise RuntimeError(exc) from exc
+        try:
+            outs, errs = proc.communicate(timeout=cls._time_out)
+        except TimeoutExpired as err:
+            proc.kill()
+            msg = "The possible cause is that too much data is collected " \
+                  "and the export time is too long."
+            logger.error(msg)
+            raise TimeoutError(msg) from err
+        logger.info(outs)
+        return outs, errs
+
+    @classmethod
+    def __get_timestamp(cls, syscnt: int, time_fmt: int = 1000):
+        """Convert syscnt to time stamp."""
+        ratio = time_fmt / cls._freq
+        # The unit of timestamp is ns
+        timestamp = round((syscnt - cls._start_cnt) * ratio) + cls._time_offset
+        return timestamp

mindspore/profiler/parser/ascend_analysis/tlv_decoder.py

@@ -0,0 +1,86 @@
+# 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.
+# ============================================================================
+"""TLV format file decoder"""
+
+import struct
+from typing import List, Dict, Union
+
+from mindspore import log as logger
+
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.function_event import MindSporeOpEvent
+
+
+class TLVDecoder:
+    """
+    The class of TLV format data decoder.
+
+    Args:
+        all_bytes(bytes): all the bytes data of tlv format binary file.
+        event_class(MindSporeOpEvent): class of events to decode.
+        fix_data_struct_size(int): a constant value.
+
+    Return:
+        List[MindSporeOpEvent]: event list of input event class.
+    """
+    _type_len = 2
+    _length_len = 4
+
+    @classmethod
+    def decode(cls, all_bytes: bytes, event_class: MindSporeOpEvent, fix_data_struct_size: int):
+        """Decode all the data."""
+        result_data = []
+        records = cls.tlv_list_decode(all_bytes)
+        for record in records:
+            if fix_data_struct_size > len(record):
+                logger.warning("The collected data has been lost")
+                continue
+            fix_data_bytes = record[0: fix_data_struct_size]
+            tlv_fields = cls.tlv_list_decode(record[fix_data_struct_size:], is_field=True)
+            tlv_fields[Constant.FIX_SIZE_BYTES] = fix_data_bytes
+            result_data.append(event_class(tlv_fields))
+        return result_data
+
+    @classmethod
+    def tlv_list_decode(cls, tlv_bytes: bytes, is_field: bool = False) -> Union[Dict, List]:
+        """Decode TLV format data."""
+        result_data = {} if is_field else []
+        index = 0
+        all_bytes_len = len(tlv_bytes)
+        while index < all_bytes_len:
+            if index + cls._type_len > all_bytes_len:
+                logger.warning("The collected data has been lost")
+                break
+            type_id = struct.unpack("<H", tlv_bytes[index: index + cls._type_len])[0]
+            index += cls._type_len
+            if index + cls._length_len > all_bytes_len:
+                logger.warning("The collected data has been lost")
+                break
+            value_len = struct.unpack("<I", tlv_bytes[index: index + cls._length_len])[0]
+            index += cls._length_len
+            if index + value_len > all_bytes_len:
+                logger.warning("The collected data has been lost")
+                break
+            value = tlv_bytes[index: index + value_len]
+            index += value_len
+            if is_field:
+                try:
+                    result_data[type_id] = bytes.decode(value)
+                except UnicodeDecodeError:
+                    logger.warning(f"The collected data can't decode by bytes.decode: {value}")
+                    result_data[type_id] = 'N/A'
+            else:
+                result_data.append(value)
+        return result_data

mindspore/profiler/parser/ascend_analysis/trace_event_manager.py

@@ -0,0 +1,59 @@
+# 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.
+# ============================================================================
+"""Json trace event manager"""
+
+from typing import Dict, List
+
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.function_event import BaseEvent
+
+
+class TraceEventManager:
+    """Chrome trace format json object manager."""
+
+    @classmethod
+    def create_x_event(cls, event: BaseEvent, cat: str) -> Dict:
+        """Create a X event."""
+        x_event = {
+            "ph": "X", "name": event.name, "pid": event.pid, "tid": event.tid,
+            "ts": str(event.ts), "dur": str(event.dur), "cat": cat, "args": event.args
+        }
+        return x_event
+
+    @classmethod
+    def create_m_event(cls, pid: int, tid_list: List) -> List:
+        """Create some metadata event."""
+        # framework sidee trace information display format: MindSpore(pid pid_value): CPU
+        event_list = [
+            # process information
+            {"ph": "M", "name": Constant.PROCESS_NAME, "pid": pid, "tid": 0, "args": {"name": "MindSpore"}},
+            {"ph": "M", "name": Constant.PROCESS_LABEL, "pid": pid, "tid": 0, "args": {"labels": "CPU"}},
+            {"ph": "M", "name": Constant.PROCESS_SORT, "pid": pid, "tid": 0, "args": {"sort_index": 0}},
+        ]
+        for tid in tid_list:
+            sort_index = tid
+            event_list.extend(
+                [{"ph": "M", "name": Constant.THREAD_NAME, "pid": pid, "tid": tid, "args": {"name": f"Thread {tid}"}},
+                 {"ph": "M", "name": Constant.THREAD_SORT, "pid": pid, "tid": tid, "args": {"sort_index": sort_index}}])
+        return event_list
+
+    @classmethod
+    def create_mindspore_to_npu_flow(cls, start_event: BaseEvent, end_event: BaseEvent) -> List:
+        """Create flow events link mindspore operator and npu kernel."""
+        flow_id = str(end_event.ts)
+        return [{"ph": "s", "bp": "e", "name": "mindspore_to_npu", "id": flow_id, "pid": start_event.pid,
+                 "tid": start_event.tid, "ts": str(start_event.ts), "cat": "async_npu"},
+                {"ph": "f", "bp": "e", "name": "mindspore_to_npu", "id": flow_id, "pid": end_event.pid,
+                 "tid": end_event.tid, "ts": str(end_event.ts), "cat": "async_npu"}]

mindspore/profiler/parser/ascend_cluster_generator.py

@@ -0,0 +1,116 @@
+# 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.
+# ============================================================================
+"""trace step time analyse model"""
+import csv
+import fnmatch
+import json
+import logging
+import os
+import stat
+
+import numpy as np
+from mindspore.profiler.common.exceptions.exceptions import ProfilerIOException
+
+
+def find_files(directory, pattern):
+    """Find files from the directory"""
+    file_list = []
+    for root, _, file in os.walk(directory):
+        file.sort(key=lambda x: os.path.getctime(os.path.join(directory, x)))
+        for base in file:
+            if fnmatch.fnmatch(base, pattern):
+                filename = os.path.join(root, base)
+                file_list.append(filename)
+    return file_list
+
+
+class AscendClusterGenerator:
+    """Generate step trace time data from msprof*.json"""
+
+    def __init__(self, source_path):
+        self.root_path = source_path
+        self.msprof_data = np.array([])
+        self.step_trace_time = {'Step': None, 'Computing': 0, 'comunNotOverlp': 0, 'Overlapped': 0, 'Communication': 0,
+                                'Free': 0, 'Stage': 0, 'Bubble': 0, 'comunNotOverlpRec': 0}
+        self.msprof_data_df = np.dtype([('name', object), ('ts', float), ('dur', float)])
+        self.trace_step_time_df = np.dtype(
+            [('Step', int), ('Computing', float), ('comunNotOverlp', float), ('Communication', float), ('Free', float),
+             ('Stage', float), ('Bubble', float), ('comunNotOverlpRec', float)])
+        self.title = ['Step', 'Computing', 'Communication(Not Overlapped)', 'Overlapped', 'Communication', 'Free',
+                      'Stage', 'Bubble', 'Communication(Not Overlapped and Exclude Receive)']
+
+    def parse(self):
+        """
+        Analyse msprof json generate cluster data.
+        """
+        self.read_msprof()
+
+        if (not isinstance(self.msprof_data, np.ndarray) or self.msprof_data.shape[0] == 0
+                or not self.msprof_data.tolist()):
+            return
+
+        self.step_trace_time['Computing'] = np.sum(self.msprof_data[self.msprof_data['name'] == 'Computing']['dur'])
+        self.step_trace_time['comunNotOverlp'] = np.sum(
+            self.msprof_data[self.msprof_data['name'] == 'Communication(Not Overlapped)']['dur'])
+        self.step_trace_time['Communication'] = np.sum(
+            self.msprof_data[self.msprof_data['name'] == 'Communication']['dur'])
+        self.step_trace_time['Free'] = np.sum(self.msprof_data[self.msprof_data['name'] == 'Free']['dur'])
+        self.step_trace_time['Bubble'] = np.sum(
+            self.msprof_data[np.char.find(self.msprof_data['name'].astype('str'), '/Receive-op')]['dur'])
+
+        self.step_trace_time['Overlapped'] = self.step_trace_time['Communication'] - self.step_trace_time[
+            'comunNotOverlp']
+        self.step_trace_time['Stage'] = np.max(self.msprof_data['ts'] + self.msprof_data['dur']) - np.min(
+            self.msprof_data['ts']) - self.step_trace_time['Bubble']
+        self.step_trace_time['comunNotOverlpRec'] = self.step_trace_time['comunNotOverlp'] - self.step_trace_time[
+            'Bubble']
+
+    def read_msprof(self):
+        """
+        read msprof json information into memory.
+        """
+        msprof_data = []
+        for file in find_files(self.root_path, "msprof_*.json"):
+            with open(file) as jsonfile:
+                for row in json.load(jsonfile):
+                    name = row.get('name', '')
+                    if name is None:
+                        name = ''
+                    if row.get('name') in ['Computing', 'Communication', 'Communication(Not Overlapped)',
+                                           'Free'] or name.find('/Receive-op'):
+                        ts = row.get('ts', 0)
+                        dur = row.get('dur', 0)
+                        msprof_data.append(tuple([name, ts, dur]))
+        self.msprof_data = np.array(msprof_data, dtype=self.msprof_data_df)
+
+    def write(self, step_trace_time_path):
+        """
+        Write the step trace time csv.
+
+        Args:
+            step_trace_time_path(str): step_trace_time.csv path.
+        """
+        try:
+            with os.fdopen(os.open(step_trace_time_path,
+                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
+                           'w') as step_trace_time:
+                writer = csv.writer(step_trace_time)
+                writer.writerow(self.title)
+                writer.writerow([v for _, v in self.step_trace_time.items()])
+        except (IOError, OSError) as err:
+            logging.critical('Error occurred when write step trace time file: %s', err)
+            raise ProfilerIOException() from err
+        if os.path.exists(step_trace_time_path):
+            os.chmod(step_trace_time_path, stat.S_IREAD | stat.S_IWRITE)