mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/profiler/parser/ascend_analysis/fwk_cann_parser.py

@@ -24,23 +24,22 @@ from mindspore.profiler.parser.ascend_analysis.fwk_file_parser import FwkFilePar
 from mindspore.profiler.parser.ascend_analysis.trace_event_manager import TraceEventManager
 from mindspore.profiler.parser.ascend_analysis.msprof_timeline_parser import MsprofTimelineParser
 from mindspore.profiler.parser.ascend_analysis.profiler_info_parser import ProfilerInfoParser
-from mindspore.profiler.parser.ascend_analysis.constant import Constant
 
 
 class FwkCANNParser:
     """The top-level trace view parser."""
 
-    _time_padding_diff = 1000 # ns
+    _trace_view_save_path = "trace_view_{}.json"
 
-    def __init__(self, source_path: str, msprof_data: List, rank_id: int, step_list=None):
+    def __init__(self, source_path: str, msprof_data: List, rank_id: int):
         source_path = validate_and_normalize_path(source_path)
         ProfilerInfoParser.init_source_path(source_path)
         ProfilerInfoParser.init_rank_id(rank_id)
         fwk_parser = FwkFileParser(source_path, rank_id)
         msprof_timeline_parser = MsprofTimelineParser(msprof_data)
-        self._fwk_data = fwk_parser.get_op_range_data(step_list)
-        self._fwk_json = fwk_parser.get_fwk_trace_data(self._fwk_data)
-        self._start_flow_to_npu_dict, self._device_most_json = msprof_timeline_parser.get_acl_to_npu_data()
+        self._fwk_op_data = fwk_parser.get_op_range_data()
+        self._fwk_trace_data = fwk_parser.get_fwk_trace_data(self._fwk_op_data)
+        self._acl_to_npu = msprof_timeline_parser.get_acl_to_npu_data()
         self.rank_id: int = rank_id
         self.kernels: List[CANNEvent] = []
 
