mindspore 2.0.0a0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/profiler/parser/cpu_gpu_timeline_generator.py

@@ -165,10 +165,6 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
         """Load timeline data from file."""
         op_file_path = self._get_and_validate_path(
             self._output_op_execute_time_file_path)
-        activity_file_path = self._get_and_validate_path(
-            self._output_activity_execute_time_file_path)
-        activity_args_file_path = self._get_and_validate_path(
-            self._output_gpu_activity_info_file_path)
 
         timeline_list, communication_info = self._load_op_data(op_file_path, reduce_op_type)
         communication_info.sort(key=lambda x: float(x[2]))
@@ -198,15 +194,13 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
                                                                        factor_start_time_uint_to_duration)
         recompute_scope_name_time_list = self._get_scope_name_time_list(timeline_list, "recompute_Default",
                                                                         factor_start_time_uint_to_duration)
-
-        activity_timeline_list, cuda_compute_ops_timeline_list = self._load_activity_data( \
-            activity_file_path, activity_args_file_path)
+        cuda_op_timeline = self._load_activity_data()
 
         # Add AllReduce info to timeline temp list and sort by start time.
         if communication_info:
             logger.debug('Allreduce info found, Start adding info to timeline...')
             cluster_related_timeline = self._get_cluster_timeline(
-                timeline_list, cuda_compute_ops_timeline_list, communication_info, step_time_list)
+                timeline_list, cuda_op_timeline[1], communication_info, step_time_list)
             timeline_list.extend(cluster_related_timeline)
             timeline_list.extend(communication_info)
             timeline_list.sort(key=lambda x: float(x[self._start_time_idx]))
@@ -219,7 +213,7 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
         timeline_list.sort(key=lambda x: (float(x[self._start_time_idx])))
 
         # Add cuda activity timeline.
-        timeline_list.extend(activity_timeline_list)
+        timeline_list.extend(cuda_op_timeline[0])
         timeline_list.sort(key=lambda x: float(x[2]))
 
         return timeline_list
@@ -268,30 +262,38 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
 
         return op_timeline_list, communication_info
 
-    def _load_activity_data(self, activity_file_path, activity_args_file_path):
+    def _load_activity_data(self):
         """Load activity data from file"""
         activity_timeline_list = []
         cuda_compute_ops_timeline_list = []
         args_dict = {}
-        try:
-            with open(activity_args_file_path, 'r') as args_file:
-                csv_reader = csv.reader(args_file)
-                keys_list = next(csv_reader)
-                # keys_list format is: name, type, op_full_name, stream_id, block_dim, grid_dim, ...
-                self._activity_keys_list = keys_list[1:3] + keys_list[4:6]
-                for info in csv_reader:
-                    args_dict[info[0]] = info[1:3] + info[4:6]
-            with open(activity_file_path, 'r') as f_obj:
-                for line in f_obj:
-                    line_list = line.strip('\n').split(';')
-                    # concat activity args info.
-                    line_list += args_dict.get(line_list[0])
-                    if not line_list[0].startswith('nccl'):
-                        cuda_compute_ops_timeline_list.append(line_list)
-                    activity_timeline_list.append(line_list)
-        except (IOError, OSError) as err:
-            logger.critical('Error occurred when load activity timeline data intermediate file: %s', err)
-            raise ProfilerIOException()
+        activity_file_path = self._get_and_validate_path(
+            self._output_activity_execute_time_file_path)
+        activity_args_file_path = self._get_and_validate_path(
+            self._output_gpu_activity_info_file_path)
+
+        if not os.path.exists(activity_args_file_path):
+            logger.error(f'The file {activity_args_file_path} does not exist.')
+            raise ProfilerFileNotFoundException(activity_args_file_path)
+        with open(activity_args_file_path, 'r') as args_file:
+            csv_reader = csv.reader(args_file)
+            keys_list = next(csv_reader)
+            # keys_list format is: name, type, op_full_name, stream_id, block_dim, grid_dim, ...
+            self._activity_keys_list = keys_list[1:3] + keys_list[4:6]
+            for info in csv_reader:
+                args_dict[info[0]] = info[1:3] + info[4:6]
+
+        if not os.path.exists(activity_file_path):
+            logger.error(f'The file {activity_file_path} does not exist.')
+            raise ProfilerFileNotFoundException(activity_file_path)
+        with open(activity_file_path, 'r') as f_obj:
+            for line in f_obj:
+                line_list = line.strip('\n').split(';')
+                # concat activity args info.
+                line_list += args_dict.get(line_list[0])
+                if not line_list[0].startswith('nccl'):
+                    cuda_compute_ops_timeline_list.append(line_list)
+                activity_timeline_list.append(line_list)
 
         return activity_timeline_list, cuda_compute_ops_timeline_list
 
