mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/profiler/parser/framework_parser.py

@@ -14,27 +14,28 @@
 # ============================================================================
 """The parser for parsing framework files."""
 import csv
+import glob
+import json
 import os
+import stat
 import re
 import struct
-import json
-from pathlib import Path
-from typing import List
 from collections import defaultdict
 from collections import namedtuple
-import glob
-import numpy as np
+from pathlib import Path
+from typing import List
 
+import numpy as np
 from mindspore import log as logger
-from mindspore.profiler.parser.framework_struct import TASK_DESC_STRUCT, TENSOR_DATA_STRUCT, STEP_INFO_STRUCT
-from mindspore.profiler.parser.framework_enum import VmDataType, VmFormat, FileDataType, MSPROF_DIFFERENCE
-from mindspore.profiler.parser.framework_enum import MSPROF_MIX_DATA_STRING
-from mindspore.profiler.common.struct_type import StructType
-from mindspore.profiler.common.util import combine_stream_task_id
 from mindspore.profiler.common.exceptions.exceptions import ProfilerDirNotFoundException
 from mindspore.profiler.common.exceptions.exceptions import ProfilerFileNotFoundException
 from mindspore.profiler.common.exceptions.exceptions import ProfilerParamValueErrorException
+from mindspore.profiler.common.struct_type import StructType
+from mindspore.profiler.common.util import combine_stream_task_id
 from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.framework_enum import MSPROF_MIX_DATA_STRING
+from mindspore.profiler.parser.framework_enum import VmDataType, VmFormat, FileDataType, MSPROF_DIFFERENCE
+from mindspore.profiler.parser.framework_struct import TASK_DESC_STRUCT, TENSOR_DATA_STRUCT, STEP_INFO_STRUCT
 from mindspore.profiler.parser.profiler_info import ProfilerInfo
 
 FILE_DATA_STRUCT_DICT = {
@@ -43,8 +44,19 @@ FILE_DATA_STRUCT_DICT = {
     FileDataType.TASK_DESC_INFO.value: TASK_DESC_STRUCT
 }
 
-COL_NAMES = ['task_id', 'stream_id', 'block_dim', 'full_op_name', 'op_name', 'op_type', 'subgraph', 'op_info',
-             'graph_id']
+TASK_TYPE_TO_KERNEL_TYPE = {
+    0: 'AI_CORE',
+    1: 'AI_CPU',
+    2: 'MSPROF_AIV',
+    10: 'MSPROF_HCCL',
+    11: 'MSPROF_RTS',
+    1000: 'MSPROF_UNKNOWN_TYPE'
+}
+
+COL_NAMES = [
+    'task_id', 'stream_id', 'block_dim', 'full_op_name', 'op_name', 'op_type', 'subgraph', 'op_info',
+    'graph_id', 'kernel_type'
+]
 OpData = namedtuple('OpData', field_names=COL_NAMES)
 
 
@@ -58,6 +70,8 @@ class FrameworkParser:
         output_path (str): The directory of the parsed file. Default: `./`.
     """
     _regex_framework = r'Framework\.(?P<data_type>.+)\.(?P<device_id>\d).+'
+    _host_regex_framework = r'Framework\.(?P<data_type>.+)\.+'
+    _match_framework_file = r'Framework*[0-9]'
     _graph_attr_name = [
         'input_format', 'input_data_type', 'input_shape', 'output_format',
         'output_data_type', 'output_shape'
@@ -211,10 +225,11 @@ class FrameworkParser:
 
     @staticmethod
     def _write_framework_to_file(all_op_data: List[OpData], output_file):
-        with open(output_file, 'w') as file_handler:
+        with os.fdopen(os.open(output_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as file_handler:
             csv_writer = csv.writer(file_handler)
             csv_writer.writerow(COL_NAMES)
             csv_writer.writerows(all_op_data)
+        os.chmod(output_file, stat.S_IREAD | stat.S_IWRITE)
 
     @staticmethod
     def _get_subgraph_name(full_op_name):
@@ -239,7 +254,7 @@ class FrameworkParser:
         Args:
             op_name (str): The operator name or operator name prefix.
             is_prefix (bool): `True` if the op_name is prefix, else `False`.
-                Default: True.
+                Default: ``True``.
 
         Returns:
             bool, `True` if the operator name does exist in framework file, else
@@ -297,17 +312,25 @@ class FrameworkParser:
             ProfilerFileNotFoundException: If the framework files are not found.
         """
         data_dir = os.path.join(profiling_path, 'data')
-        if not os.path.isdir(data_dir):
+        host_data_dir = os.path.join(profiling_path, '../host/data')
+        if not os.path.isdir(data_dir) and not os.path.isdir(host_data_dir):
             raise ProfilerDirNotFoundException(data_dir)
 
         framework_path_dict = defaultdict(list)
-        for file in Path(data_dir).glob(r'Framework*[0-9]'):
+        file_list = [f for f in Path(data_dir).glob(self._match_framework_file)]
+        if not file_list:
+            file_list = [f for f in Path(host_data_dir).glob(self._match_framework_file)]
+
+        for file in file_list:
             file_name = file.name
+
             match = re.search(self._regex_framework, file_name)
             if match is None:
-                logger.warning("Profiler does not support to analyse file(%s), this file name format is not %s, "
-                               "skip this file.", file.resolve(), self._regex_framework)
-                continue
+                match = re.search(self._host_regex_framework, file_name)
+                if match is None:
+                    logger.warning("Profiler does not support to analyse file(%s), this file name format is not %s, "
+                                   "skip this file.", file.resolve(), self._regex_framework)
+                    continue
 
             if match['data_type'] not in FileDataType.members():
                 logger.warning("Profiler does not support to analyse file(%s), this file data type is %s, "
@@ -405,8 +428,10 @@ class FrameworkParser:
                              op_type=task_desc['opType'],
                              subgraph=subgraph,
                              op_info=json.dumps(task_id_op_attr_dict.get(combined_task_id, {})),
-                             graph_id=task_desc['modelId'])
-            graph_ids.add(task_desc['modelId'])
+                             graph_id=task_desc['modelId'],
+                             kernel_type=TASK_TYPE_TO_KERNEL_TYPE.get(task_desc.get('taskType')))
+            if not task_desc['opType'].startswith("InitDataSetQueue") and not task_desc['opType'].startswith("GetNext"):
+                graph_ids.add(task_desc['modelId'])
             all_op_data.append(op_data)
         ProfilerInfo.set_graph_ids(list(graph_ids))
         return all_op_data
