mindspore 2.4.1__cp310-cp310-win_amd64.whl → 2.5.0__cp310-cp310-win_amd64.whl

mindspore/profiler/analysis/parser/timeline_event/fwk_event.py

@@ -0,0 +1,260 @@
+# Copyright 2024 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.
+# ============================================================================"""
+"""Framework event classes for timeline analysis."""
+from enum import Enum
+from decimal import Decimal
+from typing import Dict, Optional, List, Tuple
+
+from mindspore.profiler.common.constant import EventConstant, FileConstant
+from mindspore.profiler.analysis.time_converter import TimeConverter
+from mindspore.profiler.analysis.parser.timeline_event.base_event import (
+    BaseEvent,
+    CompleteEvent,
+    MetaEvent,
+    InstantEvent
+)
+
+
+class FwkFixSizeFormat:
+    """Format definition for framework fixed-size data."""
+
+    # Fixed size data format: 3 long long (q) + 6 unsigned long long (Q) + bool (?) + padding (b)
+    OpRangeStruct = "<3q6Qb?"
+
+
+class OpRangeStructField(Enum):
+    """Field indices in operator range structure fixed-size data."""
+    START_NS = 0
+    END_NS = 1
+    SEQUENCE_NUMBER = 2
+    PROCESS_ID = 3
+    START_THREAD_ID = 4
+    END_THREAD_ID = 5
+    FORWARD_THREAD_ID = 6
+    ID = 7
+    STEP_ID = 8
+    LEVEL = 9
+    IS_ASYNC = 10
+
+
+class FwkArgsDecoder:
+    """Decoder for framework event arguments in TLV (Type-Length-Value) format."""
+    TLV_TYPES = {
+        EventConstant.OP_NAME: 3,
+        EventConstant.INPUT_SHAPES: 5,
+        EventConstant.INPUT_DTYPES: 4,
+        EventConstant.CALL_STACK: 6,
+        EventConstant.MODULE_HIERARCHY: 7,
+        EventConstant.FLOPS: 8,
+        EventConstant.CUSTOM_INFO: 9
+    }
+
+    @classmethod
+    def decode(cls, origin_data: Dict, fix_size_data: Tuple) -> Dict:
+        """Decode event arguments from raw data."""
+        args = {
+            EventConstant.SEQUENCE_NUMBER: int(fix_size_data[OpRangeStructField.SEQUENCE_NUMBER.value]),
+            EventConstant.FORWARD_THREAD_ID: int(fix_size_data[OpRangeStructField.FORWARD_THREAD_ID.value])
+        }
+
+        for field_name, type_id in cls.TLV_TYPES.items():
+            if field_name == EventConstant.OP_NAME or type_id not in origin_data:
+                continue
+            value = origin_data.get(type_id)
+            if field_name in {EventConstant.INPUT_SHAPES, EventConstant.INPUT_DTYPES, EventConstant.CALL_STACK}:
+                args[field_name] = value.replace("|", "\r\n")
+            elif field_name == EventConstant.CUSTOM_INFO and value:
+                pairs = [pair.split(':') for pair in value.split(';') if pair]
+                info_dict = {k: v for k, v in pairs[0:2] if len(pairs) >= 2}
+                args[field_name] = info_dict
+            else:
+                args[field_name] = value
+
+        return args
+
+
+class FwkCompleteEvent(CompleteEvent):
+    """Framework complete event with duration."""
+    _args_decoder = FwkArgsDecoder()
+
+    def __init__(self, data: Dict):
+        """Initialize framework complete event."""
+        super().__init__(data)
+        self.fix_size_data = self._origin_data[FileConstant.FIX_SIZE_DATA]
+        self._ts_cache = None
+        self._te_cache = None
+        self._dur_cache = None
+        self._args_cache = {}
+        self._parent: Optional[BaseEvent] = None
+        self._children: List[BaseEvent] = []
+
+    @property
+    def parent(self) -> BaseEvent:
+        """Get parent event."""
+        return self._parent
+
+    @parent.setter
+    def parent(self, event: BaseEvent) -> None:
+        """Set parent event."""
+        self._parent = event
+
+    @property
+    def children(self) -> List[BaseEvent]:
+        """Get child events."""
+        return self._children
+
+    @property
+    def ts_raw(self) -> int:
+        """Get raw start timestamp."""
+        return self.fix_size_data[OpRangeStructField.START_NS.value]
+
+    @property
+    def ts(self) -> Decimal:
+        """Get start time in us."""
+        if not self._ts_cache:
+            self._ts_cache = TimeConverter.convert_syscnt_to_timestamp_us(
+                self.fix_size_data[OpRangeStructField.START_NS.value]
+            )
+        return self._ts_cache
+
+    @property
+    def te(self) -> Decimal:
+        """Get end time in us."""
+        if not self._te_cache:
+            self._te_cache = TimeConverter.convert_syscnt_to_timestamp_us(
+                self.fix_size_data[OpRangeStructField.END_NS.value]
+            )
+        return self._te_cache
+
+    @property
+    def dur(self) -> Decimal:
+        """Get duration in us."""
+        if not self._dur_cache:
+            self._dur_cache = self.te - self.ts
+        return self._dur_cache
+
+    @property
+    def pid(self) -> int:
+        """Get process ID."""
+        return int(EventConstant.MINDSPORE_PID)
+
+    @property
+    def tid(self) -> int:
+        """Get thread ID."""
+        return int(self.fix_size_data[OpRangeStructField.START_THREAD_ID.value])
+
+    @property
+    def id(self) -> int:
+        """Get event ID."""
+        return int(self.fix_size_data[OpRangeStructField.ID.value])
+
+    @property
+    def name(self) -> str:
+        """Get operator name."""
+        return str(self._origin_data.get(self._args_decoder.TLV_TYPES.get(EventConstant.OP_NAME), ""))
+
+    @property
+    def step(self) -> int:
+        """Get step ID."""
+        return int(self.fix_size_data[OpRangeStructField.STEP_ID.value])
+
+    @property
+    def level(self) -> int:
+        """Get event level."""
+        return int(self.fix_size_data[OpRangeStructField.LEVEL.value])
+
+    @property
+    def args(self) -> Dict:
+        """Get decoded event arguments."""
+        if not self._args_cache:
+            self._args_cache = self._args_decoder.decode(self._origin_data, self.fix_size_data)
+        return self._args_cache
+
+    @property
+    def custom_info(self) -> str:
+        """Get custom information."""
+        return str(self.args.get(EventConstant.CUSTOM_INFO, ''))
+
+
+class FwkInstantEvent(InstantEvent):
+    """Framework instant event without duration."""
+    _args_decoder = FwkArgsDecoder()
+
+    def __init__(self, data: Dict):
+        """Initialize framework instant event."""
+        super().__init__(data)
+        self.fix_size_data = self._origin_data[FileConstant.FIX_SIZE_DATA]
+        self._ts_cache = None
+        self._args_cache = {}
+
+    @property
+    def ts_raw(self) -> int:
+        """Get raw start timestamp."""
+        return self.fix_size_data[OpRangeStructField.START_NS.value]
+
+    @property
+    def ts(self) -> Decimal:
+        """Get time in us."""
+        if not self._ts_cache:
+            self._ts_cache = TimeConverter.convert_syscnt_to_timestamp_us(
+                self.fix_size_data[OpRangeStructField.START_NS.value]
+            )
+        return self._ts_cache
+
+    @property
+    def pid(self) -> int:
+        """Get process ID."""
+        return int(EventConstant.MINDSPORE_PID)
+
+    @property
+    def tid(self) -> int:
+        """Get thread ID."""
+        return int(self.fix_size_data[OpRangeStructField.START_THREAD_ID.value])
+
+    @property
+    def name(self) -> str:
+        """Get operator name."""
+        return str(self._origin_data.get(self._args_decoder.TLV_TYPES.get(EventConstant.OP_NAME), ""))
+
+    @property
+    def step(self) -> int:
+        """Get step ID."""
+        return int(self.fix_size_data[OpRangeStructField.STEP_ID.value])
+
+    @property
+    def level(self) -> int:
+        """Get event level."""
+        return int(self.fix_size_data[OpRangeStructField.LEVEL.value])
+
+    @property
+    def args(self) -> Dict:
+        """Get decoded event arguments."""
+        if not self._args_cache:
+            self._args_cache = self._args_decoder.decode(self._origin_data, self.fix_size_data)
+        return self._args_cache
+
+    @property
+    def custom_info(self) -> str:
+        """Get custom information."""
+        return str(self.args.get(EventConstant.CUSTOM_INFO, ''))
+
+
+class FwkMetaEvent(MetaEvent):
+    """Framework metadata event."""
+
+    @property
+    def pid(self) -> int:
+        """Get framework process ID."""
+        return int(EventConstant.MINDSPORE_PID)