@@ -49,57 +48,36 @@ class FwkCANNParser:
         Generate trace view json timeline file which contains framework side and
         device side data.
         """
-        fwk_flow_json = self.__link_msop_self()
-        device_flow_and_x_json = self.__link_msop_kernel()
-        return self._fwk_json + fwk_flow_json + self._device_most_json + device_flow_and_x_json
-
-    def __link_msop_self(self):
-        """Create flow between framework-side multi-level pipeline task."""
-        link_event_dict = defaultdict(list)
-        for op_data in self._fwk_data:
-            if op_data.name == Constant.FLOW_OP:
-                link_event_dict[op_data.flow_id].insert(0, op_data)
-            elif op_data.flow_id != Constant.INVALID_FLOW_ID:
-                link_event_dict[op_data.flow_id].append(op_data)
-        flow_json = []
-        for op_data_list in link_event_dict.values():
-            if len(op_data_list) != 2:
-                logger.info('Only alow 2 op_data have the same flow_id. but got %s', len(op_data_list))
-                continue
-            flow_json.extend(TraceEventManager.create_mindspore_to_self_flow(op_data_list[0],
-                                                                             op_data_list[1]))
-        return flow_json
+        trace_data = self.__link_msop_kernel()
+        return self._fwk_trace_data + trace_data
 
     def __link_msop_kernel(self) -> List:
         """Associate the frame-side operator with the device-side kernel"""
-        trace_data_json = []
+        trace_data = []
         op_data_by_tid = defaultdict(list)
         acl_to_npu_by_tid = {}
-        for host_data in self._fwk_data:
-            if 'KernelLaunch' in host_data.name or 'LaunchTask' in host_data.name:
-                op_data_by_tid[host_data.tid].append(host_data)
-        for (cann_op_tid, cann_op_ts), event_list in self._start_flow_to_npu_dict.items():
-            acl_to_npu_by_tid.setdefault(cann_op_tid, defaultdict(list))[cann_op_ts].extend(event_list)
-
+        for op_data in self._fwk_op_data:
+            op_data_by_tid[op_data.tid].append(op_data)
+        for (ts, tid), event_list in self._acl_to_npu.items():
+            acl_to_npu_by_tid.setdefault(tid, defaultdict(list))[ts].extend(event_list)
         if op_data_by_tid.keys() != acl_to_npu_by_tid.keys():
             logger.warning("Failed to create link between mindspore operator and kernels.")
 
-        for device_tid in acl_to_npu_by_tid:
-            host_data_sorted = sorted(op_data_by_tid.get(device_tid, []), key=lambda x: x.ts)
+        for tid in op_data_by_tid:
             op_idx = 0
-
-            for ts, device_data_list in sorted(acl_to_npu_by_tid.get(device_tid).items(), key=lambda x: x[0]):
-                op_idx, status = FwkCANNParser.__find_launch_op(ts, host_data_sorted, op_idx)
-
-                for device_data in device_data_list:
-                    if status:
-                        device_data.parent = host_data_sorted[op_idx]
-                        trace_data_json.extend(TraceEventManager.create_mindspore_to_npu_flow(host_data_sorted[op_idx],
-                                                                                              device_data))
-                        self.kernels.append(device_data)
-                    trace_data_json.append(device_data.to_json())
-
-        return trace_data_json
+            op_data_sorted = sorted(op_data_by_tid[tid], key=lambda x: x.ts)
+            acl_sorted = sorted(acl_to_npu_by_tid.get(tid, {}).items(), key=lambda x: x[0])
+            for ts, cann_event_list in acl_sorted:
+                op_idx, status = FwkCANNParser.__find_launch_op(ts, op_data_sorted, op_idx)
+                if not status:
+                    continue
+                for cann_event in cann_event_list:
+                    cann_event.parent = op_data_sorted[op_idx]
+                    op_data_sorted[op_idx].children.append(cann_event)
+                    flow_list = TraceEventManager.create_mindspore_to_npu_flow(op_data_sorted[op_idx], cann_event)
+                    self.kernels.append(cann_event)
+                    trace_data += flow_list
+        return trace_data
 
     @staticmethod
     def __find_launch_op(ts: Decimal, op_list: List[MindSporeOpEvent],
@@ -122,7 +100,7 @@ class FwkCANNParser:
         right = len(op_list) if (right is None or right < 0) else right
         # The data in range [left, right) is considered.
         while right > left:
-            if op_list[left].ts - FwkCANNParser._time_padding_diff > ts:
+            if op_list[left].ts > ts:
                 return left, False
             if op_list[left].end_us < ts:
                 left += 1

mindspore/profiler/parser/ascend_analysis/fwk_file_parser.py

@@ -24,14 +24,13 @@ from mindspore.profiler.parser.ascend_analysis.file_manager import FileManager
 from mindspore.profiler.parser.ascend_analysis.tlv_decoder import TLVDecoder
 from mindspore.profiler.parser.ascend_analysis.function_event import MindSporeOpEvent
 from mindspore.profiler.parser.ascend_analysis.trace_event_manager import TraceEventManager
-from mindspore.profiler.parser.ascend_analysis.constant import Constant
 
 
 class FwkFileParser:
     """Framework-side operator file parser."""
 
     _op_range = "FRAMEWORK/op_range_{}"
-    _op_range_struct_size = 73
+    _op_range_struct_size = 57
 
     def __init__(self, source_path: str, rank_id: int):
         """
@@ -41,7 +40,7 @@ class FwkFileParser:
         self._op_range_path = None
         self.__init_framework_path(source_path)
 
-    def get_op_range_data(self, step_list=None) -> List[MindSporeOpEvent]:
+    def get_op_range_data(self) -> List[MindSporeOpEvent]:
         """Read and decode all the mindspore oprange data."""
         op_range_list = []
         if os.path.exists(self._op_range_path):
@@ -49,27 +48,23 @@ class FwkFileParser:
             op_range_list = TLVDecoder.decode(op_range_bytes, MindSporeOpEvent, self._op_range_struct_size)
         else:
             logger.error("Failed to find op_range data.")