@@ -342,53 +344,56 @@ 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.
         """
-        step_num = len(step_info)
-        is_pipeline_parallel = False
-        comm_merged_timeline, _, comm_display_timeline = self._get_merged_time_list(
+        time_info = {"stage_time": [], "computation_time": [], "recieve_alone_time": [], "comm_alone_time": [],
+                     "collective_comm_alone_time": [], "comm_not_overlapped_timeline": [], "free_timeline": [],
+                     "collective_comm_not_overlapped_timeline": [], "comm_timeline": [], "compute_timeline": [],
+                     "receive_op_not_overlapped_timeline": [], "receive_op_timeline": [],
+                     "collective_comm_timeline": [], "receive_op_merged_timeline": [], "is_pipeline_parallel": False}
+        time_info["comm_timeline"] = self._get_merged_time_list(
             comm_info,
             display_name="communication",
             factor=1e-3
         )
         compute_op_timeline = timeline + activity_info
         compute_op_timeline.sort(key=lambda x: float(x[self._start_time_idx]))
-        compute_op_timeline_interval, _, compute_op_display_timeline = self._get_merged_time_list(
+        time_info["compute_timeline"] = self._get_merged_time_list(
             compute_op_timeline,
             get_interval_time=True,
             factor=1e-3
         )
         # Consider if the overlap will be 0 or not.
-        comm_not_overlapped_timeline = self._get_intersection_time(
-            compute_op_timeline_interval,
-            comm_merged_timeline
+        time_info["comm_not_overlapped_timeline"] = self._get_intersection_time(
+            time_info.get("compute_timeline")[0],
+            time_info.get("comm_timeline")[0]
         )
 
         # Process receive part.
         all_timeline = timeline + comm_info
         all_timeline.sort(key=lambda x: float(x[self._start_time_idx]))
-        receive_op_timeline = self._produce_two_separated_timeline(
+        time_info["receive_op_timeline"] = self._produce_two_separated_timeline(
             all_timeline,
             "Receive-op"
         )[0]
-        if receive_op_timeline:
-            is_pipeline_parallel = True
-        receive_op_merged_timeline = self._get_merged_time_list(receive_op_timeline,
-                                                                factor=1e-3)[0]
-
-        receive_op_not_overlapped_timeline = self._get_intersection_time(
-            compute_op_timeline_interval,
-            receive_op_merged_timeline,
+        if time_info.get("receive_op_timeline"):
+            time_info["is_pipeline_parallel"] = True
+        time_info["receive_op_merged_timeline"] = self._get_merged_time_list(time_info.get("receive_op_timeline"),
+                                                                             factor=1e-3)[0]
+
+        time_info["receive_op_not_overlapped_timeline"] = self._get_intersection_time(
+            time_info.get("compute_timeline")[0],
+            time_info.get("receive_op_merged_timeline"),
             display_name="receive_op_not_overlapped"
         )
 
         # Process collective communication part.
-        collective_comm_timeline = self._produce_two_separated_timeline(
+        time_info["collective_comm_timeline"] = self._produce_two_separated_timeline(
             comm_info,
             "Receive-op"
         )[-1]
-        collective_comm_merged_timeline = self._get_merged_time_list(collective_comm_timeline,
+        collective_comm_merged_timeline = self._get_merged_time_list(time_info.get("collective_comm_timeline"),
                                                                      factor=1e-3)[0]
-        collective_comm_not_overlapped_timeline = self._get_intersection_time(
-            compute_op_timeline_interval,
+        time_info["collective_comm_not_overlapped_timeline"] = self._get_intersection_time(
+            time_info.get("compute_timeline")[0],
             collective_comm_merged_timeline,
             display_name="exclude_receive_op"
         )
@@ -396,7 +401,7 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
         # Generate free time that exclude computation and communication time.
         all_timeline = compute_op_timeline + comm_info
         all_timeline.sort(key=lambda x: float(x[self._start_time_idx]))
-        free_timeline = self._get_merged_time_list(
+        time_info["free_timeline"] = self._get_merged_time_list(
             all_timeline,
             get_interval_time=True,
             display_name="free_time",
@@ -404,33 +409,48 @@ class GpuTimelineGenerator(BaseTimelineGenerator):
         )[1]
 
         # Compute these five metrics mentioned above per step.
-        recieve_alone_time = self._compute_time_inside_step(receive_op_not_overlapped_timeline, step_info)
-        stage_time, computation_time = [], []
-        comm_alone_time = self._compute_time_inside_step(comm_not_overlapped_timeline, step_info)
-        collective_comm_alone_time = self._compute_time_inside_step(
-            collective_comm_not_overlapped_timeline,
+        time_info["recieve_alone_time"] = self._compute_time_inside_step(
+            time_info.get("receive_op_not_overlapped_timeline"), step_info)
+        time_info["comm_alone_time"] = self._compute_time_inside_step(time_info.get("comm_not_overlapped_timeline"),
+                                                                      step_info)
+        time_info["collective_comm_alone_time"] = self._compute_time_inside_step(
+            time_info.get("collective_comm_not_overlapped_timeline"),
             step_info
         )
+        step_num = len(step_info)
         for step in range(step_num):
             try:
-                if is_pipeline_parallel:
-                    stage_time.append(step_info[step][self._duration_idx] - recieve_alone_time[step])
-                computation_time.append(step_info[step][self._duration_idx] - comm_alone_time[step])
+                if time_info.get("is_pipeline_parallel"):
+                    time_info.get("stage_time").append(
+                        step_info[step][self._duration_idx] - time_info.get("recieve_alone_time")[step]
+                    )
+            except IndexError as e:
+                logger.error(e)
+            try:
+                time_info.get("computation_time").append(
+                    step_info[step][self._duration_idx] - time_info.get("comm_alone_time")[step]
+                )
             except IndexError as e:
                 logger.error(e)
 
-        metrices_per_step_list = [computation_time, comm_alone_time, stage_time,
-                                  recieve_alone_time, 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))
-        self._write_cluster_metrices(metrices_per_step_list, is_pipeline_parallel, "Gpu", self._device_id)
+        try:
+            self._write_cluster_metrices(metrices_per_step_list, time_info.get("is_pipeline_parallel"), "Gpu",
+                                         self._device_id)
+        except (IOError, OSError) as e:
+            logger.warning(e)
+            raise ProfilerIOException
 
         res_timeline = []
-        res_timeline.extend(comm_not_overlapped_timeline)
-        res_timeline.extend(compute_op_display_timeline)
-        res_timeline.extend(comm_display_timeline)
-        res_timeline.extend(free_timeline)
+        res_timeline.extend(time_info.get("comm_not_overlapped_timeline"))
+        res_timeline.extend(time_info.get("compute_timeline")[2])
+        res_timeline.extend(time_info.get("comm_timeline")[2])
+        res_timeline.extend(time_info.get("free_timeline"))
         return res_timeline
 
     def _compute_time_inside_step(self, metric_timeline, step_time_list):
@@ -637,28 +657,28 @@ class CpuTimelineGenerator(GpuTimelineGenerator):
         # factor to convert the time unit of start_time(ts) from 1ns to 1us for timeline display
         factor = 1000
         op_meta = TimelineContainer(timeline)
-        timeline_dict = {}
-        timeline_dict['name'] = op_meta.op_name.split('/')[-1]
-        timeline_dict['ph'] = 'X'
-        timeline_dict['tid'] = op_meta.stream_id
-        timeline_dict['ts'] = (op_meta.start_time - min_cycle_counter) / factor
+        timeline_info = {}
+        timeline_info['name'] = op_meta.op_name.split('/')[-1]
+        timeline_info['ph'] = 'X'
+        timeline_info['tid'] = op_meta.stream_id
+        timeline_info['ts'] = (op_meta.start_time - min_cycle_counter) / factor
         dur = op_meta.duration
-        timeline_dict['dur'] = dur
-        timeline_dict['pid'] = int(self._device_id)
+        timeline_info['dur'] = dur
+        timeline_info['pid'] = int(self._device_id)
         if op_meta.stream_id == "Scope Name":
             # remove the level of scope name which has a format like "0-conv2-Conv2d".
-            timeline_dict['name'] = "-".join(op_meta.op_name.split('-')[1:])
-            timeline_dict['scope_level'] = int(op_meta.op_name.split('-')[0])
+            timeline_info['name'] = "-".join(op_meta.op_name.split('-')[1:])
+            timeline_info['scope_level'] = int(op_meta.op_name.split('-')[0])
         elif self._host_cpu_op_label == op_meta.stream_id[:len(self._host_cpu_op_label)]:
-            timeline_dict['pid'] = self._HOST_CPU_PID
+            timeline_info['pid'] = self._HOST_CPU_PID
 
         if len(timeline) == 5:
             # len(timeline) == 5 refers to analyse data.
-            timeline_dict["pid"] = op_meta.pid
+            timeline_info["pid"] = op_meta.pid
         elif op_meta.stream_id not in ["Scope Name", "Steps"]:
             # Update total time of operator execution.
             self._timeline_summary['total_time'] += dur / factor
             self._timeline_summary['op_exe_times'] += 1
 
-        self._update_format_meta_data(timeline_dict)
-        self._timeline_meta.append(timeline_dict)
+        self._update_format_meta_data(timeline_info)
+        self._timeline_meta.append(timeline_info)

mindspore/profiler/parser/hwts_log_parser.py

@@ -94,7 +94,7 @@ class HWTSLogParser:
                 if HWTSLogParser.GRAPH_MODE_MAX_TASKID < last_task_stream_map.get(stream_id, task_id) \
                         and task_id < last_task_stream_map.get(stream_id, task_id):
                     flip_times += 1
-                task_id_str = str(stream_id) + "_" + str(task_id + flip_times * task_id_threshold)
+                task_id_str = ("%s_%s" % (str(stream_id), str(task_id + flip_times * task_id_threshold)))
                 result_data += ("%-14s %-4s %-8s %-9s %-8s %-15s %s\n" % (log_type[int(ms_type, 2)], cnt, core_id,
                                                                           blk_id, task_id_str, syscnt, stream_id))
                 last_task_stream_map[stream_id] = task_id

mindspore/profiler/parser/integrator.py

@@ -37,9 +37,8 @@ class Integrator:
     _file_name_aicore_detail_time = 'output_op_compute_time_{}.txt'
     _file_name_aicpu_time = 'output_data_preprocess_aicpu_{}.txt'
     _file_name_framework = 'framework_raw_{}.csv'
-    _header_aicore_type = ['op_type', 'execution_time', 'execution_frequency',
-                           'percent']
-    _header_aicore_detail = ['full_op_name', 'execution_time']
+    _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']
 
@@ -141,16 +140,17 @@ class Integrator:
                 op_name_type_cache[row[3]] = row[5]
 
         op_type_time_cache = {}
-        for full_op_name, op_time in self._op_time_cache.items():
+        total_time = 0
+        for full_op_name, op_info in self._op_time_cache.items():
+            total_time += op_info[0] * op_info[1]
             op_type = op_name_type_cache.get(full_op_name)
             op_type_time = op_type_time_cache.get(op_type)
             if not op_type_time:
-                op_type_time = [op_time, 1]
+                op_type_time = [op_info[0] * op_info[1], op_info[1]]
                 op_type_time_cache[op_type] = op_type_time
             else:
-                op_type_time[0] += op_time
-                op_type_time[1] += 1
-
+                op_type_time[0] += op_info[0] * op_info[1]
+                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:
@@ -158,10 +158,11 @@ class Integrator:
             csv_writer.writerow(self._header_aicore_type)
 
             for op_type, op_type_time_info in op_type_time_cache.items():
-                type_info = [
-                    op_type, op_type_time_info[0], op_type_time_info[1],
-                    round((op_type_time_info[0] / self._total_time) * 100, 2)
-                ]
+                if total_time != 0:
+                    type_info = [
+                        op_type, op_type_time_info[0], op_type_time_info[1],
+                        round((op_type_time_info[0] / total_time) * 100, 2)
+                    ]
                 csv_writer.writerow(type_info)
 
     def _parse_aicore_detail_time(self):
@@ -201,8 +202,8 @@ class Integrator:
                     if op_infos[0] == 'total':
                         self._total_time = Decimal(op_infos[2])
                         continue
-                    self._op_time_cache[op_infos[0]] = Decimal(op_infos[1])
-                    csv_writer.writerow([op_infos[0], op_infos[1]])
+                    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]])
 
     def _parse_aicpu_time(self):
         """Parse the parsed AICPU operator time file."""

mindspore/profiler/parser/minddata_analyzer.py

@@ -78,8 +78,8 @@ class MinddataProfilingAnalyzer:
         try:
             validated_dir = validate_and_normalize_path(dir_name)
         except RuntimeError as path_error:
-            logger.warning('<%s> <%s> is invalid.', dir_type, validated_dir)
-            raise ProfilerPathErrorException(dir_type + 'is invalid.') from path_error
+            logger.warning('<%s> is invalid.', dir_type)
+            raise ProfilerPathErrorException(dir_type + ' is invalid.') from path_error
 
         if not os.path.isdir(validated_dir):
             logger.warning('<%s> <%s> not found.', dir_type, validated_dir)

mindspore/profiler/parser/msadvisor_analyzer.py

@@ -43,32 +43,19 @@ class Msadvisor:
         output_path = validate_and_normalize_path(output_path)
         logger.info("MSAdvisor is running. Log and result files are saved in %s", output_path)
 
-        try:
-            subprocess.run(["msadvisor", "-d", output_path, "-c", "all"],
-                           capture_output=True, check=True)
-            logger.info("MSAdvisor process finished.")
+        subprocess.run(["msadvisor", "-d", output_path, "-c", "all"],
+                       capture_output=True, check=True)
+        logger.info("MSAdvisor process finished.")
 
-            # Modified recommendation file permission, only Owner can read and write.
-            recommendation_path = os.path.join(output_path, "recommendation")
-            recommendation_path = validate_and_normalize_path(recommendation_path)
-            os.chmod(recommendation_path, stat.S_IRWXU)
-            file_list = os.listdir(recommendation_path)
-            file_list.sort(key=lambda fn: os.path.getmtime(os.path.join(recommendation_path, fn)))
-            recommendation_path = os.path.join(recommendation_path, file_list[-1])
-            recommendation_path = validate_and_normalize_path(recommendation_path)
-            os.chmod(recommendation_path, stat.S_IRUSR | stat.S_IWUSR)
-        except FileNotFoundError as err:
-            logger.warning("MSAdvisor: command not found,"
-                           "please check if installed ascend-toolkit and set environment path correctly.")
-            raise err
-        except OSError as err:
-            logger.warning("Cannot execute binary file: Exec format error.")
-            raise err
-        except subprocess.CalledProcessError:
-            logger.warning("MSAdvisor running failed,"
-                           "please check MSAdvisor running log.")
-        finally:
-            pass
+        # Modified recommendation file permission, only Owner can read and write.
+        recommendation_path = os.path.join(output_path, "recommendation")
+        recommendation_path = validate_and_normalize_path(recommendation_path)
+        os.chmod(recommendation_path, stat.S_IRWXU)
+        file_list = os.listdir(recommendation_path)
+        file_list.sort(key=lambda fn: os.path.getmtime(os.path.join(recommendation_path, fn)))
+        recommendation_path = os.path.join(recommendation_path, file_list[-1])
+        recommendation_path = validate_and_normalize_path(recommendation_path)
+        os.chmod(recommendation_path, stat.S_IRUSR | stat.S_IWUSR)
 
         # Modified log file permission, only Owner can read and write.
         log_path = os.path.join(output_path, "log")

mindspore/profiler/parser/msadvisor_parser.py

@@ -85,9 +85,7 @@ class MsadvisorParser:
         task_type = "AI_CORE"
 
         try:
-            ts = float(op[2]) * MS_TO_US
-            dur = float(op[3]) * MS_TO_US
-            sid = float(op[1])
+            ts, dur, sid = float(op[2]) * MS_TO_US, float(op[3]) * MS_TO_US, float(op[1])
         except ValueError as err:
             logger.warning("The aicore timeline file content is abnormal. Failed to format aicore timeline file")
             raise err
@@ -192,7 +190,7 @@ class MsadvisorParser:
                     if tid == 1:
                         self._time_start = op.get("ts")
                     total_duration = op.get("ts") - self._time_start
-                    if total_duration > 1*MIN_TO_US or tid > 10000:
+                    if total_duration > 1 * MIN_TO_US or tid > 10000:
                         self._time_end = op.get("ts")
                         break
                     if tid > 1:

mindspore/profiler/parser/optime_parser.py

@@ -36,7 +36,7 @@ class OPComputeTimeParser:
     """
 
     _dst_file_title = 'title:op compute time'