mindspore/profiler/analysis/parser/timeline_event/msprof_event.py

@@ -0,0 +1,73 @@
+# Copyright 2024 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.
+# ============================================================================"""
+"""Msprof event classes for MindSpore profiling data."""
+
+from typing import Dict, List, Optional
+from mindspore.profiler.analysis.parser.timeline_event.base_event import (
+    BaseEvent,
+    MetaEvent,
+    InstantEvent,
+    CompleteEvent,
+    CounterEvent
+)
+
+
+class MsprofCompleteEvent(CompleteEvent):
+    """Msprof Complete event class for representing complete operations with duration."""
+    _MINDSPORE_OP_KEY = "mindspore_op"
+
+    def __init__(self, data: Dict):
+        """Initialize complete event with data and empty event references."""
+        super().__init__(data)
+        self._parent: Optional[BaseEvent] = None
+        self._children: List[BaseEvent] = []
+        self._step_id = None
+
+    @property
+    def parent(self) -> BaseEvent:
+        """Get parent event reference."""
+        return self._parent
+
+    @parent.setter
+    def parent(self, event: BaseEvent) -> None:
+        """Set parent event and update mindspore_op argument."""
+        self._parent = event
+        self.args.update({self._MINDSPORE_OP_KEY: event.name})
+
+    @property
+    def children(self) -> List[BaseEvent]:
+        """Get list of children event references."""
+        return self._children
+
+    @property
+    def step_id(self) -> str:
+        """Get parent event reference."""
+        return self._step_id
+
+    @step_id.setter
+    def step_id(self, value):
+        self._step_id = value
+
+
+class MsprofInstantEvent(InstantEvent):
+    """Msprof Instant event class for representing instantaneous operations."""
+
+
+class MsprofMetaEvent(MetaEvent):
+    """Msprof Meta event class for representing metadata information."""
+
+
+class MsprofCounterEvent(CounterEvent):
+    """Msprof Counter event class for representing counter-based metrics."""

