mindspore 2.4.0__cp310-cp310-macosx_10_15_x86_64.whl

mindspore/profiler/parser/ascend_analysis/trace_event_manager.py

@@ -0,0 +1,75 @@
+# 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_i_event(cls, event: BaseEvent) -> Dict:
+        """Create a i event."""
+        event = {"name": event.name, "ph": "i", "ts": str(event.ts),
+                 "pid": event.pid, "tid": event.tid, "args": event.args}
+        return event
+
+    @classmethod
+    def create_m_event(cls, pid: int, tid_list: set, process_index: int) -> 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": process_index}},
+        ]
+        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"}]
+
+    @classmethod
+    def create_mindspore_to_self_flow(cls, start_event: BaseEvent, end_event: BaseEvent) -> List:
+        """Create flow events link mindspore operator and npu kernel."""
+        flow_id = start_event.flow_id
+        return [{"ph": "s", "bp": "e", "name": "mindspore_to_self", "id": flow_id, "pid": start_event.pid,
+                 "tid": start_event.tid, "ts": str(start_event.ts), "cat": "async_mindspore"},
+                {"ph": "f", "bp": "e", "name": "mindspore_to_self", "id": flow_id, "pid": end_event.pid,
+                 "tid": end_event.tid, "ts": str(end_event.ts), "cat": "async_mindspore"}]

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)

mindspore/profiler/parser/ascend_communicate_generator.py

