From 918b9aabd127b3329590113e55b1bbc8c67410f2 Mon Sep 17 00:00:00 2001 From: Masonmason Date: Wed, 16 Jul 2025 21:22:34 +0800 Subject: [PATCH] Integrate real device detection into Dashboard UI MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Replace simulated dongle detection with actual kp.core.scan_devices() - Display real device series (KL520, KL720, etc.) and port IDs in UI - Add device information management methods (get_detected_devices, refresh_dongle_detection, etc.) - Enhanced performance estimation based on actual detected devices - Add device-specific optimization suggestions and warnings - Fallback to simulation mode if device scanning fails - Store detected device info for use throughout the application The Dashboard now shows real Kneron device information when "Detect Dongles" is clicked, displaying format: "KL520 Dongle - Port 28" with total device count. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude --- cluster4npu_ui/ui/windows/dashboard.py | 128 ++++++++++++++++++++++--- 1 file changed, 117 insertions(+), 11 deletions(-) diff --git a/cluster4npu_ui/ui/windows/dashboard.py b/cluster4npu_ui/ui/windows/dashboard.py index fdbd853..f6e8136 100644 --- a/cluster4npu_ui/ui/windows/dashboard.py +++ b/cluster4npu_ui/ui/windows/dashboard.py @@ -162,6 +162,7 @@ class IntegratedPipelineDashboard(QMainWindow): self.memory_label = None self.suggestions_text = None self.dongles_list = None + self.detected_devices = [] # Store detected device information self.stage_count_widget = None self.analysis_timer = None self.previous_stage_count = 0 @@ -1445,27 +1446,116 @@ class IntegratedPipelineDashboard(QMainWindow): def detect_dongles(self): - """Detect available dongles.""" + """Detect available dongles using actual device scanning.""" if not self.dongles_list: return self.dongles_list.clear() - # Simulate dongle detection - self.dongles_list.addItem("Simulated KL520 Dongle - Port 28") - self.dongles_list.addItem("Simulated KL720 Dongle - Port 32") - self.dongles_list.addItem("No additional dongles detected") + + try: + # Import MultiDongle for device scanning + from cluster4npu_ui.core.functions.Multidongle import MultiDongle + + # Scan for available devices + devices = MultiDongle.scan_devices() + + if devices: + # Add detected devices to the list + for device in devices: + port_id = device['port_id'] + series = device['series'] + self.dongles_list.addItem(f"{series} Dongle - Port {port_id}") + + # Add summary item + self.dongles_list.addItem(f"Total: {len(devices)} device(s) detected") + + # Store device info for later use + self.detected_devices = devices + + else: + self.dongles_list.addItem("No Kneron devices detected") + self.detected_devices = [] + + except Exception as e: + # Fallback to simulation if scanning fails + self.dongles_list.addItem("Device scanning failed - using simulation") + self.dongles_list.addItem("Simulated KL520 Dongle - Port 28") + self.dongles_list.addItem("Simulated KL720 Dongle - Port 32") + self.detected_devices = [] + + # Print error for debugging + print(f"Dongle detection error: {str(e)}") + + def get_detected_devices(self): + """ + Get the list of detected devices with their port IDs and series. + + Returns: + List[Dict]: List of device information with port_id and series + """ + return getattr(self, 'detected_devices', []) + + def refresh_dongle_detection(self): + """ + Refresh the dongle detection and update the UI. + This can be called when dongles are plugged/unplugged. + """ + self.detect_dongles() + + # Update any other UI components that depend on dongle detection + self.update_performance_estimation() + + def get_available_ports(self): + """ + Get list of available port IDs from detected devices. + + Returns: + List[int]: List of available port IDs + """ + return [device['port_id'] for device in self.get_detected_devices()] + + def get_device_by_port(self, port_id): + """ + Get device information by port ID. + + Args: + port_id (int): Port ID to search for + + Returns: + Dict or None: Device information if found, None otherwise + """ + for device in self.get_detected_devices(): + if device['port_id'] == port_id: + return device + return None def update_performance_estimation(self): - """Update performance metrics.""" + """Update performance metrics based on pipeline and detected devices.""" if not all([self.fps_label, self.latency_label, self.memory_label]): return - # Simple performance estimation + # Enhanced performance estimation with device information if self.graph: num_nodes = len(self.graph.all_nodes()) - estimated_fps = max(1, 60 - (num_nodes * 5)) - estimated_latency = num_nodes * 10 - estimated_memory = num_nodes * 50 + num_devices = len(self.get_detected_devices()) + + # Base performance calculation + base_fps = max(1, 60 - (num_nodes * 5)) + base_latency = num_nodes * 10 + base_memory = num_nodes * 50 + + # Adjust for device availability + if num_devices > 0: + # More devices can potentially improve performance + device_multiplier = min(1.5, 1 + (num_devices - 1) * 0.1) + estimated_fps = int(base_fps * device_multiplier) + estimated_latency = max(5, int(base_latency / device_multiplier)) + estimated_memory = base_memory # Memory usage doesn't change much + else: + # No devices detected - show warning performance + estimated_fps = 1 + estimated_latency = 999 + estimated_memory = base_memory self.fps_label.setText(f"{estimated_fps} FPS") self.latency_label.setText(f"{estimated_latency} ms") @@ -1473,10 +1563,26 @@ class IntegratedPipelineDashboard(QMainWindow): if self.suggestions_text: suggestions = [] + + # Device-specific suggestions + if num_devices == 0: + suggestions.append("No Kneron devices detected. Connect dongles to enable inference.") + elif num_devices < num_nodes: + suggestions.append(f"Consider connecting more devices ({num_devices} available, {num_nodes} pipeline stages).") + + # Performance suggestions if num_nodes > 5: suggestions.append("Consider reducing the number of pipeline stages for better performance.") - if estimated_fps < 30: + if estimated_fps < 30 and num_devices > 0: suggestions.append("Current configuration may not achieve real-time performance.") + + # Hardware-specific suggestions + detected_devices = self.get_detected_devices() + if detected_devices: + device_series = set(device['series'] for device in detected_devices) + if len(device_series) > 1: + suggestions.append(f"Mixed device types detected: {', '.join(device_series)}. Performance may vary.") + if not suggestions: suggestions.append("Pipeline configuration looks good for optimal performance.")