mindspore/profiler/analysis/parser/timeline_event/scope_layer_event.py

@@ -0,0 +1,53 @@
+# Copyright 2024 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.
+# ============================================================================"""
+"""Scope event class for representing scope layer operations in profiling data."""
+
+from decimal import Decimal
+
+from mindspore.profiler.common.constant import EventConstant
+from mindspore.profiler.analysis.parser.timeline_event.base_event import CompleteEvent, MetaEvent
+
+
+class ScopeLayerCompleteEvent(CompleteEvent):
+    """Scope layer complete event class for representing scope operations with duration."""
+
+    def __init__(self, data: dict):
+        """Initialize scope layer event with data and duration."""
+        super().__init__(data)
+        self._dur = Decimal(data.get('dur', 0))
+
+    @property
+    def dur(self) -> Decimal:
+        """Get scope operation duration."""
+        return self._dur
+
+    @dur.setter
+    def dur(self, value: Decimal):
+        """Set scope operation duration."""
+        self._dur = value
+
+    @property
+    def pid(self) -> int:
+        """Get scope layer process ID."""
+        return int(EventConstant.SCOPE_LAYER_PID)
+
+
+class ScopeLayerMetaEvent(MetaEvent):
+    """Scope layer meta event class for scope layer metadata."""
+
+    @property
+    def pid(self) -> int:
+        """Get scope layer process ID."""
+        return int(EventConstant.SCOPE_LAYER_PID)

mindspore/profiler/analysis/parser/timeline_event/timeline_event_pool.py

