wperf-cmn-visualizer 0.1.0__py3-none-any.whl

wperf_cmn_visualizer/__init__.py

@@ -0,0 +1,34 @@
+# BSD 3-Clause License
+#
+# Copyright (c) 2025, Arm Limited
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+wperf-cmn-visualizer - A topology visualization tool for CMN mesh networks.
+"""
+__version__ = "0.1.0"

wperf_cmn_visualizer/__main__.py

@@ -0,0 +1,76 @@
+# BSD 3-Clause License
+#
+# Copyright (c) 2025, Arm Limited
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Entry point for running cmn-visualizer as a module.
+"""
+import sys
+import argparse
+from . import __version__
+from .config import Config
+from .wperf_cmn_visualizer import wperfCmnVisualizer
+try:
+    from ctypes import windll
+except ImportError:
+    windll = None
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="A GUI-based visualizer for Arm CMN (Coherent Mesh Network)"
+                    " systems using WindowsPerf backend"
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"{__version__}"
+    )
+    parser.add_argument(
+        "--topology",
+        type=str,
+        default=Config.DEFAULT_TOPOLOGY_FILE,
+        help=f"Path to the topology JSON file (default: {Config.DEFAULT_TOPOLOGY_FILE})",
+    )
+    parser.add_argument(
+        "--telemetry",
+        type=str,
+        help="Path to the telemtry CSV file",
+    )
+    return parser.parse_args()
+
+
+def main() -> int:
+    args: argparse.Namespace = parse_args()
+    if windll:
+        windll.shcore.SetProcessDpiAwareness(1)
+    app: wperfCmnVisualizer = wperfCmnVisualizer(args)
+    return app.run()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

wperf_cmn_visualizer/canvas.py