-    _dst_file_column_title = 'op_name       compute_time(ms) stream_id'
+    _dst_file_column_title = 'op_name       compute_time(ms) stream_id execution_times'
     _dst_file_column_title += '\n------------  ---------------  ---------'
 
     def __init__(self, hwts_output_file, output_filename, op_task_info,
@@ -77,8 +77,7 @@ class OPComputeTimeParser:
             op_duration_str = str(item.duration / factor)
             if op_name in op_name_time_dict.keys():
                 op_name_time_dict[op_name] += op_duration
-                if item.task_id == op_name_task_dict[op_name]:
-                    op_name_count_dict[op_name] += 1
+                op_name_count_dict[op_name] += 1
                 op_name_start_time[op_name].append(
                     (op_start_time_str, op_duration_str)
                 )
@@ -120,7 +119,7 @@ class OPComputeTimeParser:
                     raise ValueError("The number of operations can not be 0.")
                 avg_time = time / op_name_count_dict.get(op_name)
                 total_time += avg_time
-                result_data += ("%s %s  %s\n" % (op_name, str(avg_time), stream_id))
+                result_data += ("%s %s %s %s\n" % (op_name, str(avg_time), stream_id, op_name_count_dict.get(op_name)))
         result_data += ("total op  %s 0" % (str(total_time)))
 
         timeline_data = []
@@ -225,25 +224,25 @@ class OPComputeTimeParser:
         """
         tmp_result_data = []
         op_map_list = self._get_op_task_id_map()
+        tmp_op_dict = dict()
 
         cur_index = 0
         length = len(op_map_list)
         min_cycle_counter = float("inf")
         while cur_index < length:
-            if cur_index + 1 == length:
-                break
-
-            op_start = op_map_list[cur_index]
-            op_end = op_map_list[cur_index + 1]
-            if op_start.status == "Start" and op_end.status == "End" \
-                    and op_start.op_name == op_end.op_name:
-                op_start.duration = op_end.cycle_counter - op_start.cycle_counter
-                tmp_result_data.append(op_start)
-                cur_index += 2
-                if not op_start.op_name.startswith("assign"):
-                    min_cycle_counter = min(min_cycle_counter, op_start.cycle_counter)
-            else:
-                cur_index += 1
+            op_time = op_map_list[cur_index]
+            if op_time.status == "Start":
+                tmp_op_dict[op_time.op_name] = op_time
+            elif op_time.status == "End" and op_time.op_name in tmp_op_dict:
+                op_start = tmp_op_dict.get(op_time.op_name, None)
+                if op_start:
+                    op_start.duration = op_time.cycle_counter - op_start.cycle_counter
+                    tmp_result_data.append(op_start)
+                    del tmp_op_dict[op_time.op_name]
+            if not op_time.op_name.startswith("assign"):
+                min_cycle_counter = min(min_cycle_counter, op_time.cycle_counter)
+
+            cur_index += 1
 
         # Update the value of minimum cycle counter.
         self._min_cycle_counter = min_cycle_counter / 1e5  # Convert the time unit from 10ns to 1ms

mindspore/profiler/parser/profiler_info.py

@@ -17,6 +17,7 @@ import json
 import os
 import stat
 
+from mindspore.version import __version__ as ms_version
 from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
 
 
@@ -34,9 +35,9 @@ class ProfilerInfo:
     @staticmethod
     def init_info(context_mode, rank_id):
         """Profiler info initialization must include context_mode, rank_id and output_path."""
-        ProfilerInfo._profiler_info_dict = dict()
         ProfilerInfo._profiler_info_dict["context_mode"] = context_mode
         ProfilerInfo._profiler_info_dict["rank_id"] = rank_id
+        ProfilerInfo._profiler_info_dict["ms_version"] = ms_version
         ProfilerInfo._file_name = ProfilerInfo._file_name.format(rank_id)
 
     @staticmethod