@@ -524,14 +549,18 @@ class GpuFrameWorkParser:
                 op_total_time = float(line_info[-4])
                 if not self.op_detail.get(op_name):
                     # line_info[4]: op_occurrences, line_info[5]: op_detail_time(us), line_info[6]: op_avg_time(us);
-                    self.op_detail[op_name] = [op_occurrences, op_total_time,
-                                               round(op_total_time / op_occurrences, 4), op_side]
+                    self.op_detail[op_name] = [
+                        op_occurrences, op_total_time,
+                        round(op_total_time / op_occurrences, 4), op_side
+                    ]
                 else:
                     self.op_detail.get(op_name)[1] += op_total_time
                     self.op_detail.get(op_name)[2] = self.op_detail.get(op_name)[1] / self.op_detail.get(op_name)[0]
-                    self.op_detail[op_name] = [self.op_detail.get(op_name)[0],
-                                               round(self.op_detail.get(op_name)[1], 4),
-                                               round(self.op_detail.get(op_name)[2], 4), op_side]
+                    self.op_detail[op_name] = [
+                        self.op_detail.get(op_name)[0],
+                        round(self.op_detail.get(op_name)[1], 4),
+                        round(self.op_detail.get(op_name)[2], 4), op_side
+                    ]
 
     def combine_performance_data(self, op_name):
         """Combine operator detail info with framework info."""
@@ -554,8 +583,10 @@ class GpuFrameWorkParser:
                     op_shape_dict.get(op_shape)[0] += op_occurrences
                     op_shape_dict.get(op_shape)[1] += op_total_time
                     op_shape_dict.get(op_shape)[2] = op_shape_dict.get(op_shape)[1] / op_shape_dict.get(op_shape)[0]
