mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0__cp39-cp39-win_amd64.whl

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,
+        }

mindspore/profiler/analysis/time_converter.py

@@ -0,0 +1,84 @@
+# 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.
+# ============================================================================
+"""Time converter"""
+from decimal import Decimal
+
+
+class TimeConverter:
+    """
+    Time converter class use to convert syscnt to timestamp
+
+    The timeline is as follows:
+
+
+                  boot                collect start       event
+                    │                     │                │
+     origin─────────┴─────────────────────┴────────────────┴─────────────►
+
+           ────────────────────────────────
+                    local_time_diff
+
+                                          ──────────────────
+                                        cntvct            syscnt
+
+
+    boot: The point of events that occurred at the boot time of server
+    collect start: The point of events that occurred at the profiler collect start time
+    event: The point of events that occurred at the profiler record event time
+
+    schematic:
+    MindSpore profiler record event time is syscnt, we need to convert it to timestamp(us).
+    First, we get the boot time(collectionTimeBegin and clockMonotonicRaw) and
+    collect start time(cntvct and clock_monotonic_raw) from host_start.log,
+    then we can calculate the local_time_diff = clock_monotonic_raw + (collectionTimeBegin - clockMonotonicRaw)
+    Finally, we can get the profiler record absolute syscnt = syscnt - cntvct + local_time_diff, and convert
+    it to timestamp(ns) by formula: timestamp(ns) = syscnt * 1000 / frequency, 1000 means convert ns to us.
+    """
+    # multiplier
+    US_TO_NS = 1000
+    NS_TO_US = Decimal("1e-3")
+    DECIMAL_PRECISION = Decimal("0.000")
+    # parameters from msprof
+    _freq = 100.0
+    _cntvct = 0
+    _localtime_diff = 0
+    _is_loaded = False
+
+    @classmethod
+    def convert_syscnt_to_timestamp_us(cls, syscnt: int) -> Decimal:
+        """
+        Convert syscnt to timestamp(us)
+        Args:
+            syscnt: syscnt
+            time_fmt: time format
+        Returns:
+            timestamp(us)
+        """
+        if not cls._is_loaded:
+            raise RuntimeError("init_parameters must be called first")
+
+        timestamp_ns = Decimal(
+            (syscnt - cls._cntvct) * cls.US_TO_NS / cls._freq
+        ) + Decimal(cls._localtime_diff)
+
+        timestamp_us = timestamp_ns * cls.NS_TO_US
+        return timestamp_us.quantize(cls.DECIMAL_PRECISION)
+
+    @classmethod
+    def init_parameters(cls, freq: float, cntvct: int, localtime_diff: int):
+        cls._freq = freq
+        cls._cntvct = cntvct
+        cls._localtime_diff = localtime_diff
+        cls._is_loaded = True