-        if step_list and isinstance(step_list, list):
-            first_step = min(op.step for op in op_range_list)
-            step_list = [step - 1 + first_step for step in step_list]
-            op_range_list = list(filter(lambda op: op.step in step_list, op_range_list))
         return op_range_list
 
     def get_fwk_trace_data(self, mindspore_op_data: List[MindSporeOpEvent] = None):
         """Generate chrome trace format json data from decoded oprange data."""
         if not mindspore_op_data:
             mindspore_op_data = self.get_op_range_data()
-        tid_map = defaultdict(set)
-        fwk_x_event_list = []
+        tid_map = defaultdict(list)
+        fwk_x_event_list = [None] * len(mindspore_op_data)
+        index = 0
 
         for mindspore_op in mindspore_op_data:
-            if mindspore_op.name == Constant.FLOW_OP:
-                continue
-            tid_map[mindspore_op.pid].add(mindspore_op.tid)
-            fwk_x_event_list.append(TraceEventManager.create_x_event(mindspore_op, "cpu_op"))
+            tid_map[mindspore_op.pid].append(mindspore_op.tid)
+            fwk_x_event_list[index] = TraceEventManager.create_x_event(mindspore_op, "cpu_op")
+            index += 1
         fwk_m_event_list = []
-        for pid, tid_set in tid_map.items():
-            fwk_m_event_list.extend(TraceEventManager.create_m_event(pid, tid_set))
+        for pid, tid_list in tid_map.items():
+            fwk_m_event_list.extend(TraceEventManager.create_m_event(pid, tid_list))
         return fwk_x_event_list + fwk_m_event_list
 
     def __init_framework_path(self, source_path: str):

mindspore/profiler/parser/ascend_analysis/msprof_timeline_parser.py

@@ -14,7 +14,7 @@
 # ============================================================================
 """msprof timeline file parser"""
 from collections import defaultdict
-from typing import List
+from typing import List, Dict, Tuple
 
 from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent
 
@@ -22,36 +22,31 @@ from mindspore.profiler.parser.ascend_analysis.function_event import CANNEvent
 class MsprofTimelineParser:
     """Msprof timeline file parser."""
 
+    ACL_TO_NPU = "acl_to_npu"
+    START_FLOW = "s"
+    END_FLOW = "f"
+    TIMELINE = "timeline"
+
     def __init__(self, msprof_data: List):
         self.timeline_data = msprof_data
 
-    def get_acl_to_npu_data(self):
+    def get_acl_to_npu_data(self) -> Dict[Tuple, List[CANNEvent]]:
         """Get all the acl to npu flow events."""
         flow_start_dict, flow_end_dict = {}, {}
-        x_event_list, other_event_json = [], []
+        cann_event_list: List[CANNEvent] = []
         for data in self.timeline_data:
             cann_event = CANNEvent(data)
-            if cann_event.is_x_event():
-                x_event_list.append(cann_event)
-            else:
-                cann_event_json = cann_event.to_json()
-                if cann_event_json:
-                    other_event_json.append(cann_event_json)
-
+            cann_event_list.append(cann_event)
             if cann_event.is_flow_start_event():
-                flow_start_dict[cann_event.id] = (cann_event.tid, cann_event.ts)
+                flow_start_dict[cann_event.id] = (cann_event.ts, cann_event.tid)
             elif cann_event.is_flow_end_event():
-                flow_end_dict[(cann_event.pid, cann_event.tid, cann_event.ts)] = cann_event.id
-        start_flow_to_npu_dict = defaultdict(list)
-        device_data_without_flow_json = []
-        for cann_event in x_event_list:
-            flow_id = flow_end_dict.get((cann_event.pid, cann_event.tid, cann_event.ts))
-            start_flow_info = flow_start_dict.get(flow_id)
-            if flow_id is not None and start_flow_info is not None:
-                start_flow_to_npu_dict[start_flow_info].append(cann_event)
-            else:
-                cann_event_json = cann_event.to_json()
-                if cann_event_json:
-                    device_data_without_flow_json.append(cann_event_json)
-
-        return start_flow_to_npu_dict, device_data_without_flow_json + other_event_json
+                flow_end_dict[cann_event.unique_id] = cann_event.id
+        acl_to_npu_dict = defaultdict(list)
+        for cann_event in cann_event_list:
+            if not cann_event.is_x_event():
+                continue
+            corr_id = flow_end_dict.get(cann_event.unique_id)
+            acl_ts_tid = flow_start_dict.get(corr_id)
+            if corr_id is not None and acl_ts_tid is not None:
+                acl_to_npu_dict[acl_ts_tid].append(cann_event)
+        return acl_to_npu_dict

