mindspore 2.1.0__cp38-none-any.whl → 2.2.11__cp38-none-any.whl

mindspore/profiler/parser/base_timeline_generator.py

@@ -198,7 +198,7 @@ class BaseTimelineGenerator:
         display_file_path = validate_and_normalize_path(display_file_path)
 
         try:
-            with os.fdopen(os.open(display_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660), 'w') as json_file:
+            with os.fdopen(os.open(display_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as json_file:
                 json_file.write('[')
                 for _, item in enumerate(self._timeline_meta):
                     json.dump(item, json_file)
@@ -216,7 +216,7 @@ class BaseTimelineGenerator:
             return self._timeline_meta
         except (IOError, OSError) as err:
             logger.critical('Error occurred when write timeline display file: %s', err)
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
     def write_timeline_summary(self):
         """Write timeline summary to json."""
@@ -229,11 +229,11 @@ class BaseTimelineGenerator:
 
         try:
             with os.fdopen(os.open(timeline_summary_file_path,
-                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660), 'w') as json_file:
+                                   os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as json_file:
                 json.dump(self._timeline_summary, json_file)
         except (IOError, OSError) as err:
             logger.critical('Error occurred when write timeline summary file: %s', err)
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
         if os.path.exists(timeline_summary_file_path):
             os.chmod(timeline_summary_file_path, stat.S_IREAD | stat.S_IWRITE)
 
@@ -315,7 +315,7 @@ class BaseTimelineGenerator:
         tid_name = timeline_dict['tid']
         sort_index = 0
 
-        if tid_name in self._map_tid_name_to_int.keys():
+        if tid_name in self._map_tid_name_to_int:
             sort_index, tid = self._map_tid_name_to_int.get(tid_name)
         elif tid_name.startswith("Stream"):
             tid = int(tid_name.split("#")[-1])
@@ -450,12 +450,14 @@ class BaseTimelineGenerator:
         )
         cluster_analyse_file_path = validate_and_normalize_path(cluster_analyse_file_path)
 
-        with os.fdopen(os.open(cluster_analyse_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660),
+        with os.fdopen(os.open(cluster_analyse_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
                        'w') as file_handle:
             csv_writer = csv.writer(file_handle)
             if is_pipeline_parallel:
-                header = ['computation_time', 'communication_alone_time', 'stage_time',
-                          'receive_alone_time', 'collective_communication_alone_time']
+                header = [
+                    'computation_time', 'communication_alone_time', 'stage_time',
+                    'receive_alone_time', 'collective_communication_alone_time'
+                ]
                 zip_metrices = zip(metrices[0], metrices[1], metrices[2], metrices[3], metrices[4])
             else:
                 header = ['computation_time', 'communication_alone_time']

mindspore/profiler/parser/cpu_gpu_timeline_generator.py

@@ -231,7 +231,7 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
                 gpu_start_time = int(lines[1].strip().split(':')[-1])
         except (IOError, OSError) as err:
             logger.critical(f'Error occurred when read {start_time_file_path}: {err}')
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
         time_diff = gpu_start_time - host_monotonic_start_time
         for idx, time_item in enumerate(timeline_list):
@@ -258,7 +258,7 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
                             communication_info.append(line_list)
         except (IOError, OSError) as err:
             logger.critical('Error occurred when load operator timeline data intermediate file: %s', err)
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
         return op_timeline_list, communication_info
 
@@ -324,7 +324,7 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
                     step_num += 1
         except (IOError, OSError) as err:
             logger.critical(f'Error occurred when read {step_trace_profiling_path}: {err}')
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
         return step_time_list
 
@@ -344,8 +344,10 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
         communication time between stages slow down the training. The value of t3 indicates the degree
         that communication inside each stage slow down the training.
         """
-        time_info = {"stage_time": [], "computation_time": [], "recieve_alone_time": [], "comm_alone_time": [],
-                     "collective_comm_alone_time": []}
+        time_info = {
+            "stage_time": [], "computation_time": [], "recieve_alone_time": [], "comm_alone_time": [],
+            "collective_comm_alone_time": []
+        }
         is_pipeline_parallel = False
         comm_timeline = self._get_merged_time_list(
             comm_info,
@@ -429,9 +431,11 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
             except IndexError as e:
                 logger.error(e)
 
-        metrices_per_step_list = [time_info.get("computation_time"), time_info.get("comm_alone_time"),
-                                  time_info.get("stage_time"), time_info.get("recieve_alone_time"),
-                                  time_info.get("collective_comm_alone_time")]
+        metrices_per_step_list = [
+            time_info.get("computation_time"), time_info.get("comm_alone_time"),
+            time_info.get("stage_time"), time_info.get("recieve_alone_time"),
+            time_info.get("collective_comm_alone_time")
+        ]
         if step_num > 1:
             for metric in metrices_per_step_list:
                 metric.append(sum(metric[1:]) / (step_num - 1))
@@ -439,7 +443,7 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
             self._write_cluster_metrices(metrices_per_step_list, is_pipeline_parallel, "Gpu", self._device_id)
         except (IOError, OSError) as err:
             logger.warning(err)
-            raise ProfilerIOException
+            raise ProfilerIOException from err
 
         res_timeline = []
         res_timeline.extend(comm_not_overlapped_timeline)
@@ -493,9 +497,9 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
             )
             if intersection_start < intersection_end:
                 intersection_segment_display_list.append(
-                    [display_name, self._tid_dict[display_name][0],
+                    [display_name, self._tid_dict.get(display_name, ('',))[0],
                      intersection_start, (intersection_end - intersection_start) * factor_ns_to_us,
-                     self._tid_dict[display_name][1]]
+                     self._tid_dict.get(display_name, ('', ''))[1]]
                 )
             if first_time_list[first_list_idx][self._duration_idx] >= \
                     second_time_list[second_list_idx][self._duration_idx]:
@@ -604,7 +608,7 @@ class CpuTimelineGenerator(GpuTimelineGenerator):
                         op_timeline_list.append(line_list)
         except (IOError, OSError) as err:
             logger.critical('Error occurred when load operator timeline data intermediate file: %s', err)
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
         return op_timeline_list
 

mindspore/profiler/parser/flops_parser.py

@@ -181,7 +181,7 @@ class FlopsParser:
         sum_flops_utilization = 0.0
         # calculate the every step FLOPS utilization and the average values.
         utilization_save_filename = os.path.join(self._output_dir, self._flops_utilization_step_filename)
-        with open(utilization_save_filename, 'w') as f:
+        with os.fdopen(os.open(utilization_save_filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as f:
             f.write("steps, FLOPS_Utilization %\n")
             for i, x in enumerate(op_all_step_comp):
                 current_utilization = x[0] / x[1] * 1e9 / peak_flops * 100
@@ -190,6 +190,8 @@ class FlopsParser:
                 f.write(",")
                 f.write(str(current_utilization))
                 f.write("\n")
+        os.chmod(utilization_save_filename, stat.S_IREAD | stat.S_IWRITE)
+
         if len(op_all_step_comp) >= 1:
             self._flops_summary['FLOPS_Utilization'] = sum_flops_utilization / len(op_all_step_comp)
         else:
@@ -222,7 +224,7 @@ class FlopsParser:
                 all_log_struct = aicore_file.read(self.AICORE_LOG_SIZE * read_count)
         except (IOError, OSError) as err:
             logger.critical(f'Error occurred when read {aicore_file_path} file: {err}')
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
         return read_count, all_log_struct
 
@@ -246,7 +248,7 @@ class FlopsParser:
                 peak_flops = device_frequency * 1e6 * ai_core_num * 4096 * 2
         except (IOError, OSError, json.JSONDecodeError) as err:
             logger.critical(f'Error occurred when read {info_json_file_path} file: {err}')
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
         return peak_flops
 
@@ -304,7 +306,7 @@ class FlopsParser:
                     op_avg_time_dict[op_name] = avg_time
         except (IOError, OSError) as err:
             logger.critical(f'Error occurred when read {optime_file_path} file: {err}')
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
         return op_avg_time_dict
 
@@ -317,7 +319,7 @@ class FlopsParser:
         For op_name like "Default/network", the "network" will be renamed as "network(Default)".
         For op_name like "recompute_Default/network", "network" --> "network(recompute_Default)".
         For op_name like "Gradients/network", "network" --> "network(Gradients)".
-        For op_name like "Gradients/recompute_Default/network"，"network" --> "network(recompute_Gradients)".
+        For op_name like "Gradients/recompute_Default/network", "network" --> "network(recompute_Gradients)".
         """
         # Only extracts the scope name, remove the operator name.
         scope_list = op_name.split('/')[:-1]
@@ -387,7 +389,7 @@ class FlopsParser:
         output_flops_scope_file_path = join_file_path(self._flops_scope_filename)
 
         try:
-            with open(output_file_path, 'w') as f:
+            with os.fdopen(os.open(output_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as f:
                 header = "op_full_name, MFLOPs(10^6), GFLOPS(10^9), FLOPS utilization(%) \n"
                 f.writelines(header)
                 for op_flops in op_flops_list:
@@ -396,25 +398,27 @@ class FlopsParser:
             os.chmod(output_file_path, stat.S_IREAD | stat.S_IWRITE)
         except (IOError, OSError) as err:
             logger.critical(f'Error occurred when writing {output_file_path} file: {err}')
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
         for key in self._flops_summary:
             self._flops_summary[key] = round(self._flops_summary[key], 3)
         try:
-            with open(output_summary_file_path, 'w') as json_file:
+            with os.fdopen(os.open(output_summary_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
+                           'w') as json_file:
                 json.dump(self._flops_summary, json_file)
             os.chmod(output_summary_file_path, stat.S_IREAD | stat.S_IWRITE)
         except (IOError, OSError) as err:
             logger.critical(f'Error occurred when write {output_summary_file_path} file: {err}')
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
         try:
-            with open(output_flops_scope_file_path, 'w') as json_file:
+            with os.fdopen(os.open(output_flops_scope_file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600),
+                           'w') as json_file:
                 json.dump(self._flops_sankey_diagram, json_file)
             os.chmod(output_flops_scope_file_path, stat.S_IREAD | stat.S_IWRITE)
         except (IOError, OSError) as err:
             logger.critical(f'Error occurred when write {output_flops_scope_file_path} file: {err}')
-            raise ProfilerIOException()
+            raise ProfilerIOException() from err
 
     def _get_aicore_files(self, profiler_dir):
         """Get aicore files."""

mindspore/profiler/parser/framework_parser.py

@@ -17,6 +17,7 @@ import csv
 import glob
 import json
 import os
+import stat
 import re
 import struct
 from collections import defaultdict
@@ -52,8 +53,10 @@ TASK_TYPE_TO_KERNEL_TYPE = {
     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']
+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)
 
 
@@ -222,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):
@@ -545,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."""
@@ -570,13 +578,15 @@ class GpuFrameWorkParser:
                 op_occurrences = int(op_detail[0])
                 op_total_time = float(op_detail[1])
                 op_avg_time = float(op_detail[2])
-                if op_shape in op_shape_dict.keys():
+                if op_shape in op_shape_dict:
                     # Classify according to the operator information of the same shape.
                     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]
 
@@ -669,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."""
@@ -724,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")
@@ -737,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:
@@ -788,8 +803,9 @@ 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, op_summary):
         """Obtain the execution time of aicpu operator and aicore operator."""

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

@@ -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

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(

mindspore/profiler/parser/msadvisor_parser.py

@@ -92,8 +92,10 @@ class MsadvisorParser:
         finally:
             pass
 
-        op = {"name": name, "pid": pid, "ts": ts, "dur": dur,
-              "args": {"Task Type": task_type, "Stream Id": sid, "Task Id": tid}, "ph": "X"}
+        op = {
+            "name": name, "pid": pid, "ts": ts, "dur": dur,
+            "args": {"Task Type": task_type, "Stream Id": sid, "Task Id": tid}, "ph": "X"
+        }
         return op
 
     @staticmethod
@@ -127,8 +129,10 @@ class MsadvisorParser:
         finally:
             pass
 
-        op = {"name": name, "pid": pid, "ts": ts, "dur": dur,
-              "args": {"Task Type": task_type, "Stream Id": sid, "Task Id": tid}, "ph": "X"}
+        op = {
+            "name": name, "pid": pid, "ts": ts, "dur": dur,
+            "args": {"Task Type": task_type, "Stream Id": sid, "Task Id": tid}, "ph": "X"
+        }
         return op
 
     def get_input_file(self):