@@ -0,0 +1,314 @@
+# 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.
+# ============================================================================
+"""communicate data analyze api file"""
+import json
+import re
+import logging
+import os
+import stat
+from collections import defaultdict
+
+from mindspore.profiler.common.exceptions.exceptions import ProfilerIOException
+
+
+class AscendCommunicationGenerator:
+    """
+    load and split communication info by step
+    """
+    COMMUNICATION_TIME_INFO = "Communication Time Info"
+    START_TIMESTAMP = "Start Timestamp(us)"
+    COMMUNICATION_BANDWIDTH_INFO = "Communication Bandwidth Info"
+    HCOM_SEND = "Send"
+    HCOM_RECEIVE = "Receive"
+    TOTAL = "Total"
+    SYNCHRONIZATION_TIME_RATIO = "Synchronization Time Ratio"
+    SYNCHRONIZATION_TIME_MS = "Synchronization Time(ms)"
+    WAIT_TIME_RATIO = "Wait Time Ratio"
+    TRANSIT_TIME_MS = "Transit Time(ms)"
+    TRANSIT_SIZE_MB = "Transit Size(MB)"
+    SIZE_DISTRIBUTION = "Size Distribution"
+    WAIT_TIME_MS = "Wait Time(ms)"
+    BANDWIDTH_GB_S = "Bandwidth(GB/s)"
+    COMMUNICATION = "communication.json"
+    COMMUNICATION_MATRIX = "communication_matrix.json"
+    P2P = "p2p"
+    COLLECTIVE = "collective"
+    TRANSPORT_TYPE = "Transport Type"
+    PATTERN1 = re.compile(r"receive|send")
+    PATTERN2 = re.compile(r"invalid|broadcast|allreduce|reduce|"
+                          r"allgather|reducescatter|scatter|alltoall|alltoallv|alltoallvc")
+
+    def __init__(self, source_path):
+        super().__init__()
+        self.root_path = source_path
+        self.step_list = [{"step_id": None, "start_ts": 0, "end_ts": float('inf'), "comm_ops": {}}]
+        self.output_communication = {}
+        self.output_matrix_data = {}
+
+    @staticmethod
+    def combine_size_distribution(op_dict: dict, total_dict: dict):
+        """combine size distribution"""
+        for size, size_info in op_dict.items():
+            total_dict[size][0] += size_info[0]
+            total_dict[size][1] += size_info[1]
+
+    @staticmethod
+    def compute_ratio(dividend: float, divisor: float):
+        """compute ratio"""
+        if abs(divisor) < 1e-15:
+            return 0
+        return round(dividend / divisor, 4)
+
+    def parse(self) -> None:
+        """parse"""
+        self.generate_communication()
+        self.generate_matrix()
+
+    def generate_communication(self):
+        """
+        generate communication.json
+        """
+        communication_file = os.path.join(self.root_path, self.COMMUNICATION)
+        with open(communication_file) as file:
+            communication_data = json.load(file)
+        if not communication_data:
+            return
+        self.split_comm_op_by_step(communication_data)
+
+        for step_info in self.step_list:
+            step = "step" + step_info.get("step_id") if step_info.get("step_id") else "step"
+            self.output_communication[step] = self.get_communication_ops_dict(step_info.get("comm_ops"))
+
+    def generate_matrix(self):
+        """generate matrix"""
+        communication_file = os.path.join(self.root_path, self.COMMUNICATION_MATRIX)
+        with open(communication_file) as file:
+            matrix_data = json.load(file)
+        if not matrix_data:
+            return
+        matrix_data_by_step = self.split_matrix_by_step(matrix_data)
+
+        for step, comm_matrix_data in matrix_data_by_step.items():
+            self.output_matrix_data[step] = self.get_matrix_ops_dict(comm_matrix_data)
+
+    def split_comm_op_by_step(self, communication_data: dict):
+        """split comm op by step"""
+        if len(self.step_list) == 1:
+            self.step_list[0]["comm_ops"] = communication_data
+        for communication_op, communication_op_info in communication_data.items():
+            start_time = communication_op_info.get(self.COMMUNICATION_TIME_INFO, {}).get(self.START_TIMESTAMP)
+            for step_info in self.step_list:
+                if step_info.get("start_ts", -1) <= start_time <= step_info.get("end_ts", -1):
+                    step_info.get("comm_ops", {})[communication_op] = communication_op_info
+                    break
+
+    def split_communication_p2p_ops(self, op_data: dict):
+        """
+        split communicate
+        """
+        comm_op_dict = {self.P2P: {}, self.COLLECTIVE: {}}
+        for communication_op, communication_info in op_data.items():
+            if communication_op.find(self.HCOM_SEND) != -1 or communication_op.find(self.HCOM_RECEIVE) != -1:
+                comm_op_dict[self.P2P][communication_op] = communication_info
+            elif communication_op.startswith(self.TOTAL):
+                continue
+            else:
+                comm_op_dict[self.COLLECTIVE][communication_op] = communication_info
+        return comm_op_dict
+
+    def split_matrix_by_step(self, matrix_data: dict) -> dict:
+        """
+        split matrix by step
+        """
+        matrix_data_by_step = {}
+        if self.is_step_list_empty():
+            matrix_data_by_step["step"] = matrix_data
+            return matrix_data_by_step
+
+        for comm_op in matrix_data:
+            for step_info in self.step_list:
+                if comm_op in step_info.get("comm_ops", {}):
+                    step = "step" + step_info.get("step_id") if step_info.get("step_id") else "step"
+                    matrix_data_by_step.setdefault(step, {})[comm_op] = matrix_data.get(comm_op)
+                    break
+        return matrix_data_by_step
+
+    def get_communication_ops_dict(self, op_data: dict) -> dict:
+        """get communication ops dict"""
+        comm_op_dict = self.split_communication_p2p_ops(op_data)
+        self.compute_total_info(comm_op_dict[self.P2P])
+        self.compute_total_info(comm_op_dict[self.COLLECTIVE])
+        return comm_op_dict
+
+    def integrate_matrix_data(self, comm_op_dict_simple):
+        """integrate the matrix data"""
+        comm_op_dict = defaultdict(dict)
+        for new_comm_op_name, data in comm_op_dict_simple.items():
+            data.sort(key=lambda x: x[self.BANDWIDTH_GB_S], reverse=True)
+            t_type = data[0].get(self.TRANSPORT_TYPE, '')
+            t_size = sum(x.get(self.TRANSIT_SIZE_MB, 0) for x in data)
+            t_time = sum(x.get(self.TRANSIT_TIME_MS, 0) for x in data)
+            bandwidth = self.compute_ratio(t_size, t_time)
+
+            link = new_comm_op_name[2]
+
+            comm_op_dict[f'{new_comm_op_name[0]}-top1@{new_comm_op_name[1]}'].update({link: data[0]})
+            comm_op_dict[f'{new_comm_op_name[0]}-middle@{new_comm_op_name[1]}'].update({link: data[len(data) // 2]})
+            comm_op_dict[f'{new_comm_op_name[0]}-bottom1@{new_comm_op_name[1]}'].update({link: data[-1]})
+            index2 = -2
+            index3 = -3
+            if len(data) == 1:
+                index2 = -1
+                index3 = -1
+            elif len(data) == 2:
+                index3 = -2
+            comm_op_dict[f'{new_comm_op_name[0]}-bottom2@{new_comm_op_name[1]}'].update({link: data[index2]})
+            comm_op_dict[f'{new_comm_op_name[0]}-bottom3@{new_comm_op_name[1]}'].update({link: data[index3]})
+            comm_op_dict[f'{new_comm_op_name[0]}-total@{new_comm_op_name[1]}'].update({link: {
+                self.TRANSPORT_TYPE: t_type,
+                self.TRANSIT_SIZE_MB: t_size,
+                self.TRANSIT_TIME_MS: t_time,
+                self.BANDWIDTH_GB_S: bandwidth
+            }})
+        return comm_op_dict
+
+    def get_matrix_ops_dict(self, op_data: dict) -> dict:
+        """parse matrix data"""
+        comm_op_dict_simple_p2p = defaultdict(list)
+        comm_op_dict_simple_collective = defaultdict(list)
+
+        for communication_op, communication_info in op_data.items():
+            if communication_op.find(self.HCOM_SEND) != -1 or communication_op.find(self.HCOM_RECEIVE) != -1:
+
+                match_obj = self.PATTERN1.search(communication_op.lower())
+                comm_op_type = match_obj.group()
+                for link, data in communication_info.items():
+                    new_comm_op_name = (comm_op_type, communication_op.split("@")[-1], link)
+                    data['op_name'] = communication_op.split("@")[0]
+                    comm_op_dict_simple_p2p[new_comm_op_name].append(data)
+
+            elif communication_op.startswith(self.TOTAL):
+                continue
+            else:
+                match_obj = self.PATTERN2.search(communication_op.lower())
+                if not match_obj:
+                    comm_op_type = communication_op.lower().split('/')[-1].split('-op')[0]
+                    logging.warning("Communication operator type not found communication_op: %s, use comm_op_type: %s",
+                                    communication_op, comm_op_type)
+                else:
+                    comm_op_type = match_obj.group()
+                for link, data in communication_info.items():
+                    new_comm_op_name = (comm_op_type, communication_op.split("@")[-1], link)
+                    data['op_name'] = communication_op.split("@")[0]
+                    comm_op_dict_simple_collective[new_comm_op_name].append(data)
+
+        comm_op_dict = {self.P2P: self.integrate_matrix_data(comm_op_dict_simple_p2p),
+                        self.COLLECTIVE: self.integrate_matrix_data(comm_op_dict_simple_collective)}
+
+        return comm_op_dict
+
+    def is_step_list_empty(self):
+        """is step list empty"""
+        for step_info in self.step_list:
+            if step_info.get("comm_ops"):
+                return False
+        return True
+
+    def compute_total_info(self, comm_ops: dict):
+        """
+        compute total info
+        """
+        if not comm_ops:
+            return
+        total_time_info_dict = defaultdict(float)
+        total_bandwidth_info_dict = {}
+        for _, communication_op_info in comm_ops.items():
+            for com_info, com_info_dict in communication_op_info.items():
+                if com_info == self.COMMUNICATION_TIME_INFO:
+                    self.combine_time_info(com_info_dict, total_time_info_dict)
+                if com_info == self.COMMUNICATION_BANDWIDTH_INFO:
+                    self.combine_bandwidth_info(com_info_dict, total_bandwidth_info_dict)
+        self.compute_time_ratio(total_time_info_dict)
+        self.compute_bandwidth_ratio(total_bandwidth_info_dict)
+        comm_ops['Total Op Info'] = {
+            self.COMMUNICATION_TIME_INFO: total_time_info_dict,
+            self.COMMUNICATION_BANDWIDTH_INFO: total_bandwidth_info_dict
+        }
+
+    def combine_time_info(self, com_info_dict: dict, total_time_info_dict: dict):
+        """combine time info"""
+        ratio_list = [self.WAIT_TIME_RATIO, self.SYNCHRONIZATION_TIME_RATIO]
+        for time_info in com_info_dict:
+            if time_info not in ratio_list and time_info != self.START_TIMESTAMP:
+                total_time_info_dict[time_info] += com_info_dict.get(time_info)
+
+    def combine_bandwidth_info(self, com_info_dict: dict, total_bandwidth_info_dict: dict):
+        """
+        combine bandwidth info
+        """
+        add_list = [self.TRANSIT_TIME_MS, self.TRANSIT_SIZE_MB]
+        dict_list = [self.SIZE_DISTRIBUTION]
+        for transport_type, part_transport_dict in com_info_dict.items():
+            if transport_type not in total_bandwidth_info_dict:
+                total_bandwidth_info_dict[transport_type] = {
+                    self.TRANSIT_TIME_MS: 0,
+                    self.TRANSIT_SIZE_MB: 0,
+                    self.SIZE_DISTRIBUTION: defaultdict(lambda: [0, 0])
+                }
+            for bandwidth_msg, value in part_transport_dict.items():
+                if bandwidth_msg in add_list:
+                    total_bandwidth_info_dict[transport_type][bandwidth_msg] += value
+                if bandwidth_msg in dict_list:
+                    self.combine_size_distribution(value, total_bandwidth_info_dict[transport_type][bandwidth_msg])
+
+    def compute_time_ratio(self, total_time_info_dict: dict):
+        """compute time ratio"""
+        total_time_info_dict[self.WAIT_TIME_RATIO] = \
+            self.compute_ratio(total_time_info_dict.get(self.WAIT_TIME_MS, 0),
+                               total_time_info_dict.get(self.WAIT_TIME_MS, 0) +
+                               total_time_info_dict.get(self.TRANSIT_TIME_MS, 0))
+        total_time_info_dict[self.SYNCHRONIZATION_TIME_RATIO] = \
+            self.compute_ratio(total_time_info_dict.get(self.SYNCHRONIZATION_TIME_MS, 0),
+                               total_time_info_dict.get(self.TRANSIT_TIME_MS, 0) +
+                               total_time_info_dict.get(self.SYNCHRONIZATION_TIME_MS, 0))
+
+    def compute_bandwidth_ratio(self, total_bandwidth_info_dict: dict):
+        """compute bandwidth ratio"""
+        for _, bandwidth_dict in total_bandwidth_info_dict.items():
+            self.compute_ratio(bandwidth_dict.get(self.TRANSIT_SIZE_MB, 0), bandwidth_dict.get(self.TRANSIT_TIME_MS, 0))
+
+    def write(self, communication_file_path, communication_matrix_file_path):
+        """
+        write communication file and communication matrix file
+        """
+        try:
+            with os.fdopen(os.open(communication_file_path,
+                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as json_file:
+                json.dump(self.output_communication, json_file)
+        except (IOError, OSError) as err:
+            logging.critical('Error occurred when write communication file: %s', err)
+            raise ProfilerIOException() from err
+        if os.path.exists(communication_file_path):
+            os.chmod(communication_file_path, stat.S_IREAD | stat.S_IWRITE)
+
+        try:
+            with os.fdopen(os.open(communication_matrix_file_path,
+                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as json_file:
+                json.dump(self.output_matrix_data, json_file)
+        except (IOError, OSError) as err:
+            logging.critical('Error occurred when write communication matrix file: %s', err)
+            raise ProfilerIOException() from err
+        if os.path.exists(communication_matrix_file_path):
+            os.chmod(communication_matrix_file_path, stat.S_IREAD | stat.S_IWRITE)

mindspore/profiler/parser/ascend_flops_generator.py

@@ -0,0 +1,116 @@
+# 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.
+# ============================================================================
+"""flops analyse model"""
+import csv
+import json
+import logging
+import os
+import stat
+
+import numpy as np
+from mindspore import log as logger
+from mindspore.profiler.common.exceptions.exceptions import ProfilerIOException
+
+
+class AscendFlopsGenerator:
+    """Generate ascend flops data from DataFrame."""
+
+    def __init__(self, op_summary, launch_ops, pretty=False):
+        self.op_summary = op_summary
+        self.launch_ops = launch_ops
+        self.flops_dt = np.dtype(
+            [('full_kernel_name', object), ('MFLOPs(10^6 cube)', float), ('GFLOPS(10^9 cube)', float),
+             ('MFLOPs(10^6 vector)', float), ('GFLOPS(10^9 vector)', float)])
+        self.flops = None
+        self.flops_summary = None
+        self._full_kernel_name = None
+        self.pretty = pretty
+
+    @property
+    def indent(self):
+        indent = 1 if self.pretty else None
+        return indent
+
+    def parse(self):
+        """Analyse the op_summary data generate flops data."""
+
+        self.flops = np.empty((len(self.op_summary)), dtype=self.flops_dt)
+        self._set_full_kernel_name(self.op_summary, self.launch_ops)
+        nonzero_duration = self.op_summary['Task Duration'] != 0
+        self.flops['full_kernel_name'] = self._full_kernel_name
+        self.flops['MFLOPs(10^6 cube)'] = self.op_summary['cube_fops'] * 1e-6
+        self.flops['GFLOPS(10^9 cube)'] = np.where(nonzero_duration, self.op_summary['cube_fops'] / self.op_summary[
+            'Task Duration'] * 1e-6, 0)
+        self.flops['MFLOPs(10^6 vector)'] = self.op_summary['vector_fops'] * 1e-6
+        self.flops['GFLOPS(10^9 vector)'] = self.op_summary['vector_fops'] / self.op_summary['Task Duration'] * 1e-6
+        self.flops['GFLOPS(10^9 vector)'] = np.where(nonzero_duration, self.op_summary['vector_fops'] / self.op_summary[
+            'Task Duration'] * 1e-6, 0)
+
+        cube_flops = 0
+        vec_flops = 0
+        if np.sum(self.op_summary['Task Duration']) != 0:
+            cube_flops = round(np.sum(self.flops['GFLOPS(10^9 cube)']) / np.sum(self.op_summary['Task Duration']), 4)
+            vec_flops = round(np.sum(self.flops['GFLOPS(10^9 vector)']) / np.sum(self.op_summary['Task Duration']), 4)
+
+        self.flops_summary = {
+            'cube_FLOPs': round(float(np.sum(self.flops['MFLOPs(10^6 cube)'])), 4),
+            'cube_FLOPS': cube_flops,
+            'vec_FLOPs': round(float(np.sum(self.flops['MFLOPs(10^6 vector)'])), 4),
+            'vec_FLOPS': vec_flops
+        }
+
+    def write(self, flops_path, flops_summary_path):
+        """
+        Write the flops.csv and flops_summary.json
+
+        Args:
+            flops_path(str): flops.csv path.
+            flops_summary_path(str): flops_summary.json path.
+        """
+        try:
+            with os.fdopen(os.open(flops_path,
+                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR), 'w') as fp:
+                writer = csv.writer(fp)
+                writer.writerow(self.flops.dtype.names)
+                writer.writerows(self.flops.tolist())
+        except (IOError, OSError) as err:
+            logging.critical('Errot occurred when write flops file: %s', err)
+            raise ProfilerIOException() from err
+        if os.path.exists(flops_path):
+            os.chmod(flops_path, stat.S_IREAD | stat.S_IWRITE)
+
+        try:
+            with os.fdopen(os.open(flops_summary_path,
+                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR),
+                           'w') as json_file:
+                json.dump(self.flops_summary, json_file, indent=self.indent)
+        except (IOError, OSError) as err:
+            logging.critical('Errot occurred when write step trace point info file: %s', err)
+            raise ProfilerIOException() from err
+        if os.path.exists(flops_summary_path):
+            os.chmod(flops_summary_path, stat.S_IREAD | stat.S_IWRITE)
+
+    def _set_full_kernel_name(self, op_summary, launch_ops):
+        """update full kernel name"""
+        self._full_kernel_name = op_summary['Op Name']
+
+        if launch_ops and len(launch_ops) != len(op_summary):
+            logger.error("Size mismatch between op_summary and launch_ops!")
+            launch_ops = []
+
+        for index, launch_op in enumerate(launch_ops):
+            if not launch_op:
+                continue
+            self._full_kernel_name[index] = f"{launch_op}/{self._full_kernel_name[index]}"