-                    op_shape_dict[op_shape] = [op_shape_dict.get(op_shape)[0], round(op_shape_dict.get(op_shape)[1], 4),
-                                               round(op_shape_dict.get(op_shape)[2], 4), op_side]
+                    op_shape_dict[op_shape] = [
+                        op_shape_dict.get(op_shape)[0], round(op_shape_dict.get(op_shape)[1], 4),
+                        round(op_shape_dict.get(op_shape)[2], 4), op_side
+                    ]
                 else:
                     op_shape_dict[op_shape] = [op_occurrences, op_total_time, op_avg_time, op_side]
 
@@ -648,8 +679,9 @@ class GpuFrameWorkParser:
             "kernel_type": kernel_type_step_time,
         }
         dynamic_shape_file_path = os.path.join(self._output_path, output_dynamic_shape_file_name)
-        with os.fdopen(os.open(dynamic_shape_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660), 'w') as fp:
+        with os.fdopen(os.open(dynamic_shape_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as fp:
             json.dump(result, fp)
+        os.chmod(dynamic_shape_file_path, stat.S_IREAD | stat.S_IWRITE)
 
     def get_graph_ids(self):
         """Get gpu graph ids."""
@@ -661,7 +693,7 @@ class GpuFrameWorkParser:
         with open(gpu_framework_file[0], 'r') as f_obj:
             framework_info = f_obj.readlines()
         for line_info in framework_info:
-            if line_info.startswith("InitDataSetQueue"):
+            if line_info.startswith("InitDataSetQueue") or line_info.startswith("GetNext"):
                 continue
             line_info = line_info.strip(' ').strip('\n').split(';')
             if len(line_info) > 2 and line_info[2].isdigit():
@@ -681,13 +713,14 @@ class GpuFrameWorkParser:
                 "grid_dim": args.get('grid_dim')
             }
         else:
+            op_step_shape = self.op_step_shape_info.get(op_info.get('name'))
             item = {
                 "step": step,
                 "op_side": self.op_step_shape_info.get(op_info.get('name'))[0],
                 "op_type": op_info.get('name').split('-')[0],
                 "op_name": op_info.get('name'),
                 "dur": op_info.get('dur'),
-                "shape_info": self.op_step_shape_info.get(op_info.get('name'))[step],
+                "shape_info": op_step_shape[step] if len(op_step_shape) > step else [],
             }
         return item
 
@@ -702,10 +735,12 @@ class GpuFrameWorkParser:
             else:
                 self.one_step_op_time[sort_type][0] += duration
                 self.one_step_op_time[sort_type][1] += 1
-                self.one_step_op_time[sort_type] = [self.one_step_op_time[sort_type][0],
-                                                    self.one_step_op_time[sort_type][1],
-                                                    round(self.one_step_op_time[sort_type][0] /
-                                                          self.one_step_op_time[sort_type][1], 4)]
+                self.one_step_op_time[sort_type] = [
+                    self.one_step_op_time[sort_type][0],
+                    self.one_step_op_time[sort_type][1],
+                    round(self.one_step_op_time[sort_type][0] /
+                          self.one_step_op_time[sort_type][1], 4)
+                ]
         else:
             sort_type = item.get("op_name")
             op_full_name = item.get("op_full_name")
@@ -715,11 +750,13 @@ class GpuFrameWorkParser:
             else:
                 self.one_step_kernel_time[sort_type][0] += duration
                 self.one_step_kernel_time[sort_type][1] += 1
-                self.one_step_kernel_time[sort_type] = [self.one_step_kernel_time[sort_type][0],
-                                                        self.one_step_kernel_time[sort_type][1],
-                                                        round(self.one_step_kernel_time[sort_type][0] /
-                                                              self.one_step_kernel_time[sort_type][1], 4),
-                                                        op_full_name]
+                self.one_step_kernel_time[sort_type] = [
+                    self.one_step_kernel_time[sort_type][0],
+                    self.one_step_kernel_time[sort_type][1],
+                    round(self.one_step_kernel_time[sort_type][0] /
+                          self.one_step_kernel_time[sort_type][1], 4),
+                    op_full_name
+                ]
 
 
 class DynamicFrameWorkParser:
@@ -743,9 +780,9 @@ class DynamicFrameWorkParser:
         self._dynamic_shape_info = defaultdict(list)
         self._step = 0
 
-    def write_dynamic_shape_data(self):
+    def write_dynamic_shape_data(self, df_op_summary):
         """Analyze dynamic shape data and write to dynamic shape file."""
-        self._get_total_step_num()
+        self._get_total_step_num(df_op_summary)
         output_dynamic_shape_file_name = f'dynamic_shape_info_{self._rank_id}.json'
         for op_name in self._exe_time_and_shape_detail:
             if self._exe_time_and_shape_detail[op_name]['op_exe_occurrences'] == self._step:
@@ -766,41 +803,23 @@ class DynamicFrameWorkParser:
                               len(self._op_type_exe_time[op_type]), 4)).tolist()
         self._dynamic_shape_info['op_type'] = self._op_info.get("op_type")
         dynamic_shape_file_path = os.path.join(self._output_path, output_dynamic_shape_file_name)