mindspore/profiler/parser/ascend_analysis/profiler_info_parser.py

@@ -28,6 +28,7 @@ from mindspore.profiler.parser.profiler_info import ProfilerInfo
 class ProfilerInfoParser:
     """Parse files that record information, such as profiler_info.json"""
 
+    _localtime_diff = Decimal(0)
     _freq = 100.0
     _time_offset = 0
     _start_cnt = 0
@@ -49,7 +50,7 @@ class ProfilerInfoParser:
         cls._source_prof_path = prof_path
 
     @classmethod
-    def init_rank_id(cls, rank_id: int):
+    def init_rank_id(cls, rank_id):
         """initialize the rank id."""
         cls._rank_id = rank_id
 
@@ -76,9 +77,8 @@ class ProfilerInfoParser:
             profiler_info_path = os.path.join(cls._source_prof_path, os.path.pardir,
                                               f"profiler_info_{cls._rank_id}.json")
             if not os.path.isfile(profiler_info_path):
-                raise RuntimeError(f"Can`t find the file {profiler_info_path}, please check !")
-            with os.fdopen(os.open(profiler_info_path, os.O_RDONLY, 0o600),
-                           'r') as fr:
+                raise RuntimeError(f"Can`t find the file {profiler_info_path}, please check!")
+            with os.fdopen(os.open(profiler_info_path, os.O_RDONLY, 0o600), 'r') as fr:
                 profiler_info_data = json.load(fr)
             cls._start_cnt = profiler_info_data.get('system_cnt')
             cls._time_offset = profiler_info_data.get('system_time')
@@ -86,7 +86,7 @@ class ProfilerInfoParser:
             ProfilerInfo.set_system_cnt(cls._start_cnt)
             cls._loaded_frequency = True
         start_ns = cls.__get_timestamp(syscnt)
-        start_us = Decimal(start_ns * Constant.NS_TO_US)
+        start_us = Decimal(start_ns) / Constant.NS_TO_US
         return start_us
 
     @classmethod

mindspore/profiler/parser/ascend_analysis/trace_event_manager.py

@@ -33,7 +33,7 @@ class TraceEventManager:
         return x_event
 
     @classmethod
-    def create_m_event(cls, pid: int, tid_list: set) -> List:
+    def create_m_event(cls, pid: int, tid_list: List) -> List:
         """Create some metadata event."""
         # framework sidee trace information display format: MindSpore(pid pid_value): CPU
         event_list = [
@@ -57,12 +57,3 @@ class TraceEventManager:
                  "tid": start_event.tid, "ts": str(start_event.ts), "cat": "async_npu"},
                 {"ph": "f", "bp": "e", "name": "mindspore_to_npu", "id": flow_id, "pid": end_event.pid,
                  "tid": end_event.tid, "ts": str(end_event.ts), "cat": "async_npu"}]
-
-    @classmethod
-    def create_mindspore_to_self_flow(cls, start_event: BaseEvent, end_event: BaseEvent) -> List:
-        """Create flow events link mindspore operator and npu kernel."""
-        flow_id = start_event.flow_id
-        return [{"ph": "s", "bp": "e", "name": "mindspore_to_self", "id": flow_id, "pid": start_event.pid,
-                 "tid": start_event.tid, "ts": str(start_event.ts), "cat": "async_mindspore"},
-                {"ph": "f", "bp": "e", "name": "mindspore_to_self", "id": flow_id, "pid": end_event.pid,
-                 "tid": end_event.tid, "ts": str(end_event.ts), "cat": "async_mindspore"}]

mindspore/profiler/parser/ascend_hccl_generator.py

@@ -29,8 +29,6 @@ from mindspore.profiler.common.util import get_newest_file
 class AscendHCCLGenerator:
     """Generate ascend hccl data from files."""
 
