mindspore 2.2.0__cp37-cp37m-manylinux1_x86_64.whl → 2.2.11__cp37-cp37m-manylinux1_x86_64.whl

mindspore/profiler/parser/ascend_msprof_generator.py

@@ -20,7 +20,7 @@ import os
 import numpy as np
 
 
-class AscendMsprofDataGenerator:
+class AscendMsprofDataGeneratorOld:
     """Generate ascend data from files."""
 
     def __init__(self, source_path):
@@ -47,10 +47,15 @@ class AscendMsprofDataGenerator:
             'Output Data Types': {'index': self.invalid_index, 'dtype': ('Output Data Types', object)},
             'Output Formats': {'index': self.invalid_index, 'dtype': ('Output Formats', object)},
         }
-        self.op_summary_extend_name = {
+        self.op_summaryA_extend_name = {
             'vector_fops': {'index': self.invalid_index, 'dtype': ('vector_fops', float)},
             'cube_fops': {'index': self.invalid_index, 'dtype': ('cube_fops', float)},
         }
+
+        self.op_summaryB_extend_name = {
+            'aiv_vector_fops': {'index': self.invalid_index, 'dtype': ('vector_fops', float)},
+            'aic_cube_fops': {'index': self.invalid_index, 'dtype': ('cube_fops', float)},
+        }
         self.op_summary_name = None
 
         self.op_statistic_name = {
@@ -110,10 +115,15 @@ class AscendMsprofDataGenerator:
                 iteration = int(file.split('_')[-1].split('.')[0])
                 reader = csv.reader(csvfile, delimiter=',', quotechar='"')
                 header = next(reader)
-                self.link_index_with_name(header, self.op_summary_basis_name)
-                extend_flag = self.link_index_with_name(header, self.op_summary_extend_name)
-                if extend_flag:
-                    self.op_summary_name = {**self.op_summary_basis_name, **self.op_summary_extend_name}
+                flag = self.link_index_with_name(header, self.op_summary_basis_name)
+                if not flag:
+                    raise RuntimeError("Read op summary failed. The file is missing basic fields.")
+                extend_flag_A = self.link_index_with_name(header, self.op_summaryA_extend_name)
+                extend_flag_B = self.link_index_with_name(header, self.op_summaryB_extend_name)
+                if extend_flag_A:
+                    self.op_summary_name = {**self.op_summary_basis_name, **self.op_summaryA_extend_name}
+                elif extend_flag_B:
+                    self.op_summary_name = {**self.op_summary_basis_name, **self.op_summaryB_extend_name}
                 else:
                     self.op_summary_name = self.op_summary_basis_name
                 self.op_summary_name['Iteration ID'] = {'index': -1, 'dtype': ('Iteration ID', object)}
@@ -137,7 +147,9 @@ class AscendMsprofDataGenerator:
             with open(file, newline='') as csvfile:
                 reader = csv.reader(csvfile, delimiter=',', quotechar='"')
                 header = next(reader)
-                self.link_index_with_name(header, self.op_statistic_name)
+                flag = self.link_index_with_name(header, self.op_statistic_name)
+                if not flag:
+                    raise RuntimeError("Read op summary failed. The file is missing basic fields.")
                 for row in reader:
                     row = [row[index.get('index')] for index in self.op_statistic_name.values()]
                     row = ['0' if i == 'N/A' else i for i in row]
@@ -155,7 +167,9 @@ class AscendMsprofDataGenerator:
             with open(file, newline='') as csvfile:
                 reader = csv.reader(csvfile, delimiter=',', quotechar='"')
                 header = next(reader)
-                self.link_index_with_name(header, self.steptrace_name)
+                flag = self.link_index_with_name(header, self.steptrace_name)
+                if not flag:
+                    raise RuntimeError("Read op summary failed. The file is missing basic fields.")
                 for row in reader:
                     rows = [row[index.get('index')] for index in self.steptrace_name.values()]
                     if row[9:]:
@@ -182,7 +196,7 @@ class AscendMsprofDataGenerator:
         for i in range(len(self.steptrace_name), len(header), 2):
             name = f'hccl_{i}'
             self.steptrace_name[name] = {'index': i, 'dtype': (name, float)}
-            self.steptrace_name[f'{name} duration'] = {'index': i+1, 'dtype': (f'{name} duration', float)}
+            self.steptrace_name[f'{name} duration'] = {'index': i + 1, 'dtype': (f'{name} duration', float)}
 
         steptrace_dt = np.dtype([value['dtype'] for value in self.steptrace_name.values()])
 
@@ -197,3 +211,176 @@ class AscendMsprofDataGenerator:
 
         for name in self.steptrace.dtype.names[9:]:
             self.steptrace[name] = self.steptrace[name] * 1e-3
+
+
+class AscendMsprofDataGenerator:
+    """Generate ascend data from files."""
+
+    def __init__(self, source_path):
+        self.source_path = source_path
+        self.op_summary = None
+        self.op_statistic = None
+        self.steptrace = []
+
+        self.op_summary_type = [
+            ('Model ID', int),
+            ('Task ID', int),
+            ('Stream ID', int),
+            ('Op Name', object),
+            ('Op Type', object),
+            ('Task Type', object),
+            ('Task Start Time', float),
+            ('Task Duration', float),
+            ('Task Wait Time', float),
+            ('Input Shapes', object),
+            ('Input Data Types', object),
+            ('Input Formats', object),
+            ('Output Shapes', object),
+            ('Output Data Types', object),
+            ('Output Formats', object)
+        ]
+
+        self.op_statistic_type = [
+            ('Op Type', object),
+            ('Count', int),
+            ('Total Time', float),
+        ]
+
+        self.steptrace_type = [
+            ('Iteration ID', int),
+            ('FP Start', float),
+            ('BP End', float),
+            ('Iteration End', float),
+            ('Iteration Time', float),
+            ('FP to BP Time', float),
+            ('Iteration Refresh', float),
+            ('Data Aug Bound', float),
+            ('Model ID', int),
+        ]
+
+    @staticmethod
+    def find_files(directory, pattern):
+        """Find files with feature 'pattern' from the directory"""
+
+        for root, _, files in os.walk(directory):
+            files.sort(key=lambda x: os.path.getctime(os.path.join(directory, x)))
+            for basename in files:
+                if fnmatch.fnmatch(basename, pattern):
+                    filename = os.path.join(root, basename)
+                    yield filename
+
+    def parse(self):
+        """read msprof data generate DataFrame data"""
+        self._read_op_summary()
+
+        self._read_op_statistic()
+
+        self._read_steptrace()
+
+        return self.op_summary, self.op_statistic, self.steptrace
+
+    def _read_op_summary(self):
+        """read op summary to memory"""
+        op_summary = []
+        for file in self.find_files(self.source_path, "op_summary*.csv"):
+            with open(file, newline='') as csvfile:
+                reader = csv.DictReader(csvfile, delimiter=',', quotechar='"')
+                for row in reader:
+                    vector_fops = row.get('vector_fops', None)
+                    cube_fops = row.get('cube_fops', None)
+                    aiv_vector_fops = row.get('aiv_vector_fops', None)
+                    aic_cube_fops = row.get('aic_cube_fops', None)
+
+                    new_row = [
+                        row.get('Model ID'),
+                        row.get('Task ID'),
+                        row.get('Stream ID'),
+                        row.get('Op Name'),
+                        row.get('OP Type'),
+                        row.get('Task Type'),
+                        row.get('Task Start Time(us)'),
+                        row.get('Task Duration(us)'),
+                        row.get('Task Wait Time(us)'),
+                        row.get('Input Shapes'),
+                        row.get('Input Data Types'),
+                        row.get('Input Formats'),
+                        row.get('Output Shapes'),
+                        row.get('Output Data Types'),
+                        row.get('Output Formats')
+                    ]
+
+                    if vector_fops is not None and cube_fops is not None:
+                        new_row.append(vector_fops)
+                        new_row.append(cube_fops)
+
+                    elif aic_cube_fops is not None and aiv_vector_fops is not None:
+                        new_row.append(aiv_vector_fops)
+                        new_row.append(aic_cube_fops)
+
+                    new_row = tuple(['0' if d == 'N/A' else d for d in new_row])
+                    op_summary.append(new_row)
+            break
+
+        if op_summary and len(op_summary[0]) > len(self.op_summary_type):
+            self.op_summary_type.extend([
+                ('vector_fops', float),
+                ('cube_fops', float)
+            ])
+        op_summary_dt = np.dtype(self.op_summary_type)
+
+        self.op_summary = np.array(op_summary, dtype=op_summary_dt)
+        self.op_summary['Task Start Time'] *= 1e-3
+        self.op_summary['Task Duration'] *= 1e-3
+        self.op_summary['Task Wait Time'] *= 1e-3
+
+    def _read_op_statistic(self):
+        """read op statistic to memory"""
+        op_statistic = []
+        for file in self.find_files(self.source_path, "op_statistic*.csv"):
+            with open(file, newline='') as csvfile:
+                reader = csv.DictReader(csvfile, delimiter=',', quotechar='"')
+                for row in reader:
+                    new_row = (
+                        row.get('OP Type'),
+                        row.get('Count'),
+                        row.get('Total Time(us)'),
+                    )
+                    new_row = tuple(['0' if d == 'N/A' else d for d in new_row])
+                    op_statistic.append(new_row)
+            break
+
+        op_statistic_dt = np.dtype(self.op_statistic_type)
+        self.op_statistic = np.array(op_statistic, dtype=op_statistic_dt)
+        self.op_statistic['Total Time'] *= 1e-3
+
+    def _read_steptrace(self):
+        """read steptrace to memory"""
+        steptrace = []
+        for file in self.find_files(self.source_path, "step_trace*.csv"):
+            with open(file, newline='') as csvfile:
+                reader = csv.DictReader(csvfile, delimiter=',', quotechar='"')
+                for row in reader:
+                    new_row = [
+                        row.get('Iteration ID'),
+                        row.get('FP Start(us)'),
+                        row.get('BP End(us)'),
+                        row.get('Iteration End(us)'),
+                        row.get('Iteration Time(us)'),
+                        row.get('FP to BP Time(us)'),
+                        row.get('Iteration Refresh(us)'),
+                        row.get('Data Aug Bound(us)'),
+                        row.get('Model ID'),
+                    ]
+                    new_row = ['0' if i == 'N/A' else i for i in new_row]
+                    steptrace.append(tuple(new_row))
+
+        steptrace_dt = np.dtype(self.steptrace_type)
+
+        self.steptrace = np.array(steptrace, dtype=steptrace_dt)
+        self.steptrace['FP Start'] = self.steptrace['FP Start'] * 1e-3
+        self.steptrace['BP End'] = self.steptrace['BP End'] * 1e-3
+        self.steptrace['Iteration End'] = self.steptrace['Iteration End'] * 1e-3
+        self.steptrace['Iteration Time'] = self.steptrace['Iteration Time'] * 1e-3
+        self.steptrace['FP to BP Time'] = self.steptrace['FP to BP Time'] * 1e-3
+        self.steptrace['Iteration Refresh'] = self.steptrace['Iteration Refresh'] * 1e-3
+        self.steptrace['Data Aug Bound'] = self.steptrace['Data Aug Bound'] * 1e-3

mindspore/profiler/parser/ascend_op_generator.py

@@ -124,7 +124,7 @@ class AscendOPGenerator:
                     writer.writerows(self.aicpu_detail.tolist())
             except (IOError, OSError) as err:
                 logging.critical('Errot occurred when write aicpu detail file: %s', err)
-                raise ProfilerIOException()
+                raise ProfilerIOException() from err
             if os.path.exists(aicpu_intermediate_detail_path):
                 os.chmod(aicpu_intermediate_detail_path, stat.S_IREAD | stat.S_IWRITE)
 

mindspore/profiler/parser/ascend_timeline_generator.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 # ============================================================================
 """The integrator for integrating parsed profiling files."""
-import os
 
 import numpy as np
 from mindspore import log as logger
@@ -22,7 +21,6 @@ from mindspore.profiler.parser.base_timeline_generator import BaseTimelineGenera
 from mindspore.profiler.parser.container import TimelineContainer
 from mindspore.profiler.parser.cpu_gpu_timeline_generator import CpuTimelineGenerator
 from mindspore.profiler.parser.integrator import DeviceTarget
-from mindspore.profiler.parser.op_intermediate_parser import OPIntermediateParser
 
 
 class AscendTimelineGenerator(BaseTimelineGenerator):
@@ -51,16 +49,6 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
             [('Op Name', object), ('Stream ID', int), ('Task Start Time', float), ('Task Duration', float),
              ('pid', int)])
 
-    @staticmethod
-    def _get_all_reduce_names(communication_info):
-        names = []
-        for info in communication_info:
-            # all_reduce_name format: stream_stream_id_stream_op_index_opname
-            all_reduce_name = info[0][info[0].rindex('_') + 1:]
-            if all_reduce_name not in names:
-                names.append(all_reduce_name)
-        return names
-
     def init_timeline(self, op_summary, steptrace):
         """
         Init timeline metadata, adding all collected info.
@@ -160,49 +148,19 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
         self._timeline_meta = self._format_meta_data_list
 
         # Update timeline summary info
-        timeline_summary = op_summary[np.isin(op_summary['Task Type'], ['AI_CORE', 'AI_CPU', 'HCCL'])][[
-            'Op Name', 'Stream ID', 'Task Duration']]
+        timeline_summary = op_summary[['Op Name', 'Stream ID', 'Task Duration']]
         self._timeline_summary['total_time'] = np.sum(timeline_summary['Task Duration'])
         self._timeline_summary['num_of_streams'] = int(
             len(np.unique(timeline_summary['Stream ID'], return_counts=True)[0]))
         self._timeline_summary['num_of_ops'] = int(len(np.unique(timeline_summary['Op Name'], return_counts=True)[0]))
         self._timeline_summary['op_exe_times'] = int(len(timeline_summary))
-        self._timeline_summary['max_scope_name_num'] = int(np.max(
-            [len(x) for x in np.char.split(timeline_summary['Op Name'].astype(str), sep='/')]))
+        if self._timeline_summary['op_exe_times'] != 0:
+            self._timeline_summary['max_scope_name_num'] = int(np.max(
+                [len(x) for x in np.char.split(timeline_summary['Op Name'].astype(str), sep='/')]))
+        else:
+            self._timeline_summary['max_scope_name_num'] = 0
         logger.info('Finished adding info into timeline...')
 
-    def init_pynative_timeline(self):
-        """Init timeline for pynative model."""
-        timeline_list = OPIntermediateParser(self._profiling_dir, self._rank_id).get_timeline_data()
-        cpu_timeline_generator = CpuTimelineGenerator(self._profiling_dir, self._rank_id, self._model)
-        cpu_timeline_list = cpu_timeline_generator.load_cpu_op_data()
-        if cpu_timeline_list:
-            self._pynative_clock_synchronize(cpu_timeline_list)
-            timeline_list.extend(cpu_timeline_list)
-
-        self._register_op_name(timeline_list)
-        self._timeline_summary['op_exe_times'] = len(timeline_list)
-        self._max_scope_name_num = self._get_max_scope_name_num(timeline_list)
-        self._timeline_summary['max_scope_name_num'] = self._max_scope_name_num
-        self._timeline_summary['num_of_ops'] = len(self._op_name_list)
-
-        timeline_list.sort(key=lambda x: float(x[self._start_time_idx]))
-        min_cycle_counter = float(timeline_list[0][self._start_time_idx])
-
-        step_timeline = self._pynative_get_step_timeline_list(timeline_list)
-        timeline_list.extend(step_timeline)
-
-        stream_count_dict = {}
-        max_scope_name_num = 0
-        for timeline in timeline_list:
-            self._parse_timeline_data(timeline, min_cycle_counter)
-            self._update_num_of_streams(timeline, stream_count_dict)
-            cur_scope_name_num = len(timeline[self._op_name_idx].split('/')) - 1
-            max_scope_name_num = max(cur_scope_name_num, max_scope_name_num)
-
-        self._timeline_summary['max_scope_name_num'] = max_scope_name_num
-        self._timeline_summary['num_of_streams'] = len(stream_count_dict)
-
     def _parse_timeline_data(self, timeline, min_cycle_counter):
         """Parse timeline data."""
         # factor to convert the time unit from 1ms to 1us for timeline display
@@ -233,94 +191,6 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
         self._update_format_meta_data(timeline_dict)
         self._timeline_meta.append(timeline_dict)
 
-    def _get_op_timeline(self, communication_info, source_path):
-        """get ai_core and cpu timeline."""
-        all_reduce_names = AscendTimelineGenerator._get_all_reduce_names(communication_info)
-        timeline_list = OPIntermediateParser(self._profiling_dir, self._rank_id).get_timeline_data(all_reduce_names)
-        for timeline in timeline_list:
-            timeline[self._tid_idx] = f"Stream #{timeline[self._tid_idx]}"
-
-        cpu_timeline_generator = CpuTimelineGenerator(self._profiling_dir, self._rank_id, self._model)
-        cpu_timeline_list = cpu_timeline_generator.get_timeline_data()
-        if cpu_timeline_list:
-            self._clock_synchronize_to_device(cpu_timeline_list, source_path)
-            timeline_list.extend(cpu_timeline_list)
-        timeline_list.sort(key=lambda x: float(x[self._start_time_idx]))
-        self._max_scope_name_num = self._get_max_scope_name_num(timeline_list)
-        self._timeline_summary['op_exe_times'] = len(timeline_list)
-        self._timeline_summary['max_scope_name_num'] = self._max_scope_name_num
-        return timeline_list
-
-    def _clock_synchronize_to_device(self, timeline_list, source_path):
-        """Synchronize the timestamp from host to device."""
-        host_start_file_path = os.path.join(source_path, f"host_start.log.{self._device_id}")
-        dev_start_file_path = os.path.join(source_path, f"dev_start.log.{self._device_id}")
-        host_monotonic = 0
-        dev_cntvct = 0
-        try:
-            with open(host_start_file_path) as f_obj:
-                lines = f_obj.readlines()
-            for line in lines:
-                info = line.strip().split(':')
-                if len(info) < 2 or info[0] != "clock_monotonic_raw":
-                    continue
-                host_monotonic = int(info[1])
-                break
-
-            with open(dev_start_file_path) as f_obj:
-                lines = f_obj.readlines()
-            for line in lines:
-                info = line.strip().split(':')
-                if len(info) < 2 or info[0] != "cntvct":
-                    continue
-                dev_cntvct = int(info[1])
-                break
-        except (IOError, OSError) as err:
-            logger.critical('Error occurred when read dev_start.log: %s', err)
-            raise ProfilerIOException() from err
-        if host_monotonic == 0 or dev_cntvct == 0:
-            logger.error('Error occurred when read host_monotonic or dev_cntvct time')
-
-        factor = {"factor_ns_to_ms": 1e-6, "factor_ten_ns_to_ns": 10, "factor_ms_to_ns": 1e6}
-        for idx, time_item in enumerate(timeline_list):
-            host_time = int(float(time_item[self._start_time_idx]) * factor.get("factor_ms_to_ns"))
-            device_time = dev_cntvct * factor.get("factor_ten_ns_to_ns") + (host_time - host_monotonic)
-            timeline_list[idx][self._start_time_idx] = device_time * factor.get("factor_ns_to_ms")
-
-    def _add_framework_info(self, framework_obj_list):
-        """
-        Add framework info into timeline metadata.
-
-        Args:
-            framework_obj_list (list): The framework metadata.
-        """
-        logger.debug('Start adding framework info into timeline...')
-        # Get the framework info that will be written into timeline.
-        framework_info_dict = {}
-        for framework_obj in framework_obj_list:
-            op_name = framework_obj[0]
-            op_type = framework_obj[1]
-            op_full_name = framework_obj[4]
-            op_info = framework_obj[5]
-            framework_info = {
-                'name': op_name,
-                'args': {
-                    'type': op_type,
-                    'fullname': op_full_name
-                }
-            }
-            framework_info.get('args').update(op_info)
-            framework_info_dict[op_full_name] = framework_info
-
-        # Insert framework info into timeline.
-        for timeline_item in self._timeline_meta:
-            op_full_name = timeline_item.get('name')
-            framework_item = framework_info_dict.get(op_full_name)
-            if framework_item:
-                timeline_item['name'] = framework_item.get('name')
-                timeline_item['args'] = framework_item.get('args')
-        logger.debug('Finished adding framework info into timeline...')
-
     def _produce_two_separated_timeline(self, timeline, op_name):
         """Produce two separated timeline based on op_name."""
         timeline_include_op_name = []
@@ -490,52 +360,6 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
 
         return intersection_segment_display_list
 
-    def _pynative_get_step_timeline_list(self, timeline_list):
-        """Get step timeline list for pynative model."""
-        step_list = []
-        # The timeline starts with the GetNext op
-        if len(timeline_list) < 2 or 'GetNext' not in timeline_list[0][self._op_name_idx] and \
-                'GetNext' not in timeline_list[1][self._op_name_idx]:
-            return step_list
-        step = [-1, -1]
-        step_num = 0
-        tid = "Steps"
-        for timeline in timeline_list:
-            if 'GetNext' not in timeline[self._op_name_idx]:
-                continue
-            start_time = float(timeline[self._start_time_idx])
-            if step[0] == -1:
-                step[0] = start_time
-            else:
-                step[1] = start_time - step[0]
-                step_num = step_num + 1
-                step_list.append([str(step_num), tid, float(step[0]), step[1]])
-                step = [start_time, -1]
-        if step[0] != -1 and step[1] == -1:
-            step_num = step_num + 1
-            step_list.append([str(step_num), tid, float(step[0]),
-                              float(timeline_list[-1][self._start_time_idx]) - step[0]])
-        return step_list
-
-    def _pynative_clock_synchronize(self, timeline_list):
-        """Synchronize the timestamp from device to host."""
-        start_time_file_path = os.path.join(self._profiling_dir, f"start_time_{self._rank_id}.txt")
-        try:
-            with open(start_time_file_path) as f_obj:
-                lines = f_obj.readlines()
-                # lines[0] stores the host monotonic time of start training.
-                host_monotonic_start_time = int(lines[0].strip().split(':')[-1])
-                # lines[1] stores the gpu time of start training.
-                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()
-        time_diff = gpu_start_time * 1000 - host_monotonic_start_time
-        for idx, time_item in enumerate(timeline_list):
-            timeline_list[idx][self._start_time_idx] = int(time_item[self._start_time_idx]) + time_diff
-            timeline_list[idx][self._start_time_idx] = timeline_list[idx][self._start_time_idx] / 1000000
-            timeline_list[idx][self._duration_idx] = timeline_list[idx][self._duration_idx] / 1000
-
     def _set_step_start_and_end_op_name(self, timeline_list):
         """Set the start and end operator full name of each step."""
         if not timeline_list or len(timeline_list) < 2:

mindspore/profiler/parser/base_timeline_generator.py

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

mindspore/profiler/parser/cpu_gpu_timeline_generator.py

@@ -497,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]:

mindspore/profiler/parser/framework_parser.py

@@ -578,7 +578,7 @@ 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

mindspore/profiler/parser/profiler_info.py

@@ -76,6 +76,25 @@ class ProfilerInfo:
         info["analyse_end_time"] = end_time
         ProfilerInfo._profiler_info_dict.update(info)
 
+    @staticmethod
+    def set_export_start_time(start_time):
+        """Set the export start time."""
+        info = dict()
+        info["export_start_time"] = start_time
+        ProfilerInfo._profiler_info_dict.update(info)
+
+    @staticmethod
+    def set_export_end_time(end_time):
+        """Set the export end time."""
+        info = dict()
+        info["export_end_time"] = end_time
+        ProfilerInfo._profiler_info_dict.update(info)
+
+    @staticmethod
+    def set_export_flag(flag):
+        """Set the graph id list."""
+        ProfilerInfo._profiler_info_dict["all_export"] = flag
+
     @staticmethod
     def set_graph_ids(graph_ids):
         """Set the graph id list."""