-        with os.fdopen(os.open(dynamic_shape_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660), 'w') as fp:
+        with os.fdopen(os.open(dynamic_shape_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as fp:
             json.dump(self._dynamic_shape_info, fp)
+        os.chmod(dynamic_shape_file_path, stat.S_IREAD | stat.S_IWRITE)
 
-    def _analyse_op_execute_time(self):
+    def _analyse_op_execute_time(self, op_summary):
         """Obtain the execution time of aicpu operator and aicore operator."""
-        timeline_origin_file_name = f'output_timeline_data_{self._rank_id}.txt'
-        aicpu_file_name = f'aicpu_intermediate_{self._rank_id}.csv'
-        timeline_origin_file_path = os.path.join(self._output_path, timeline_origin_file_name)
-        timeline_origin_file_path = validate_and_normalize_path(timeline_origin_file_path)
-        aicpu_file_path = os.path.join(self._output_path, aicpu_file_name)
-
-        def read_file(file_path):
-            """Read file data."""
-            with open(file_path, 'r') as fp:
-                file_info = fp.readlines()[1:]
-                return file_info
-
-        timeline_info = read_file(timeline_origin_file_path)
-        for line_info in timeline_info:
-            line_info = line_info.strip('\n').split(',')
-            op_name = line_info[0].split('/')[-1]
-            op_exe_time = float(line_info[3])
-            self._all_op_exe_time[op_name].append(op_exe_time)
-        if os.path.exists(aicpu_file_path):
-            aicpu_info = read_file(aicpu_file_path)
-            for line_info in aicpu_info:
-                line_info = line_info.strip('\n').split(',')
-                op_name = line_info[1]
-                op_exe_time = float(line_info[3])
-                self._all_op_exe_time[op_name].append(op_exe_time)
+        timeline_info = defaultdict(list)
+        for row in op_summary:
+            key = row['Op Name'].split('/')[-1]
+            timeline_info[key].append(row['Task Duration'])
+
+        self._all_op_exe_time = timeline_info
 
-    def _get_dynamic_shape_info(self):
+    def _get_dynamic_shape_info(self, op_summary):
         """Get the shape information of AICPU and aicore."""
         framework_file_name = f'framework_raw_{self._rank_id}.csv'
-        self._analyse_op_execute_time()
+        self._analyse_op_execute_time(op_summary)
         framework_file_path = os.path.join(self._output_path, framework_file_name)
         framework_file_path = validate_and_normalize_path(framework_file_path)
         with open(framework_file_path, 'r') as f_obj:
@@ -811,9 +830,9 @@ class DynamicFrameWorkParser:
                 shape_info = ','.join(line_info[7:]).replace('"', '')
                 self._op_shape_info[op_name].append(shape_info)
 
-    def _get_total_step_num(self):
+    def _get_total_step_num(self, op_summary):
         """Get the number of steps."""
-        self._get_dynamic_shape_info()
+        self._get_dynamic_shape_info(op_summary)
         all_exe_occurrences = list()
         for op_name in self._all_op_exe_time:
             op_shape = self._op_shape_info.get(op_name)

mindspore/profiler/parser/hccl_parser.py

@@ -36,9 +36,9 @@ class CommunicationInfo(Enum):
         RDMA: Communication link between servers in cluster training.
         SDMA: Communication link inside server in cluster training.
         LOCAL: The operation of this card has no transmission process.
-        RDMASEND：Communication operator of RDMA link.
-        REDUCE_INLINE：Communication operator of SDMA link.
-        MEMCPY：Communication operator of SDMA link.
+        RDMASEND: Communication operator of RDMA link.
+        REDUCE_INLINE: Communication operator of SDMA link.
+        MEMCPY: Communication operator of SDMA link.
         NOTIFY_RECORD: Communication operator of SDMA link.
         NOTIFY_WAIT: operator of LOCAL.
     """
@@ -269,15 +269,17 @@ class HcclParser:
 
             # index_0:step_num, index_1:start_point, index_2:end_point
             # The unit of time stamp is 10ns. To convert it to μs, you need to divide it by 100.
-            step_timestamps_info = [[info[0], float(info[1]) / 100, float(info[2]) / 100]
-                                    for info in csv_reader if info[0].isdigit()]
+            step_timestamps_info = [
+                [info[0], float(info[1]) / 100, float(info[2]) / 100]
+                for info in csv_reader if info[0].isdigit()
+            ]
 
         return [communication_operators_names, step_timestamps_info]
 
     def _get_communication_operator_name_mapping_info(self):
         """Get the name of communication operators mapping between hccl and step trace."""
         dir_path = self._validate_dir_path(self._source_dir)
-        # The name of the operator in hccl is like：operatorName_{Ordered_number}_xx_xx.
+        # The name of the operator in hccl is like: operatorName_{Ordered_number}_xx_xx.
         operators_names_in_hccl = [entry.name for entry in os.scandir(dir_path) if entry.is_dir()]
         operators_names_in_hccl_set = set({i.split('_')[0] for i in operators_names_in_hccl})
         op_names_in_hccl_dic = dict()
@@ -294,8 +296,10 @@ class HcclParser:
                                           for op_name in operators_names_in_step_trace})
         op_names_in_step_trace_dic = dict()
         for item in op_names_in_step_trace_set:
-            op_names_in_step_trace_dic[item] = [op_name for op_name in operators_names_in_step_trace
-                                                if op_name.split('/')[-1].split('-')[0].split('_')[-1] == item]
+            op_names_in_step_trace_dic[item] = [
+                op_name for op_name in operators_names_in_step_trace
+                if op_name.split('/')[-1].split('-')[0].split('_')[-1] == item
+            ]
 
         communication_operator_mapping_info = dict()
         for hccl_key, hccl_value in op_names_in_hccl_dic.items():
@@ -548,9 +552,9 @@ class HcclParser:
         """Validate file path."""
         try:
             file_path = validate_and_normalize_path(file_path)
-        except RuntimeError:
+        except RuntimeError as err:
             logger.warning('file path is invalid.')
-            raise ProfilerPathErrorException('file path is invalid.')
+            raise ProfilerPathErrorException('file path is invalid.') from err
         if not os.path.isfile(file_path):
             logger.warning('The file <%s> not found.', file_path)
             raise ProfilerFileNotFoundException(file_path)
@@ -560,9 +564,9 @@ class HcclParser:
         """Validate dir path."""
         try:
             dir_path = validate_and_normalize_path(dir_path)
-        except RuntimeError:
+        except RuntimeError as err:
             logger.warning('dir path is invalid.')
-            raise ProfilerPathErrorException('dir path is invalid.')
+            raise ProfilerPathErrorException('dir path is invalid.') from err
         if not os.path.isdir(dir_path):
             logger.warning('The  dir <%s> not found.', dir_path)
             raise ProfilerDirNotFoundException(dir_path)

mindspore/profiler/parser/integrator.py

@@ -16,6 +16,7 @@
 import csv
 import json
 import os
+import stat
 from decimal import Decimal
 from enum import Enum
 import sys
@@ -39,8 +40,10 @@ class Integrator:
     _file_name_framework = 'framework_raw_{}.csv'
     _header_aicore_type = ['op_type', 'total_time', 'execution_frequency', 'percent']
     _header_aicore_detail = ['full_op_name', 'execution_time', 'execution_frequency']
-    _header_aicpu = ['serial_number', 'op_type', 'total_time', 'dispatch_time',
-                     'execution_time', 'run_start', 'run_end']
+    _header_aicpu = [
+        'serial_number', 'op_type', 'total_time', 'dispatch_time',
+        'execution_time', 'run_start', 'run_end'
+    ]
 
     _file_name_aicore_type_time = 'aicore_intermediate_{}_type.csv'
     _file_name_aicore_detail_info = 'aicore_intermediate_{}_detail.csv'
@@ -153,7 +156,7 @@ class Integrator:
                 op_type_time[1] += op_info[1]
         op_type_file_name = 'aicore_intermediate_' + self._device_id + '_type.csv'
         op_type_file_path = os.path.join(self._profiling_dir, op_type_file_name)
-        with open(op_type_file_path, 'w') as type_file:
+        with os.fdopen(os.open(op_type_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as type_file:
             csv_writer = csv.writer(type_file)
             csv_writer.writerow(self._header_aicore_type)
 
@@ -164,6 +167,7 @@ class Integrator:
                         round((op_type_time_info[0] / total_time) * 100, 2)
                     ]
                 csv_writer.writerow(type_info)
+        os.chmod(op_type_file_path, stat.S_IREAD | stat.S_IWRITE)
 
     def _parse_aicore_detail_time(self):
         """Parse the parsed AICORE operator time file."""
@@ -188,8 +192,8 @@ class Integrator:
                 _ = src_file.readline()
             else:
                 return
-
-            with open(op_detail_file_path, 'w') as detail_file:
+            with os.fdopen(os.open(op_detail_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
+                           'w') as detail_file:
                 csv_writer = csv.writer(detail_file)
                 csv_writer.writerow(self._header_aicore_detail)
 
@@ -204,6 +208,7 @@ class Integrator:
                         continue
                     self._op_time_cache[op_infos[0]] = [Decimal(op_infos[1]), int(op_infos[3])]
                     csv_writer.writerow([op_infos[0], op_infos[1], op_infos[3]])
+            os.chmod(op_detail_file_path, stat.S_IREAD | stat.S_IWRITE)
 
     def _parse_aicpu_time(self):
         """Parse the parsed AICPU operator time file."""
@@ -221,7 +226,7 @@ class Integrator:
             row = src_file.readline()
             if not row.startswith('serial_number'):
                 return
-            with open(save_file_path, 'w') as save_file:
+            with os.fdopen(os.open(save_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as save_file:
                 csv_writer = csv.writer(save_file)
                 csv_writer.writerow(self._header_aicpu)
 
@@ -233,6 +238,7 @@ class Integrator:
                     if infos[0] == 'AI':
                         continue
                     csv_writer.writerow(infos)
+            os.chmod(save_file_path, stat.S_IREAD | stat.S_IWRITE)
 
     def _aicore_data_load(self):
         """Load data according to the parsed AICORE operator types file."""
@@ -276,7 +282,8 @@ class Integrator:
             _ = next(csv_reader)
             for info in csv_reader:
                 framework_infos[info[3]] = [
-                    info[3], info[4], info[5], info[6], json.loads(info[7]) if info[7] else None]
+                    info[3], info[4], info[5], info[6], json.loads(info[7]) if info[7] else None
+                ]
 
         with open(op_detail_file_path, 'r') as file:
             csv_reader = csv.reader(file)
@@ -374,8 +381,10 @@ class Integrator:
         factor = 1e5  # convert time unit from 10ns to 1ms
         reduce_pid = 10000
         reduce_info = []
-        reduce_fields = [field_name for field_name in self._column
-                         if field_name.startswith('stream_') and not field_name.endswith('point')]
+        reduce_fields = [
+            field_name for field_name in self._column
+            if field_name.startswith('stream_') and not field_name.endswith('point')
+        ]
         for reduce_field in reduce_fields:
             reduce_start = row_info_dict.get(reduce_field + '_start_point')
             reduce_start = reduce_start / factor \
@@ -388,8 +397,10 @@ class Integrator:
             cur_stream_id = reduce_field.split('_', 3)[1]
             if reduce_field.split('_', 2)[1] == 'ops':
                 cur_stream_id = reduce_field.split('_', 3)[2]
-            reduce_meta = [reduce_field, int(cur_stream_id), reduce_start,
-                           reduce_duration, reduce_pid]
+            reduce_meta = [
+                reduce_field, int(cur_stream_id), reduce_start,
+                reduce_duration, reduce_pid
+            ]
             reduce_info.append(reduce_meta)
 
         return reduce_info

mindspore/profiler/parser/memory_usage_parser.py

@@ -147,9 +147,9 @@ class MemoryUsageParser:
                 continue
 
             graph_parser = GraphMemoryParser(graph_proto, self._points, self._framework)
-            graph = graph_parser.parse_graph()
-            if graph:
-                self._graphs_dict[graph_id] = graph
+            graph, model_id = graph_parser.parse_graph()
+            if graph and model_id != -1:
+                self._graphs_dict[model_id] = graph
 
             # update global memory usage data
             self._peak_mem = max(self._peak_mem, graph_parser.peak_mem)
@@ -163,9 +163,9 @@ class MemoryUsageParser:
         file_path = validate_and_normalize_path(file_path)
 
         try:
-            with open(file_path, 'w') as json_file:
+            with os.fdopen(os.open(file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as json_file:
                 json.dump(content, json_file)
-                os.chmod(file_path, stat.S_IREAD | stat.S_IWRITE)
+            os.chmod(file_path, stat.S_IREAD | stat.S_IWRITE)
         except (IOError, OSError) as err:
             logger.critical('Fail to write memory file.\n%s', err)
             raise ProfilerIOException from err
@@ -191,6 +191,12 @@ class GraphMemoryParser:
         self._mem_change = []
         self.breakdowns = []
         self._lifetime = []
+        # compatible with original mode
+        self._multi_graph = False
+        if not isinstance(self._points, dict):
+            raise TypeError("Input points data must be dict!")
+        if not self._points.get("fp_start"):
+            self._multi_graph = True
 
     @staticmethod
     def _remove_duplicate_tensors(node):
@@ -221,12 +227,13 @@ class GraphMemoryParser:
     def parse_graph(self):
         """Parse memory usage data for subgraphs."""
         graph_dict = {}
+        model_id = -1
         self.graph = Graph(self._graph_proto)
         # process tensors in the graph
         tensors_proto = self._graph_proto.tensor_mems
         if not tensors_proto:
             logger.info('No tensor in graph %s, skipped.', self.graph.graph_id)
-            return graph_dict
+            return graph_dict, model_id
         self._parse_tensors(tensors_proto)
 
         # calculate memory usage of the graph by number of nodes and details of tensors
@@ -251,7 +258,7 @@ class GraphMemoryParser:
         self.graph.breakdowns = [self.breakdowns[self.tensor_node_id]]
 
         # update fp_start and bp_end
-        point_id = self._locate_fp_bp_id()
+        point_id, model_id = self._locate_fp_bp_id()
         self.graph.fp_start = point_id.get('fp_start')
         self.graph.bp_end = point_id.get('bp_end')
 
@@ -262,7 +269,7 @@ class GraphMemoryParser:
         self.deallocations = len(self.tensors)
         self.peak_mem = max(max(self._mem_change), self.peak_mem)
 
-        return graph_dict
+        return graph_dict, model_id
 
     def _parse_tensors(self, tensors_proto):
         """Parse tensors."""
@@ -371,12 +378,30 @@ class GraphMemoryParser:
 
     def _locate_fp_bp_id(self):
         """Locate the node id of fp_start and bp_end in graph."""
+        model_id = 0
+        if not self._multi_graph:
+            point_id = self._match_graph_fpbp(self._points)
+        else:
+            for mod_id, points in self._points.items():
+                if not isinstance(points, dict) or not mod_id.startswith("model"):
+                    raise RuntimeError("Inputs points is invalid!")
+                point_id = self._match_graph_fpbp(points)
+                if point_id.get("fp_start"):
+                    model_id = int(mod_id.split("_")[-1])
+                    break
+        if not point_id.get("fp_start") or not point_id.get("bp_end"):
+            model_id = -1
+
+        return point_id, model_id
+
+    def _match_graph_fpbp(self, points):
+        "Match model_id and graph_id"
         point_id = {
             'fp_start': None,
             'bp_end': None
         }
-        fp_start = self._points.get('fp_start') if self._points else None
-        bp_end = self._points.get('bp_end') if self._points else None
+        fp_start = points.get('fp_start')
+        bp_end = points.get('bp_end')
         fp_name = fp_start.split('/')[-1] if fp_start else ""
         bp_name = bp_end.split('/')[-1] if bp_end else ""
         if fp_name in self.nodes:
@@ -388,7 +413,7 @@ class GraphMemoryParser:
 
     def _process_memory_breakdowns(self):
         """Process memory breakdowns for each node."""
-        self.breakdowns = [[] for _ in range(len(self.nodes))]
+        self.breakdowns = [[] for _ in range(len(self._lifetime))]
         for index, breakdown in enumerate(self._lifetime):
             for t_id in breakdown:
                 tensor = self.tensors.get(t_id)

mindspore/profiler/parser/minddata_analyzer.py

@@ -557,21 +557,19 @@ class MinddataProfilingAnalyzer:
         output_csv_path_filename = os.path.join(self._output_path, summary_templatename.format(self._device_id))
 
         # Open file for writing
-        data_file = open(output_csv_path_filename, 'w')
+        with os.fdopen(os.open(output_csv_path_filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
+                       'w') as data_file:
 
-        # Create CSV writer object
-        csv_writer = csv.writer(data_file)
+            # Create CSV writer object
+            csv_writer = csv.writer(data_file)
 
-        # Write the dictionary information to CSV file
-        # Create deepcopy of input data_dict so zip processing in this function does NOT change the data_dict
-        temp_dict = copy.deepcopy(data_dict)
-        for data_key, data_value in zip(temp_dict.keys(), temp_dict.values()):
-            # Begin/prefix the data value with the data key
-            data_value.insert(0, data_key)
-            csv_writer.writerow(data_value)
-
-        # Close file for writing
-        data_file.close()
+            # Write the dictionary information to CSV file
+            # Create deepcopy of input data_dict so zip processing in this function does NOT change the data_dict
+            temp_dict = copy.deepcopy(data_dict)
+            for data_key, data_value in zip(temp_dict.keys(), temp_dict.values()):
+                # Begin/prefix the data value with the data key
+                data_value.insert(0, data_key)
+                csv_writer.writerow(data_value)
 
         # Update file permissions
         os.chmod(output_csv_path_filename, stat.S_IREAD | stat.S_IWRITE)
@@ -625,7 +623,7 @@ class MinddataProfilingAnalyzer:
             logger.warning(warning_msg)
 
         # Save summary output dictionary to JSON output file (format#1)
-        with open(self._save_path, 'w') as save_file:
+        with os.fdopen(os.open(self._save_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as save_file:
             json.dump(summary_dict, save_file)
 
         os.chmod(self._save_path, stat.S_IREAD | stat.S_IWRITE)

mindspore/profiler/parser/minddata_pipeline_parser.py

@@ -166,7 +166,7 @@ class MinddataPipelineParser:
                 )
             op_id_info_cache[item.get('op_id')] = item
 
-        with open(self._save_path, 'w') as save_file:
+        with os.fdopen(os.open(self._save_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as save_file:
             csv_writer = csv.writer(save_file)
             csv_writer.writerow(self._col_names)
             self._parse_and_save_op_info(