-    DEFAULT_MODEL_ID = 4294967295
-
     def __init__(self, mindstudio_profiler_output, steptrace):
         self.mindstudio_profiler_output = mindstudio_profiler_output
         self.steptrace = steptrace
@@ -186,8 +184,7 @@ class AscendHCCLGenerator:
                 size = size if isinstance(size, int) else int(size, 16)
                 steptrace = groups_steptrace.get(model_id, None)
                 if steptrace is None:
-                    if self.DEFAULT_MODEL_ID != model_id:
-                        logging.warning('Could not find model: %s in hccl json, skip.', model_id)
+                    logging.warning('Could not find model: %s in hccl json, skip.', model_id)
                     continue
                 tag = np.searchsorted(steptrace['Iteration End'], te * 1e-3, side='left')
                 iteration_id = steptrace[tag]['Iteration ID']

mindspore/profiler/parser/ascend_msprof_exporter.py

@@ -99,30 +99,18 @@ class AscendMsprofExporter:
         logger.info("The msprof command has been added to the path!")
 
     @classmethod
-    def get_msprof_script_path(cls, script_path=""):
-        """Check the existence of msprof script"""
-        if not script_path:
-            return ""
-        outs, _ = AscendMsprofExporter.run_cmd(["which", cls._msprof_cmd])
+    def get_msprof_info_path(cls):
+        """Check the existence of get_msprof_info.py script"""
+        outs, _ = AscendMsprofExporter.run_cmd(['which', cls._msprof_cmd])
         if not outs:
             return ""
         msprof_path = os.path.realpath(outs.strip())
-        sup_path = msprof_path.split("tools")[0]
-        script_path = os.path.join(sup_path, script_path)
+        sup_path = msprof_path.split('tools')[0]
+        script_path = os.path.join(sup_path, 'tools/profiler/profiler_tool/analysis/interface/get_msprof_info.py')
         if not os.path.exists(script_path):
             return ""
         return script_path
 
-    @classmethod
-    def get_msprof_info_path(cls):
-        """Check the existence of get_msprof_info.py script"""
-        return cls.get_msprof_script_path("tools/profiler/profiler_tool/analysis/interface/get_msprof_info.py")
-
-    @classmethod
-    def get_msprof_py_script_path(cls):
-        """Check the existence of msprof.py script"""
-        return cls.get_msprof_script_path("tools/profiler/profiler_tool/analysis/msprof/msprof.py")
-
     @classmethod
     def run_cmd(cls, cmd, timeout=300):
         """run shell command"""
@@ -143,14 +131,17 @@ class AscendMsprofExporter:
 
     def get_drv_version(self):
         """Get the drv_version for choosing the export mode."""
+        script_path = AscendMsprofExporter.get_msprof_info_path()
+        if not script_path:
+            logger.warning("Can`t find get_msprof_info.py path, use single-export mode instead.")
+            return False
+
+        logger.info("get_msprof_info.py path is : %s", script_path)
+        host_dir = os.path.join(self.prof_root_dir, 'host')
+        cmd = ['python',
+               script_path,
+               '-dir', host_dir]
         try:
-            script_path = AscendMsprofExporter.get_msprof_info_path()
-            if not script_path:
-                logger.warning("Can`t find get_msprof_info.py path, use single-export mode instead.")
-                return False
-            logger.info("get_msprof_info.py path is : %s", script_path)
-            host_dir = os.path.join(self.prof_root_dir, 'host')
-            cmd = ['python', script_path, '-dir', host_dir]
             outs, _ = AscendMsprofExporter.run_cmd(cmd)
             if not outs:
                 logger.warning('Check the drvVersion can`t find the result, use single-export mode instead.')
@@ -164,7 +155,7 @@ class AscendMsprofExporter:
             if drv_version >= self.DRV_VERSION:
                 return True
             return False
-        except (RuntimeError, JSONDecodeError, AttributeError, TimeoutError) as err:
+        except (RuntimeError, JSONDecodeError, AttributeError) as err:
             logger.warning('Get the drvVersion error, use single-export mode instead. detail : %s', err)
             return False
 
@@ -178,8 +169,12 @@ class AscendMsprofExporter:
                 model_iteration_dict = self._generate_step_trace()
 
             if model_iteration_dict:
-                for model_id, iter_list in model_iteration_dict.items():
-                    self._run_msprof_export_cmd(self.prof_root_dir, model_id, iter_list)
+                for model_id, value in model_iteration_dict.items():
+                    for iteration_id in value:
+                        msprof_export_cmd = self._msprof_command_generator_old(self.prof_root_dir, model_id,
+                                                                               iteration_id)
+                        AscendMsprofExporter.run_cmd(msprof_export_cmd, self._time_out)
+
         else:
             msprof_export_cmd = self._msprof_command_generator(self.prof_root_dir)
             AscendMsprofExporter.run_cmd(msprof_export_cmd, self._time_out)
@@ -192,22 +187,6 @@ class AscendMsprofExporter:
 
         return flag
 
-    def _run_msprof_export_cmd(self, prof_root_dir, model_id, iter_list):
-        """run msprof.py export cmd"""
-        script_path = AscendMsprofExporter.get_msprof_py_script_path()
-        if not script_path:
-            raise FileNotFoundError("Can not find msprof.py path, please check the cann environment.")
-        export_cmd = ['python', script_path]
-        iter_param = []
-        if isinstance(model_id, int) and model_id >= 0:
-            iter_param.extend(["--model-id", str(model_id)])
-        if iter_list and isinstance(iter_list, list):
-            iter_list.sort()
-            iter_param.extend(["--iteration-id", str(iter_list[0]), "--iteration-count", str(len(iter_list))])
-        for export_type in ("timeline", "summary"):
-            cmd = export_cmd + ["export", export_type, "-dir", prof_root_dir] + iter_param
-            AscendMsprofExporter.run_cmd(cmd, self._time_out)
-
     def _msprof_command_generator_old(self, output, model_id=None, iter_id=None):
         """msprof export helper"""
         export_cmd = [self._msprof_cmd, "--export=on", "--output={}".format(output)]

mindspore/profiler/parser/ascend_timeline_generator.py

@@ -37,8 +37,7 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
     scope_index = 1
     cpu_index = 2
 
-    def __init__(self, profiling_dir, source_path, mindstudio_profiler_output, rank_id, rank_size, mode,
-                 step_list=None):
+    def __init__(self, profiling_dir, source_path, mindstudio_profiler_output, rank_id, rank_size, mode):
         super().__init__(DeviceTarget.ASCEND.value, mode)
         self._profiling_dir = profiling_dir
         self._source_path = source_path
@@ -48,7 +47,6 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
         self._timeline_display_filename = self._timeline_display_filename.format(rank_id)
         self._timeline_summary_filename = self._timeline_summary_filename.format(rank_id)
         self._timeline_data = []
-        self._step_list = step_list
 
         self.step_time_list_df = np.dtype(
             [('Iteration ID', object), ('Steps', object), ('Iteration Start', float), ('Iteration Time', float)])
@@ -150,7 +148,8 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
         logger.info("Start parse timeline data...")
         self._pretty = pretty
         timeline_data = []
-        all_scope_data = []
+
+        all_scope_data = []  # 所有带scope的算子
 
         # get msprof data
         msprof_file_name = fr'{self._mindstudio_profiler_output}/msprof_*.json'
@@ -160,6 +159,7 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
             logger.error('Could not find msprof_*.json file in %s', self._mindstudio_profiler_output)
         else:
             msprof_timeline = self._parse_msprof_data(get_newest_file(file_list_msprof))
+            timeline_data.extend(msprof_timeline)
 
         # get Ascend Hardware for scope
         scope_data = self._parse_ascend_hardware_scope(msprof_timeline)
@@ -186,8 +186,6 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
             result = self._parse_fwk_device_data(msprof_timeline)
             timeline_data.extend(result.get("trace_data", []))
             self._kernel_events = result.get("kernels", [])
-        else:
-            timeline_data.extend(msprof_timeline)
 
         logger.info("All timeline data parse complete.")
         self._timeline_data = timeline_data
@@ -258,7 +256,7 @@ class AscendTimelineGenerator(BaseTimelineGenerator):
         """
         Get framework op range trace data, flow events and hardware kernel events
         """