@@ -0,0 +1,146 @@
+# Copyright 2024 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.
+# ============================================================================"""
+"""Timeline event pool for managing and categorizing events."""
+from typing import Dict, List, Set
+from collections import defaultdict
+
+from mindspore.profiler.common.constant import EventConstant
+from mindspore.profiler.analysis.parser.timeline_event.base_event import (
+    BaseEvent,
+    MetaEvent,
+)
+
+
+class TimelineEventPool:
+    """A container class that manages and categorizes events within a specific timeline lane (process).
+
+    This class is responsible for:
+    1. Storing and categorizing different types of events (complete, instant, counter, meta) by thread ID
+    2. Managing timeline connection events within the same process
+    3. Providing event indexing capabilities by thread ID or thread name
+    4. Maintaining thread name mappings for the process
+
+    Note:
+        This class only handles runtime events, offline events are managed separately.
+    """
+
+    def __init__(self, pid):
+        # process ID
+        self.pid = pid
+        self.name = ""
+        # Event storage by phase
+        self.complete_event: Dict[int, List[BaseEvent]] = defaultdict(list)
+        self.instance_event: Dict[int, List[BaseEvent]] = defaultdict(list)
+        self.counter_event: Dict[int, List[BaseEvent]] = defaultdict(list)
+        self.meta_event: List[BaseEvent] = []
+        # Store start/end events for timeline connections
+        self.start_to_end_events_pairs: Dict[str, Dict[str, List[BaseEvent]]] = {}
+        # Thread mappings
+        self.tid_to_name: Dict[int, str] = {}
+        self.name_to_tid: Dict[str, int] = {}
+
+    def add_event(self, event: BaseEvent) -> None:
+        """Add event to timeline based on its phase type."""
+        if event.ph == EventConstant.COMPLETE_EVENT:
+            self.complete_event[event.tid].append(event)
+        elif event.ph == EventConstant.INSTANT_EVENT:
+            self.instance_event[event.tid].append(event)
+        elif event.ph == EventConstant.COUNTER_EVENT:
+            self.counter_event[event.tid].append(event)
+        elif event.ph == EventConstant.META_EVENT:
+            self.meta_event.append(event)
+            self._handle_meta_event(event)
+
+    def _handle_meta_event(self, event: MetaEvent) -> None:
+        """Update process and thread mappings from meta event."""
+        if event.name == EventConstant.PROCESS_NAME:
+            self.name = event.args.get("name", "")
+        elif event.name == EventConstant.THREAD_NAME:
+            tid = event.tid
+            thread_name = event.args.get("name", "")
+            if tid is not None and thread_name:
+                self.tid_to_name[tid] = thread_name
+                self.name_to_tid[thread_name] = tid
+
+    def add_start_event(self, flow_key: str, event: BaseEvent) -> None:
+        """Add start event for timeline connection."""
+        if flow_key not in self.start_to_end_events_pairs:
+            self.start_to_end_events_pairs[flow_key] = {"start": [], "end": []}
+        self.start_to_end_events_pairs[flow_key]["start"].append(event)
+
+    def add_end_event(self, flow_key: str, event: BaseEvent) -> None:
+        """Add end event for timeline connection."""
+        if flow_key not in self.start_to_end_events_pairs:
+            self.start_to_end_events_pairs[flow_key] = {"start": [], "end": []}
+        self.start_to_end_events_pairs[flow_key]["end"].append(event)
+
+    def _get_events(self, event_dict: dict) -> List[BaseEvent]:
+        """Helper function to get events from a dictionary."""
+        events = []
+        for event_list in event_dict.values():
+            events.extend(event_list)
+        return events
+
+    def get_complete_events(self) -> List[BaseEvent]:
+        """Get all complete events."""
+        return self._get_events(self.complete_event)
+
+    def get_instant_events(self) -> List[BaseEvent]:
+        """Get all instant events."""
+        return self._get_events(self.instance_event)
+
+    def get_counter_events(self) -> List[BaseEvent]:
+        """Get all counter events."""
+        return self._get_events(self.counter_event)
+
+    def get_all_events(self) -> List[BaseEvent]:
+        """Get all events in order: meta events first, followed by complete, instant and counter events."""
+        all_events = []
+        all_events.extend(self.meta_event)
+        all_events.extend(self.get_complete_events())
+        all_events.extend(self.get_instant_events())
+        all_events.extend(self.get_counter_events())
+        return all_events
+
+    def get_start_to_end_flow_pairs(self) -> Dict[str, Dict[str, List[BaseEvent]]]:
+        """Get all start/end events for timeline connections."""
+        return self.start_to_end_events_pairs
+
+    def get_events_by_tid(self, tid: int) -> List[BaseEvent]:
+        """Get all events for specified thread ID."""
+        events = []
+        events.extend(self.complete_event.get(tid, []))
+        events.extend(self.instance_event.get(tid, []))
+        events.extend(self.counter_event.get(tid, []))
+        return events
+
+    def get_events_by_name(self, name: str) -> List[BaseEvent]:
+        """Get all events for specified thread name."""
+        tid = self.name_to_tid.get(name)
+        if tid is None:
+            return []
+        return self.get_events_by_tid(tid)
+
+    def get_all_tids(self) -> Set[int]:
+        """Get set of all thread IDs."""
+        tids = set()
+        tids.update(self.complete_event.keys())
+        tids.update(self.instance_event.keys())
+        tids.update(self.counter_event.keys())
+        return tids
+
+    def get_all_events_with_trace_format(self) -> List[Dict]:
+        """Convert and return all events in Chrome trace format."""
+        return [event.to_trace_format() for event in self.get_all_events()]

