mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/profiler/envprofiling.py

@@ -17,6 +17,7 @@ import json
 import os
 import time
 from mindspore.profiler import Profiler
+from mindspore.profiler.parser.ascend_analysis.file_manager import FileManager
 from mindspore.profiler.profiling import AICORE_METRICS_DICT, DeviceSupportParam, ALWAYS_VALID_PARAM
 from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
 from mindspore.profiler.parser.integrator import DeviceTarget
@@ -65,11 +66,7 @@ def construct_profiling_options():
         if os.getenv("MS_PROFILER_RUN_CONFIG"):
             return error_config
         os.environ["MS_PROFILER_RUN_CONFIG"] = json.dumps(error_config)
-        logger.error(
-            "The format of MS_PROFILER_OPTIONS is incorrect. "
-            "The MS_PROFILER_OPTIONS parameter configuration may refer to "
-            "'https://www.mindspore.cn/mindinsight/docs/zh-CN/r2.2/performance_profiling_ascend.html'."
-        )
+        logger.error("The format of MS_PROFILER_OPTIONS is incorrect.")
         return error_config
     conbine_options = combine_profile_options(profiling_options)
     if conbine_options.get("start"):
@@ -77,8 +74,7 @@ def construct_profiling_options():
         if not output_path:
             output_path = os.path.join(os.getcwd(), "data")
         conbine_options["output_path"] = validate_and_normalize_path(output_path)
-        if not os.path.exists(output_path):
-            os.makedirs(output_path, exist_ok=True)
+        FileManager.make_dir_safety(output_path)
         conbine_options["file_output_path"] = os.path.join(output_path, "profiler")
     return conbine_options
 
@@ -95,8 +91,8 @@ def parse_pubilc_args(options):
     if not isinstance(options.get("data_process"), bool):
         logger.warning(
             "The 'data_process' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
-            f" but got type {type(options.get('data_process'))}, it will be set to true.")
-        options["data_process"] = True
+            f" but got type {type(options.get('data_process'))}, it will be set to False.")
+        options["data_process"] = False
     if not isinstance(options.get("op_time"), bool):
         logger.warning(
             "The 'op_time' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
@@ -122,11 +118,11 @@ def parse_pubilc_args(options):
             "The 'output_path' parameter of the environment variable MS_PROFILE_OPTIONS only supports absolute path, "
             f"it will be set to '{absolute_path}'.")
         options["output_path"] = absolute_path
-    if options.get("profile_framework") not in ["memory", "time", "all", None]:
+    if options.get("profile_framework") not in ["time", "all", None]:
         logger.warning(
-            "The 'profile_framework' parameter of the environment variable MS_PROFILE_OPTIONS must be one of ['memory',"
-            " 'time', 'all', null], but got %s, it will be set to 'all'.", options.get("profile_framework"))
-        options['profile_framework'] = "all"
+            "The 'profile_framework' parameter of the environment variable MS_PROFILE_OPTIONS must be one of ["
+            " 'time', 'all', null], but got %s, it will be set to None.", options.get("profile_framework"))
+        options['profile_framework'] = None
     return options
 
 
@@ -150,8 +146,8 @@ def parse_ascend_args(options):
     if not isinstance(options.get("parallel_strategy"), bool):
         logger.warning(
             "The 'parallel_strategy' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
-            f" but got type {type(options.get('parallel_strategy'))}, it will be set to true.")
-        options["parallel_strategy"] = True
+            f" but got type {type(options.get('parallel_strategy'))}, it will be set to false.")
+        options["parallel_strategy"] = False
     if not isinstance(options.get("profile_communication"), bool):
         logger.warning(
             "The 'profile_communication' parameter of the environment variable MS_PROFILE_OPTIONS must be bool,"
@@ -160,7 +156,7 @@ def parse_ascend_args(options):
     if options.get("aicore_metrics") not in AICORE_METRICS_DICT:
         logger.warning(
             "The 'aicore_metrics' parameter of the environment variable MS_PROFILE_OPTIONS must be in "
-            f"[-1, 0, 1, 2, 3, 4, 5], but got {options.get('aicore_metrics')}, it will be set to 0.")
+            f"[-1, 0, 1, 2, 3, 4, 5, 6], but got {options.get('aicore_metrics')}, it will be set to 0.")
         options["aicore_metrics"] = 0
     if not isinstance(options.get("l2_cache"), bool):
         logger.warning(
@@ -193,11 +189,12 @@ def combine_profile_options(profiling_options):
         "aicore_metrics": profiling_options.get("aicore_metrics", 0),
         "l2_cache": profiling_options.get("l2_cache", False),
         "sync_enable": profiling_options.get("sync_enable", True),
-        "data_process": profiling_options.get("data_process", True),
+        "data_process": profiling_options.get("data_process", False),
         "timeline_limit": profiling_options.get("timeline_limit", 500),
-        "parallel_strategy": profiling_options.get("parallel_strategy", True),
+        "parallel_strategy": profiling_options.get("parallel_strategy", False),
         'op_time': profiling_options.get("op_time", True),
-        'profile_framework': profiling_options.get("profile_framework", "all")
+        'profile_framework': profiling_options.get("profile_framework", None),
+        'with_stack': profiling_options.get("with_stack", False)
     }
     combine_options = parse_profiling_args(config_options)
     if combine_options.get("start"):