-        fwkcann_parser = FwkCANNParser(self._source_path, cann_kernel_data, self._rank_id, self._step_list)
+        fwkcann_parser = FwkCANNParser(self._source_path, cann_kernel_data, self._rank_id)
         fwk_link_data = fwkcann_parser.generate_trace_data()
         kernels = fwkcann_parser.kernels
         result = {"trace_data": fwk_link_data, "kernels": kernels}

mindspore/profiler/parser/minddata_parser.py

@@ -14,8 +14,6 @@
 # ============================================================================
 """Minddata aicpu parser."""
 import os
-import glob
-import csv
 
 from mindspore.profiler.common.util import get_file_join_name, fwrite_format
 from mindspore import log as logger
@@ -88,80 +86,13 @@ class MinddataParser:
         return result
 
     @staticmethod
-    def execute(source_path, output_path, job_id, device_id):
+    def execute(source_path, output_path, device_id):
         """
         Execute the parser.
 
         Args:
-            source_path (str): the source file path, eg: profiler.
-            output_path (str): the output file path, eg: profiler.
-            job_id (str): the job id, eg: PROF_XXX/device_*
-            device_id (str): the device id.
-        """
-        if MinddataParser._is_legacy_aicpu_data(source_path, job_id):
-            logger.warning("The aicpu data is legacy, which will be deprecated in the future, please update your "
-                           "CANN and driver version.")
-            MinddataParser._execute_legacy(os.path.join(source_path, job_id), output_path, device_id)
-            return
-
-        MinddataParser._execute(source_path, output_path, job_id, device_id)
-
-    @staticmethod
-    def _is_legacy_aicpu_data(source_path, job_id) -> bool:
-        """
-        Check whether the aicpu data is legacy.
-
-        Args:
-            source_path (str): the source file path, eg: profiler.
-            job_id (str): the job id, eg: PROF_XXX/device_*
-        Returns:
-            bool, True if the aicpu data is legacy, False otherwise.
-        """
-        legacy_files = glob.glob(os.path.join(source_path, job_id, "data", "DATA_PREPROCESS.*"))
-        return len(legacy_files) > 0
-
-    @staticmethod
-    def _execute(source_path, output_path, job_id, device_id):
-        """
-        Execute the parser when using newest CANN and driver version.
-
-        Args:
-            source_path (str): the source file path, eg: profiler.
-            output_path (str): the output file path, eg: profiler.
-            job_id (str): the job id, eg: PROF_XXX/device_*
-            device_id (str): the device id.
-        """
-        minddata_aicpu_data = []
-        prof_path = job_id.split("/")[0]
-        if not prof_path:
-            logger.error("The job_id is invalid: %s", job_id)
-            return
-
-        prof_output_path = os.path.join(source_path, prof_path, "mindstudio_profiler_output")
-        aicpu_file = glob.glob(os.path.join(prof_output_path, "aicpu_mi_*.csv"))
-        if not aicpu_file:
-            return
-
-        # aicpu_file len is 1
-        for file_path in aicpu_file:
-            file_path = validate_and_normalize_path(file_path)
-            with open(file_path, "r", newline='') as f:
-                reader = csv.reader(f)
-                minddata_aicpu_data = [[line[1], line[2][:-2], line[3][:-2], line[4]] for line in reader]
-
-        if minddata_aicpu_data:
-            minddata_aicpu_output_path = os.path.join(output_path, "minddata_aicpu_" + str(device_id) + ".txt")
-            fwrite_format(minddata_aicpu_output_path, minddata_aicpu_data[1:], is_start=True)
-            logger.info("Minddata aicpu data has been saved to %s", minddata_aicpu_output_path)
-
-    @staticmethod
-    def _execute_legacy(source_path, output_path, device_id):
-        """
-        Execute the parser when using legacy CANN and driver version.
-
-        Args:
-            source_path (str): the source file path, eg: profiler/PROF_XXX/device_*.
-            output_path (str): the output file path, eg: profiler.
+            source_path (str): the source file path.
+            output_path (str): the output file path.
             device_id (str): the device id.
         """
         col_names = ["node_name", "start_time", "end_time", "queue_size"]