mindspore/profiler/analysis/task_manager.py

@@ -0,0 +1,131 @@
+# Copyright 2024 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.
+# ============================================================================
+"""Task manager"""
+import time
+from typing import Dict, Any
+from collections import defaultdict
+from multiprocessing import Manager
+from multiprocessing import Process
+
+from mindspore import log as logger
+from mindspore.profiler.common.process_bar import ProcessBar
+from mindspore.profiler.analysis.parser.base_parser import BaseParser
+from mindspore.profiler.analysis.work_flow import WorkFlow
+from mindspore.profiler.common.log import ProfilerLogger
+
+
+class TaskManager:
+    """
+    Manages the execution of workflows consisting of multiple parsers.
+    """
+
+    ROUND_DECIMAL = 2
+
+    def __init__(self):
+        """
+        Initialize the TaskManager with empty workflows and cost time tracking.
+        """
+        self.workflows: Dict[str, WorkFlow] = defaultdict(WorkFlow)
+        self.show_process: Dict[str, bool] = defaultdict(bool)
+        self.flows_cost_time: Dict[str, Dict[str, Any]] = Manager().dict()
+        self._logger = ProfilerLogger.get_instance()
+
+    @property
+    def cost_time(self) -> Dict[str, Dict[str, Any]]:
+        # convert Manager().dict() to dict for json serialization
+        return dict(self.flows_cost_time)
+
+    def create_flow(self, *parsers: BaseParser, flow_name: str, show_process: bool = False) -> None:
+        """
+        Create a workflow with a list of parsers.
+
+        Args:
+            *parsers (BaseParser): The parsers to be executed in the workflow.
+            flow_name (str): The name of the workflow.
+            show_process (bool): Whether to show the process bar of the workflow.
+
+        Raises:
+            ValueError: If any of the provided parsers is not an instance of BaseParser.
+        """
+        if not parsers:
+            logger.error("No parsers provided")
+            return
+
+        workflow = WorkFlow()
+        for parser in parsers:
+            if not isinstance(parser, BaseParser):
+                raise ValueError(
+                    f"parser {parser.__class__.__name__} must be a BaseParser"
+                )
+            workflow.add_parser(parser)
+
+        self.workflows[flow_name] = workflow
+        self.show_process[flow_name] = show_process
+
+    def run(self) -> None:
+        """
+        Run all workflows with the given data using a ProcessPoolExecutor.
+
+        Args:
+            data (Any): The data to be processed by the workflows.
+        """
+        processes = []
+        for flow_name, workflow in self.workflows.items():
+            p = Process(target=self._run_flow, args=(flow_name, workflow))
+            processes.append((p, flow_name))
+            p.start()
+            self._logger.info("TaskManager run flow [%s] [pid: %s] start", flow_name, p.pid)
+
+        for p, flow_name in processes:
+            p.join()
+            self._logger.info("TaskManager flow [%s] [pid: %s] join", flow_name, p.pid)
+
+    def _run_flow(self, flow_name: str, workflow: WorkFlow) -> None:
+        """
+        Run a single workflow with the given data.
+
+        Args:
+            flow_name (str): The name of the workflow.
+            workflow (WorkFlow): The workflow to be executed.
+            data (Any): The data to be processed by the workflow.
+        """
+        start_time = time.perf_counter()
+        parser_cost_time = defaultdict(float)
+
+        parsers = (
+            ProcessBar(workflow, desc="Parsing")
+            if self.show_process[flow_name]
+            else workflow
+        )
+
+        try:
+            data = {}
+            for parser in parsers:
+                parser_start_time = time.perf_counter()
+                data = parser.parse(data)
+                parser_end_time = time.perf_counter()
+                parser_cost_time[parser.__class__.__name__] = round(
+                    parser_end_time - parser_start_time, self.ROUND_DECIMAL
+                )
+        except Exception as e: # pylint: disable=W0703
+            logger.error("Parser %s error: %s", parser.__class__.__name__, str(e))
+            self._logger.error("TaskManager run [%s] error: %s", flow_name, str(e), exc_info=True)
+
+        end_time = time.perf_counter()
+        # Record the cost time of the workflow
+        self.flows_cost_time[flow_name] = {
+            "total_time_seconds": round(end_time - start_time, self.ROUND_DECIMAL),
+            "parser_times_seconds": parser_cost_time,
+        }