@@ -250,7 +247,8 @@ def profiler_check_env():
              sync_enable=config.get("sync_enable", False),
              op_time=config.get("op_time", False),
              timeline_limit=config.get("timeline_limit", 500),
-             profile_framework=config.get("profile_framework", "all"))
+             profile_framework=config.get("profile_framework", None),
+             with_stack=config.get("with_stack", False))
 
 
 profiler_check_env()

mindspore/{_extends/parallel_compile/tbe_compiler → profiler/parser/ascend_analysis}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

mindspore/profiler/parser/ascend_analysis/constant.py

@@ -0,0 +1,71 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Constant value for ascend profiling parser."""
+import os
+
+
+class Constant:
+    """Constant values"""
+
+    HOST_TO_DEVICE = "HostToDevice"
+    START_FLOW = "s"
+    END_FLOW = "f"
+    META_EVENT = 'M'
+    COMPLETE_EVENT = 'X'
+    FLOW_OP = "flow"
+    INVALID_FLOW_ID = 18446744073709551615
+    DEFAULT_PROCESS_NUMBER = os.cpu_count() // 2
+
+    # file authority
+    MAX_FILE_SIZE = 1024 * 1024 * 1024 * 10
+    MAX_CSV_SIZE = 1024 * 1024 * 1024 * 5
+
+    # tlv constant struct
+    FIX_SIZE_BYTES = "fix_size_bytes"
+    NS_TO_US = 1e-3
+
+    # field name
+    SEQUENCE_UNMBER = "Sequence number"
+    FORWORD_THREAD_ID = "Fwd thread id"
+    OP_NAME = "op_name"
+    INPUT_SHAPES = "Input Dims"
+    INPUT_DTYPES = "Input type"
+    CALL_STACK = "Call stack"
+    MODULE_HIERARCHY = "Module Hierarchy"
+    FLOPS = "flops"
+    NAME = "name"
+    CUSTOM_INFO = "custom_info"
+
+    # trace constant
+    PROCESS_NAME = "process_name"
+    PROCESS_LABEL = "process_labels"
+    PROCESS_SORT = "process_sort_index"
+    THREAD_NAME = "thread_name"
+    THREAD_SORT = "thread_sort_index"
+
+    # dir name
+    FRAMEWORK_DIR = "FRAMEWORK"
+    PROFILER_DIR = "profiler"
+    TOP_SCOPE_NAMES = ('Default', 'Gradients', 'recompute_Default')
+
+    # the index of modules of timeline
+    MINDSPORE = 1
+    CPU_OP = 2
+    CANN = 3
+    SCOPE_LAYLER = 4
+    ASCEND_HARDWARE = 5
+    HCCL = 6
+    OVERLAP = 7
+    OTHERWISE = 8

mindspore/profiler/parser/ascend_analysis/file_manager.py

@@ -0,0 +1,180 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Profiler file manager"""
+import csv
+import json
+import os.path
+from typing import List, Dict, Optional
+
+from mindspore import log as logger
+from mindspore.profiler.common.validator.validate_path import validate_and_normalize_path
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.path_manager import PathManager
+
+
+class FileManager:
+    """Profiler file manager"""
+
+    MAX_PATH_LENGTH = 4096
+    MAX_FILE_NAME_LENGTH = 255
+    DATA_FILE_AUTHORITY = 0o640
+    DATA_DIR_AUTHORITY = 0o700
+
+    @classmethod
+    def read_file_content(cls, path: str, mode: str = "r"):
+        """Read the content in the input file."""
+        if not os.access(path, os.R_OK):
+            msg = f"The file {os.path.basename(path)} is not readable!"
+            raise RuntimeError(msg)
+
+        if not os.path.isfile(path):
+            raise RuntimeError(f"The file {os.path.basename(path)} is invalid!")
+        file_size = os.path.getsize(path)
+        if file_size <= 0:
+            return ""
+        if file_size > Constant.MAX_FILE_SIZE:
+            msg = f"File too large file to read: {path}"
+            logger.warning(msg)
+            return ''
+        try:
+            with open(path, mode) as file:
+                return file.read()
+        except Exception as err:
+            raise RuntimeError(f"Failed to read file: {path}") from err
+
+    @classmethod
+    def make_dir_safety(cls, dir_path: str):
+        """Make directory with least authority"""
+        dir_path = validate_and_normalize_path(dir_path)
+
+        if os.path.exists(dir_path):
+            return
+        try:
+            os.makedirs(dir_path, mode=cls.DATA_DIR_AUTHORITY, exist_ok=True)
+        except Exception as err:
+            msg = f"Failed to make directory: {dir_path}"
+            raise RuntimeError(msg) from err
+
+    @classmethod
+    def read_json_file(cls, file_path: str) -> Optional[Dict]:
+        """Read json file and return dict data"""
+        if not os.path.isfile(file_path):
+            return {}
+        file_size = os.path.getsize(file_path)
+        if file_size <= 0:
+            return {}
+        if file_size > Constant.MAX_FILE_SIZE:
+            msg = f"The file size exceeds the preset value, please check the file: {file_path}"
+            logger.warning(msg)
+            return {}
+        try:
+            PathManager.check_directory_path_readable(file_path)
+            with open(file_path, 'r', encoding='utf-8') as json_file:
+                data = json.load(json_file)
+                return data
+        except Exception as err:
+            raise RuntimeError(f"Failed to read the file: {file_path}") from err
+
+    @classmethod
+    def create_json_file(cls, output_path: str, json_data: List, file_name: str, indent: int = None) -> None:
+        """Create json file with least authority"""
+        if not json_data:
+            return
+        cls.make_dir_safety(output_path)
+        file_path = os.path.join(output_path, file_name)
+        flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+        with os.fdopen(os.open(file_path, flags, cls.DATA_FILE_AUTHORITY), 'w') as fp:
+            json.dump(json_data, fp, ensure_ascii=False, indent=indent)
+
+    @classmethod
+    def read_csv_file(cls, file_path: str) -> list:
+        """Read csv file and return list"""
+        if not os.path.isfile(file_path):
+            return []
+        file_size = os.path.getsize(file_path)
+        if file_size <= 0:
+            return []
+        if file_size > Constant.MAX_CSV_SIZE:
+            msg = f"The file size exceeds the preset value, please check the file: {file_path}"
+            logger.warning(msg)
+            return []
+        result_data = []
+        try:
+            with open(file_path, newline="") as csv_file:
+                reader = csv.reader(csv_file)
+                for row in reader:
+                    result_data.append(row)
+        except Exception as err:
+            raise RuntimeError(f"Failed to read the file: {file_path}") from err
+        return result_data
+
+    @classmethod
+    def create_csv_file(cls, file_path: str, data: list, headers: list = None) -> None:
+        """Create csv file and write the data"""
+        if not data:
+            return
+        try:
+            with os.fdopen(os.open(file_path, os.O_WRONLY | os.O_CREAT, 0o600),
+                           'w', newline="") as file:
+                writer = csv.writer(file)
+                if headers:
+                    writer.writerow(headers)
+                writer.writerows(data)
+        except Exception as err:
+            raise RuntimeError(f"Can't create file: {file_path}") from err
+
+    @classmethod
+    def combine_csv_file(cls, source_file_list: list, target_file_path: str, header_map: dict = None):
+        """Merge multiple CSV files into one"""
+        headers, all_data = [], []
+        for source_file in source_file_list:
+            data = cls.read_csv_file(source_file)
+            if len(data) > 1:
+                headers = data[0]
+                all_data.extend(data[1:])
+        if all_data:
+            if isinstance(header_map, dict):
+                headers = [header_map.get(header, header) for header in headers]
+            FileManager.create_csv_file(target_file_path, all_data, headers)
+
+    @classmethod
+    def get_csv_file_list_by_start_name(cls, source_path: str, start_name: str):
+        """Get all the csv files that match the name"""
+        file_list = []
+        for file_name in os.listdir(source_path):
+            if file_name.startswith(start_name) and file_name.endswith(".csv"):
+                file_list.append(os.path.join(source_path, file_name))
+        return file_list
+
+    @classmethod
+    def read_txt_file(cls, file_path: str) -> list:
+        """Read txt file and return list"""
+        if not os.path.isfile(file_path):
+            return []
+        file_size = os.path.getsize(file_path)
+        if file_size <= 0:
+            return []
+        if file_size > Constant.MAX_FILE_SIZE:
+            msg = f"The file size exceeds the preset value, please check the file: {file_path}"
+            logger.warning(msg)
+            return []
+        result_data = []
+        try:
+            with open(file_path, "r") as file:
+                for line in file.readlines():
+                    result_data.append(line.strip().split(","))
+        except Exception as err:
+            raise RuntimeError(f"Failed to read the file: {file_path}") from err
+        return result_data