@@ -0,0 +1,305 @@
+# BSD 3-Clause License
+#
+# Copyright (c) 2025, Arm Limited
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Zoomable and pannable canvas.
+This will serve as the main body to which CMN objects are rendered.
+"""
+
+import tkinter as tk
+import tkinter.font as tkFont
+import ttkbootstrap as tb
+from functools import lru_cache
+from typing import Callable, Optional, Tuple, Any
+from .config import Config
+
+
+class ZoomPanCanvas(tk.Canvas):
+    """
+    A tkinter Canvas subclass that supports zooming and panning.
+    This canvas allows users to zoom in and out and pan across the content.
+    It maintains a zoom scale and offset to convert between world coordinates
+    and screen coordinates.
+    It also supports a hover callback for mouse movement in world coordinates.
+    Also a redraw callback automaticalled called when redraw required.
+    Attributes:
+        zoom_scale : float
+            The current zoom scale factor.
+        offset_x : float
+            Horizontal offset for panning.
+        offset_y : float
+            Vertical offset for panning.
+        hover_callback : Optional[Callable[[float, float], None]]
+            Optional callback for mouse hover events in world coordinates.
+        redraw_callback : Callable[[], None]
+            Callback to trigger canvas redraw; must take zero arguments.
+    """
+    def __init__(self, master: tb.Window, redraw_callback: Callable[[], None], **kwargs: Any) -> None:
+        """
+        Args:
+        master : tb.Frame
+            The parent tkinter root
+        redraw_callback : Callable[[], None]
+            A callback function that is called whenever the canvas
+            needs to be redrawn, such as after panning or zooming.
+            This function must take no parameters.
+        kwargs : dict
+            Additional keyword arguments to be passed to the base tk.Canvas.
+        """
+        super().__init__(master, **kwargs)
+        self.zoom_scale: float = Config.DEFAULT_ZOOM
+        self.offset_x: float = 0.0
+        self.offset_y: float = 0.0
+        self._pan_start_x: int = 0
+        self._pan_start_y: int = 0
+        self.hover_callback: Optional[Callable[[float, float], None]] = None
+        self.redraw_callback: Callable[[], None] = redraw_callback
+        self.font: tkFont.Font = tkFont.Font()
+        self._setup_bindings()
+
+    def get_dynamic_grid_cell_size(self) -> float:
+        """Scale Current Grid Size."""
+        return Config.GRID_CELL_SIZE * (1.0 + (self.zoom_scale - 1.0) * 0.2)
+
+    def _setup_bindings(self) -> None:
+        """Set up mouse and keyboard event bindings."""
+        self.bind("<ButtonPress-1>", self._start_pan)
+        self.bind("<B1-Motion>", self._do_pan)
+        self.bind("<MouseWheel>", self._do_zoom)
+        self.bind("<Configure>", self._on_resize)
+        self.bind("<Motion>", self._on_mouse_move)
+        self.bind_all("<Control-plus>", self._do_zoom)
+        self.bind_all("<Control-equal>", self._do_zoom)
+        self.bind_all("<Control-minus>", self._do_zoom)
+
+    def _start_pan(self, event: tk.Event) -> None:
+        """Start panning operation."""
+        self._pan_start_x = event.x
+        self._pan_start_y = event.y
+
+    def _do_pan(self, event: tk.Event) -> None:
+        """Handle panning motion."""
+        dx = event.x - self._pan_start_x
+        dy = event.y - self._pan_start_y
+        self.offset_x += dx
+        self.offset_y += dy
+        self._pan_start_x = event.x
+        self._pan_start_y = event.y
+        self.redraw_callback()
+
+    def _do_zoom(self, event: tk.Event) -> None:
+        """Handle zoom operation from mouse wheel or keyboard shortcuts."""
+        if event.type == tk.EventType.MouseWheel:
+            if event.delta > 0 and self.zoom_scale >= Config.MAX_ZOOM:
+                return
+            if event.delta < 0 and self.zoom_scale <= Config.MIN_ZOOM:
+                return
+            factor = Config.ZOOM_FACTOR if event.delta > 0 else 1 / Config.ZOOM_FACTOR
+            mouse_x = self.canvasx(event.x)
+            mouse_y = self.canvasy(event.y)
+
+        elif event.type == tk.EventType.KeyPress:
+            key = event.keysym.lower()
+            if key in ("equal", "plus") and self.zoom_scale < Config.MAX_ZOOM:
+                factor = Config.ZOOM_FACTOR
+            elif key == "minus" and self.zoom_scale > Config.MIN_ZOOM:
+                factor = 1 / Config.ZOOM_FACTOR
+            else:
+                return
+            mouse_x = self.canvasx(self.winfo_width() / 2)
+            mouse_y = self.canvasy(self.winfo_height() / 2)
+        else:
+            return
+
+        new_scale = max(Config.MIN_ZOOM, min(self.zoom_scale * factor, Config.MAX_ZOOM))
+        if new_scale != self.zoom_scale:
+            old_grid_size = self.get_dynamic_grid_cell_size()
+            old_world_x = (mouse_x - self.offset_x) / self.zoom_scale
+            old_world_y = (mouse_y - self.offset_y) / self.zoom_scale
+            self.zoom_scale = new_scale
+            new_grid_size = self.get_dynamic_grid_cell_size()
+            grid_scale_factor = new_grid_size / old_grid_size
+            new_world_x = old_world_x * grid_scale_factor
+            new_world_y = old_world_y * grid_scale_factor
+            self.offset_x = mouse_x - new_world_x * self.zoom_scale
+            self.offset_y = mouse_y - new_world_y * self.zoom_scale
+
+            self.redraw_callback()
+
+    def _on_resize(self, event: tk.Event) -> None:
+        """Handle canvas resize."""
+        self.redraw_callback()
+
+    def _on_mouse_move(self, event: tk.Event) -> None:
+        """Handle mouse movement for hover effects."""
+        if self.hover_callback:
+            wx = (event.x - self.offset_x) / self.zoom_scale
+            wy = (event.y - self.offset_y) / self.zoom_scale
+            self.hover_callback(wx, wy)
+
+    def world_to_screen(self, x: float, y: float) -> Tuple[float, float]:
+        """Convert world coordinates to screen coordinates."""
+        return x * self.zoom_scale + self.offset_x, y * self.zoom_scale + self.offset_y
+
+    # Line thickness constants
+    MIN_THICKNESS = 1
+    MAX_THICKNESS = 3
+
+    def draw_line(
+            self,
+            x1: float, y1: float,
+            x2: float, y2: float,
+            color: str, thickness: float = 1.0,
+            scale_rate: float = 1.0,
+            tag: str = "") -> int:
+        """Draw a line in world coordinates."""
+
+        sx1, sy1 = self.world_to_screen(x1, y1)
+        sx2, sy2 = self.world_to_screen(x2, y2)
+        effective_scale = self.zoom_scale ** scale_rate
+        base_thickness = thickness * effective_scale
+        scaled_thickness = max(self.MIN_THICKNESS, min(self.MAX_THICKNESS, base_thickness))
+        return self.create_line(
+            sx1, sy1, sx2, sy2,
+            fill=color,
+            width=scaled_thickness,
+            tags=tag
+        )
+
+    def draw_rectangle(
+            self,
+            x: float, y: float,
+            width: float, height: float,
+            color: str, outline_color: str = "black",
+            outline_thickness=1.0,
+            scale_rate: float = 1.0,
+            tag: str = "") -> int:
+        """Draw a filled rectangle in world coordinates."""
+
+        sx, sy = self.world_to_screen(x, y)
+        effective_scale = self.zoom_scale ** scale_rate
+        scaled_width = width * effective_scale
+        scaled_height = height * effective_scale
+        base_thickness = outline_thickness * effective_scale
+        scaled_thickness = max(self.MIN_THICKNESS, min(self.MAX_THICKNESS, base_thickness))
+
+        sx1 = sx - scaled_width / 2
+        sy1 = sy - scaled_height / 2
+        sx2 = sx + scaled_width / 2
+        sy2 = sy + scaled_height / 2
+
+        return self.create_rectangle(
+            sx1, sy1, sx2, sy2,
+            fill=color, outline=outline_color,
+            width=scaled_thickness,
+            tags=tag
+        )
+
+    def draw_outline_rectangle(
+            self,
+            x: float, y: float,
+            width: float, height: float,
+            outline_color: str, thickness: float = 1.0,
+            scale_rate: float = 1.0,
+            tag: str = "") -> int:
+        """Draw an outline rectangle in world coordinates."""
+
+        sx, sy = self.world_to_screen(x, y)
+        effective_scale = self.zoom_scale ** scale_rate
+        scaled_width = width * effective_scale
+        scaled_height = height * effective_scale
+        base_thickness = thickness * effective_scale
+        scaled_thickness = max(self.MIN_THICKNESS, min(self.MAX_THICKNESS, base_thickness))
+
+        sx1 = sx - scaled_width / 2
+        sy1 = sy - scaled_height / 2
+        sx2 = sx + scaled_width / 2
+        sy2 = sy + scaled_height / 2
+
+        return self.create_rectangle(
+            sx1, sy1, sx2, sy2,
+            fill="", outline=outline_color,
+            width=scaled_thickness,
+            tags=tag
+        )
+
+    def draw_text(
+            self,
+            x: float, y: float,
+            text: str,
+            color: str = "white", font_size: int = 12,
+            angle: float = 0,
+            scale_rate: float = 1.0,
+            tag: str = "") -> int:
+        """Draw text in world coordinates."""
+
+        sx, sy = self.world_to_screen(x, y)
+        effective_scale = self.zoom_scale ** scale_rate
+        scaled_font_size = max(1, int(font_size * effective_scale))
+        return self.create_text(
+            sx, sy, text=text,
+            fill=color, font=("", scaled_font_size),
+            angle=angle,
+            tags=tag
+        )
+
+    @staticmethod
+    @lru_cache(maxsize=1024)
+    def _get_font(scaled_size: int) -> tkFont.Font:
+        """Cache Font objects"""
+        return tkFont.Font(size=scaled_size)
+
+    @staticmethod
+    @lru_cache(maxsize=4096)
+    def _measure_text_width_scaled(text: str, scaled_size: int) -> float:
+        """Cache measuremeants"""
+        f = ZoomPanCanvas._get_font(scaled_size)
+        return f.measure(text)
+
+    @staticmethod
+    @lru_cache(maxsize=1024)
+    def _measure_text_height_scaled(scaled_size: int) -> float:
+        """Actual cached measurement with scaled font size"""
+        f = ZoomPanCanvas._get_font(scaled_size)
+        return f.metrics("linespace")
+
+    def get_text_width(self, text: str, font_size: int, scale_rate: float = 1.0) -> float:
+        zoom_scale = self.zoom_scale
+        effective_scale = zoom_scale ** scale_rate
+        scaled_size = max(1, int(font_size * effective_scale))
+        width_px = ZoomPanCanvas._measure_text_width_scaled(text, scaled_size)
+        return width_px / effective_scale
+
+    def get_text_height(self, font_size: int, scale_rate: float = 1.0) -> float:
+        zoom_scale = self.zoom_scale
+        effective_scale = zoom_scale ** scale_rate
+        scaled_size = max(1, int(font_size * effective_scale))
+        height_px = ZoomPanCanvas._measure_text_height_scaled(scaled_size)
+        return height_px / effective_scale

wperf_cmn_visualizer/cmn.py

@@ -0,0 +1,219 @@
+# BSD 3-Clause License
+#
+# Copyright (c) 2025, Arm Limited
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+CMN mesh data structures and operations.
+"""
+
+import numpy as np
+from numpy import dtype as np_dtype
+from typing import Dict, Any, List
+
+CMN_MAX_PORTS: int = 6
+CMN_MAX_CHILDS: int = 32
+CMN_MAX_MESH_WIDTH: int = 12
+CMN_MAX_MESH_HEIGHT: int = 12
+CMN_TYPE_STR_MAX_LEN: int = 128
+CMN_XP_DEVICE_ID: int = 6
+
+coord_dtype = np_dtype(
+    [
+        ("x", "u1"),
+        ("y", "u1"),
+    ]
+)
+
+node_dtype = np_dtype(
+    [
+        ("coord", coord_dtype),
+        ("nodeid", "u2"),
+        ("logicalid", "u2"),
+        ("type", "u2"),
+        ("type_str", "U128"),
+    ]
+)
+
+port_dtype = np_dtype(
+    [
+        ("type", "u1"),
+        ("type_str", "U128"),
+        ("cal", "b1"),
+        ("num_devices", "u1"),
+        ("devices", node_dtype, CMN_MAX_CHILDS),
+    ]
+)
+
+xp_dtype = np_dtype(
+    [
+        ("node_info", node_dtype),
+        ("dtc_domain", "u1"),
+        ("num_device_ports", "u1"),
+        ("ports", port_dtype, CMN_MAX_PORTS),
+    ]
+)
+
+mesh_dtype = np_dtype(
+    [
+        ("x_dim", "u1"),
+        ("y_dim", "u1"),
+        ("xps", xp_dtype, (CMN_MAX_MESH_HEIGHT, CMN_MAX_MESH_WIDTH)),
+    ]
+)
+
+
+class CMN:
+    """
+    Top-level CMN topology container managing multiple meshes.
+    Attributes:
+        num_meshes (int): Number of meshes in the topology
+        meshes (np.ndarray): Array of mesh structures.
+    """
+    def __init__(self, topology: Dict[str, Any]) -> None:
+        """
+        Initialise CMN topology from JSON configuration.
+        Args:
+            topology (Dict[str, Any]): JSON configuration
+        Raises:
+            AssertionError: On invalid input
+        """
+        assert "elements" in topology, "topology data does not contain elements information"
+        self.num_meshes: int = len(topology["elements"])
+        assert self.num_meshes > 0, f"topology data contained {self.num_meshes} meshes"
+        self.meshes = np.zeros(self.num_meshes, dtype=mesh_dtype)
+
+        for i, element in enumerate(topology["elements"]):
+            assert "config" in element, f"element idx: {i} does not contain configuration data"
+            self._init_mesh(self.meshes[i], element["config"])
+
+    def _init_mesh(self, mesh: np.ndarray, config: Dict[str, Any]) -> None:
+        """
+        Initialise a single mesh element.
+        Args:
+            mesh (np.ndarray): The structured array element to populate
+            config (Dict[str, Any]): Configuration data for the mesh
+        """
+        x_val = config.get("X", 0)
+        y_val = config.get("Y", 0)
+
+        x_dim = int(x_val)
+        y_dim = int(y_val)
+
+        assert 0 < x_dim <= CMN_MAX_MESH_WIDTH, f"invalid x dimension on mesh, got: {x_dim}"
+        assert 0 < y_dim <= CMN_MAX_MESH_HEIGHT, f"invalid y dimension on mesh, got: {y_dim}"
+
+        mesh["x_dim"] = x_dim
+        mesh["y_dim"] = y_dim
+
+        assert "xps" in config, "no XP information on mesh"
+        assert len(config["xps"]) > 0, "empty XP information on mesh"
+
+        self._load_data(mesh, config["xps"], x_dim, y_dim)
+
+    def _load_data(
+        self,
+        mesh: np.ndarray,
+        xps_data: List[Dict[str, Any]],
+        x_dim: int, y_dim: int
+    ) -> None:
+        """
+        Load XP data into the mesh structure.
+        Args:
+            mesh (np.ndarray): Mesh structure
+            xps_data (List[Dict[str, Any]]): List of XP data
+            x_dim (int): Width of mesh
+            y_dim (int): Height of mesh
+        """
+        for xp in xps_data:
+            x = int(xp.get("X", 0))
+            y = int(xp.get("Y", 0))
+
+            if not (0 <= x < x_dim and 0 <= y < y_dim):
+                continue
+
+            node_xp = mesh["xps"][y, x]
+
+            node_xp["node_info"]["coord"]["x"] = x
+            node_xp["node_info"]["coord"]["y"] = y
+            node_xp["node_info"]["nodeid"] = xp.get("id", 0)
+            node_xp["node_info"]["logicalid"] = xp.get("logical_id", 0)
+            node_xp["node_info"]["type"] = CMN_XP_DEVICE_ID
+            node_xp["node_info"]["type_str"] = "XP"
+
+            node_xp["dtc_domain"] = xp.get("dtc", 0)
+            node_xp["num_device_ports"] = xp.get("n_ports", 0)
+
+            for port in xp.get("ports", [])[:CMN_MAX_PORTS]:
+                if "port" not in port or not (0 <= port["port"] < CMN_MAX_PORTS):
+                    continue
+
+                po = node_xp["ports"][port["port"]]
+                po["type"] = port.get("type", 0)
+                po["type_str"] = port.get("type_s", "unknown")[:CMN_TYPE_STR_MAX_LEN]
+                po["cal"] = port.get("cal", False)
+
+                devices_list = port.get("devices", [])[:CMN_MAX_CHILDS]
+                po["num_devices"] = len(devices_list)
+
+                for d, device in enumerate(devices_list):
+                    dev = po["devices"][d]
+                    dev["coord"]["x"] = x
+                    dev["coord"]["y"] = y
+                    dev["nodeid"] = device.get("id", 0)
+                    dev["logicalid"] = device.get("logical_id", 0)
+                    dev["type"] = device.get("type", 0)
+                    dev["type_str"] = device.get("type_s", "unknown")[:CMN_TYPE_STR_MAX_LEN]
+
+    def get_view(
+        self,
+        mesh_idx: int,
+        min_row: int, max_row: int,
+        min_col: int, max_col: int
+    ):
+        """
+        Get a view of the mesh array for the visible region (NumPy array slicing).
+        Args:
+            mesh_idx (int): Mesh index
+            min_row (int): Start row (inclusive)
+            max_row (int): End row (inclusive)
+            min_col (int): Start col (inclusive)
+            max_col (int): End col (inclusive)
+        Returns:
+            NDArray[np.ndarray]: Sliced 2D view of the mesh XP array
+        """
+        mesh = self.meshes[mesh_idx]
+        x_dim = mesh["x_dim"]
+        y_dim = mesh["y_dim"]
+
+        min_row = max(0, min_row)
+        max_row = min(y_dim, max_row + 1)
+        min_col = max(0, min_col)
+        max_col = min(x_dim, max_col + 1)
+
+        return mesh["xps"][min_row:max_row, min_col:max_col]