mindspore/profiler/parser/ascend_analysis/function_event.py

@@ -0,0 +1,185 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Function event data struct."""
+from typing import Dict, Optional
+from enum import Enum
+from decimal import Decimal
+import struct
+from abc import ABC, abstractmethod
+
+from mindspore.profiler.parser.ascend_analysis.constant import Constant
+from mindspore.profiler.parser.ascend_analysis.profiler_info_parser import ProfilerInfoParser
+
+
+class BaseEvent(ABC):
+    """Base class of CANNEvent and MindSporeOpEvent"""
+
+    def __init__(self, data: Dict):
+        if not isinstance(data, dict):
+            raise TypeError("Input data must be dict.")
+        # common attributes
+        self._orig_data = data
+        self.name: str = ""
+        self.pid: int = 0
+        self.tid: int = 0
+        self.ts: Decimal = Decimal(0)
+        self.te: Decimal = Decimal(0)
+        self.dur: float = 0.0
+        self.args: Dict = {}
+        self.parent: Optional[BaseEvent] = None
+        self._init_params()
+
+    @abstractmethod
+    def _init_params(self):
+        err_msg = "Protected function _init_params need to be implemented."
+        raise NotImplementedError(err_msg)
+
+
+class CANNEvent(BaseEvent):
+    """Function event collected on the CANN side"""
+
+    def _init_params(self):
+        """Initialize the attribute value of CANNEvent."""
+        self.ts = Decimal(str(self._orig_data.get("ts", 0)))
+        self.pid = self._orig_data.get("pid", 0)
+        self.tid = self._orig_data.get("tid", 0)
+        self.dur = self._orig_data.get("dur", 0.0)
+        self.te = self.ts + Decimal(str(self.dur))
+        self.name = self._orig_data.get("name", "")
+        self.id = self._orig_data.get("id", 0)
+        self.args = self._orig_data.get("args", {})
+        self.ph = self._orig_data.get("ph")
+        self.cat = self._orig_data.get("cat")
+
+    def is_flow_start_event(self) -> bool:
+        """Determine whether the event is flow start event or not."""
+        return self._orig_data.get("cat") == Constant.HOST_TO_DEVICE and \
+               self._orig_data.get("ph") == Constant.START_FLOW
+
+    def is_flow_end_event(self) -> bool:
+        """Determine whether the event is flow end event or not."""
+        return self._orig_data.get("cat") == Constant.HOST_TO_DEVICE and \
+               self._orig_data.get("ph") == Constant.END_FLOW
+
+    def is_x_event(self) -> bool:
+        """Determine whether the event x event or not."""
+        return self._orig_data.get("ph") == Constant.COMPLETE_EVENT
+
+    def get_sort_index(self):
+        """get the process sort index"""
+        if self.args.get('name', '') == 'Ascend Hardware':
+            return Constant.ASCEND_HARDWARE
+        if self.args.get('name', '') == 'CANN':
+            return Constant.CANN
+        if self.args.get('name', '') == 'HCCL':
+            return Constant.HCCL
+        if self.args.get('name', '') == 'Overlap Analysis':
+            return Constant.OVERLAP
+        return Constant.OTHERWISE
+
+    def to_json(self):
+        """Cast to trace event."""
+        if self.ph == Constant.META_EVENT:
+            if self.name == Constant.PROCESS_NAME:
+                return [{'name': self.name, 'pid': self.pid, 'tid': self.tid,
+                         'args': self.args, 'ph': self.ph},
+                        {'name': Constant.PROCESS_SORT, 'pid': self.pid, 'tid': self.tid,
+                         'args': {'sort_index': self.get_sort_index()}, 'ph': self.ph}]
+            if self.name == Constant.PROCESS_SORT:
+                return None
+            return {'name': self.name, 'pid': self.pid, 'tid': self.tid,
+                    'args': self.args, 'ph': self.ph}
+
+        if self.ph == Constant.COMPLETE_EVENT:
+            if self.parent is not None:
+                self.args.update({'mindspore_op': self.parent.name})
+            res = {'name': self.name, 'pid': self.pid, 'tid': self.tid,
+                   'ts': str(self.ts), 'dur': self.dur, 'args': self.args, 'ph': self.ph}
+            if self.cat:
+                res.update({'cat': self.cat})
+            return res
+
+        if self.ph == Constant.START_FLOW:
+            return {"ph": self.ph, "name": self.name, "id": self.id, "pid": self.pid,
+                    "tid": self.tid, "ts": str(self.ts), "cat": self.cat}
+
+        if self.ph == Constant.END_FLOW:
+            return {"ph": self.ph, "name": self.name, "id": self.id, "pid": self.pid,
+                    "tid": self.tid, "ts": str(self.ts), "cat": self.cat, 'bp': "e"}
+        return None
+
+
+class MindSporeOpEnum(Enum):
+    """MindSporeOp index enum"""
+    START_NS = 0
+    END_NS = 1
+    SEQUENCE_UNMBER = 2
+    PROCESS_ID = 3
+    START_THREAD_ID = 4
+    END_THREAD_ID = 5
+    FORWORD_THREAD_ID = 6
+    FLOW_ID = 7
+    STEP_ID = 8
+    LEVEL = 9
+    IS_ASYNC = 10
+
+
+class MindSporeOpEvent(BaseEvent):
+    """
+    Function event collected on the mindspore frame side.
+
+    Args:
+        data(Dict): The mindspore frame side data decoded by TLVDecoder.
+    """
+    _tlv_type_dict = {
+        Constant.OP_NAME: 3, Constant.INPUT_SHAPES: 5, Constant.INPUT_DTYPES: 4,
+        Constant.CALL_STACK: 6, Constant.MODULE_HIERARCHY: 7, Constant.FLOPS: 8,
+        Constant.CUSTOM_INFO: 9
+    }
+    _fix_data_format = "<3q6Qb?"
+
+    def _init_params(self):
+        """Initialize the attribute value of MindSporeOpEvent."""
+        fix_size_data = struct.unpack(self._fix_data_format, self._orig_data.get(Constant.FIX_SIZE_BYTES))
+        self.pid = Constant.MINDSPORE
+        self.tid = int(fix_size_data[MindSporeOpEnum.START_THREAD_ID.value])
+        self.name = str(self._orig_data.get(self._tlv_type_dict.get(Constant.OP_NAME), ""))
+        self.ts = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.START_NS.value])  # unit is us
+        self.te = ProfilerInfoParser.get_local_time(fix_size_data[MindSporeOpEnum.END_NS.value])  # unit is us
+        self.dur = self.te - self.ts
+        self.flow_id = int(fix_size_data[MindSporeOpEnum.FLOW_ID.value])
+        self.step = int(fix_size_data[MindSporeOpEnum.STEP_ID.value])
+        self.level = int(fix_size_data[MindSporeOpEnum.LEVEL.value])
+        self.custom_info = ""
+        self.args = self._get_args(fix_size_data)
+
+    def _get_args(self, fix_size_data) -> Dict:
+        """Get the rest information saved in args"""
+        args = {
+            Constant.SEQUENCE_UNMBER: int(fix_size_data[MindSporeOpEnum.SEQUENCE_UNMBER.value]),
+            Constant.FORWORD_THREAD_ID: int(fix_size_data[MindSporeOpEnum.FORWORD_THREAD_ID.value])}
+        for type_name, type_id in self._tlv_type_dict.items():
+            if type_name == Constant.OP_NAME or type_id not in self._orig_data.keys():
+                continue
+            if type_name in set([Constant.INPUT_SHAPES, Constant.INPUT_DTYPES, Constant.CALL_STACK]):
+                args[type_name] = self._orig_data.get(type_id).replace("|", "\r\n")
+            elif type_name == Constant.CUSTOM_INFO and self._orig_data.get(type_id):
+                pairs = self._orig_data.get(type_id).split(';')
+                custom_info = {pair.split(':')[0]: pair.split(':')[1] for pair in pairs}
+                args[type_name] = custom_info
+                self.custom_info = custom_info.__str__()
+            else:
+                args[type_name] = self._orig_data.get(type_id)
+        return args