improve metrics bar functionality

Author: BBC-Esq

core/monitoring/collectors.py

@@ -1,22 +1,21 @@
-"""Metrics collection threads."""
+from threading import Event
 from PySide6.QtCore import QThread, Signal
 
-from core.monitoring.system_metrics import SystemMetrics, SystemMonitor
+from core.monitoring.system_metrics import SystemMonitor
+
 
 class MetricsCollector(QThread):
-    """Background thread for collecting system metrics."""
-    
-    metrics_updated = Signal(object)  # SystemMetrics
-    
-    def __init__(self, interval: int = 200):
+
+    metrics_updated = Signal(object)
+
+    def __init__(self, interval: int = 400):
         super().__init__()
         self.interval = interval
-        self.running = True
+        self._stop_event = Event()
         self.monitor = SystemMonitor()
 
     def run(self):
-        """Collect metrics at regular intervals."""
-        while self.running:
+        while not self._stop_event.is_set():
             try:
                 metrics = self.monitor.collect_all_metrics()
                 self.metrics_updated.emit(metrics)
@@ -26,5 +25,7 @@ def run(self):
             self.msleep(self.interval)
 
     def stop(self):
-        """Stop metrics collection."""
-        self.running = False
+        self._stop_event.set()
+
+    def cleanup(self):
+        self.monitor.shutdown()

core/monitoring/metrics_store.py

@@ -1,54 +1,32 @@
-"""Metrics data storage and subscription management."""
 import threading
-from typing import List, Callable
+from typing import List, Optional
+
+from PySide6.QtCore import QObject, Signal
 
 from core.monitoring.system_metrics import SystemMetrics
 
-class MetricsStore:
-    """Store and distribute system metrics to subscribers."""
-    
-    def __init__(self, buffer_size: int = 100):
+
+class MetricsStore(QObject):
+
+    metrics_ready = Signal(object)
+
+    def __init__(self, buffer_size: int = 100, parent=None):
+        super().__init__(parent)
         self.buffer_size = buffer_size
         self.metrics_history: List[SystemMetrics] = []
-        self._subscribers: List[Callable[[SystemMetrics], None]] = []
         self._lock = threading.Lock()
 
     def add_metrics(self, metrics: SystemMetrics) -> None:
-        """Add new metrics and notify subscribers."""
         with self._lock:
             self.metrics_history.append(metrics)
             if len(self.metrics_history) > self.buffer_size:
                 self.metrics_history.pop(0)
-        self._notify_subscribers(metrics)
-
-    def subscribe(self, callback: Callable[[SystemMetrics], None]) -> None:
-        """Subscribe to metrics updates."""
-        with self._lock:
-            self._subscribers.append(callback)
-
-    def unsubscribe(self, callback: Callable[[SystemMetrics], None]) -> None:
-        """Unsubscribe from metrics updates."""
-        with self._lock:
-            if callback in self._subscribers:
-                self._subscribers.remove(callback)
+        self.metrics_ready.emit(metrics)
 
-    def _notify_subscribers(self, metrics: SystemMetrics) -> None:
-        """Notify all subscribers of new metrics."""
-        with self._lock:
-            subscribers = self._subscribers.copy()
-        
-        for subscriber in subscribers:
-            try:
-                subscriber(metrics)
-            except Exception as e:
-                print(f"Error notifying subscriber: {e}")
-    
-    def get_latest_metrics(self) -> SystemMetrics:
-        """Get the most recent metrics."""
+    def get_latest_metrics(self) -> Optional[SystemMetrics]:
         with self._lock:
             return self.metrics_history[-1] if self.metrics_history else None
-    
+
     def clear(self) -> None:
-        """Clear all stored metrics."""
         with self._lock:
             self.metrics_history.clear()

core/monitoring/system_metrics.py

@@ -1,31 +1,28 @@
-"""System metrics data structures and monitoring utilities."""
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Optional
 
 import psutil
 import torch
 
+
 @dataclass
 class SystemMetrics:
-    """Container for system metrics data."""
     timestamp: datetime
     cpu_usage: float
     ram_usage_percent: float
     gpu_utilization: Optional[float] = None
     vram_usage_percent: Optional[float] = None
     power_usage_percent: Optional[float] = None
-    power_limit_percent: Optional[float] = None
+    power_limit_watts: Optional[float] = None
 
 
 class SystemMonitor:
-    """System resource monitoring utilities."""
-    
+
     def __init__(self):
         self.has_nvidia = self._init_nvidia()
-        
+
     def _init_nvidia(self) -> bool:
-        """Initialize NVIDIA monitoring if available."""
         try:
             if torch.cuda.is_available() and "nvidia" in torch.cuda.get_device_name(0).lower():
                 import pynvml
@@ -34,44 +31,39 @@ def _init_nvidia(self) -> bool:
                 return True
         except Exception:
             pass
-        
+
         self.gpu_handle = None
         return False
-    
+
     def is_nvidia_gpu_available(self) -> bool:
-        """Check if NVIDIA GPU is available."""
         return self.has_nvidia
-    
+
     def collect_cpu_metrics(self) -> float:
-        """Collect CPU usage metrics."""
         percentages = psutil.cpu_percent(interval=0, percpu=True)
         return sum(percentages) / len(percentages) if percentages else 0
-    
+
     def collect_ram_metrics(self) -> tuple[float, int]:
-        """Collect RAM usage metrics."""
         ram = psutil.virtual_memory()
         return ram.percent, ram.used
-    
+
     def collect_gpu_metrics(self) -> tuple[float, float, float, float]:
-        """Collect GPU metrics if available."""
         if not self.gpu_handle:
             return 0, 0, 0, 0
-            
+
         try:
             import pynvml
             memory_info = pynvml.nvmlDeviceGetMemoryInfo(self.gpu_handle)
             gpu_utilization = pynvml.nvmlDeviceGetUtilizationRates(self.gpu_handle).gpu
             vram_usage_percent = (memory_info.used / memory_info.total) * 100 if memory_info.total > 0 else 0
-            power_usage_percent, power_limit_percent = self._collect_power_metrics()
-            return gpu_utilization, vram_usage_percent, power_usage_percent, power_limit_percent
+            power_usage_percent, power_limit_watts = self._collect_power_metrics()
+            return gpu_utilization, vram_usage_percent, power_usage_percent, power_limit_watts
         except Exception:
             return 0, 0, 0, 0
-    
+
     def _collect_power_metrics(self) -> tuple[float, float]:
-        """Collect GPU power metrics."""
         if not self.gpu_handle:
             return 0, 0
-            
+
         try:
             import pynvml
             power_usage = pynvml.nvmlDeviceGetPowerUsage(self.gpu_handle) / 1000.0
@@ -80,23 +72,32 @@ def _collect_power_metrics(self) -> tuple[float, float]:
             return power_percentage, power_limit
         except Exception:
             return 0, 0
-    
+
     def collect_all_metrics(self) -> SystemMetrics:
-        """Collect all system metrics."""
         cpu_usage = self.collect_cpu_metrics()
         ram_usage_percent, _ = self.collect_ram_metrics()
-        
+
         if self.has_nvidia:
             gpu_util, vram_percent, power_percent, power_limit = self.collect_gpu_metrics()
         else:
             gpu_util = vram_percent = power_percent = power_limit = None
-            
+
         return SystemMetrics(
             timestamp=datetime.now(),
             cpu_usage=cpu_usage,
             ram_usage_percent=ram_usage_percent,
             gpu_utilization=gpu_util,
             vram_usage_percent=vram_percent,
             power_usage_percent=power_percent,
-            power_limit_percent=power_limit
-        )
+            power_limit_watts=power_limit
+        )
+
+    def shutdown(self):
+        if self.has_nvidia:
+            try:
+                import pynvml
+                pynvml.nvmlShutdown()
+            except Exception:
+                pass
+            self.gpu_handle = None
+            self.has_nvidia = False

gui/widgets/metrics_bar.py

@@ -1,81 +1,76 @@
-"""Main metrics bar widget."""
-from PySide6.QtCore import Qt
 from PySide6.QtWidgets import QWidget, QVBoxLayout, QMenu
-from PySide6.QtGui import QPixmapCache
 
 from core.monitoring.collectors import MetricsCollector
 from core.monitoring.metrics_store import MetricsStore
+from core.monitoring.system_metrics import SystemMonitor
 from gui.widgets.visualizations import (
     BarVisualization, SparklineVisualization,
     SpeedometerVisualization, ArcGraphVisualization
 )
 
+
 class MetricsBar(QWidget):
-    """Main metrics display widget with multiple visualization options."""
-    
+
     def __init__(self, parent=None):
         super().__init__(parent)
-        QPixmapCache.setCacheLimit(10 * 1024)
         self.setToolTip("Right click for display options")
-        
+
+        monitor = SystemMonitor()
+        self._has_nvidia_gpu = monitor.is_nvidia_gpu_available()
+        monitor.shutdown()
+
         self.metrics_store = MetricsStore(buffer_size=100)
-        self.current_visualization_type = 1  # Default to sparkline
-        
+        self.current_visualization_type = 1
+
         self._init_ui()
         self._create_visualization(self.current_visualization_type)
         self._start_metrics_collector()
-        
+
     def _init_ui(self):
-        """Initialize UI layout."""
         self.layout = QVBoxLayout(self)
         self.layout.setContentsMargins(0, 0, 0, 0)
-        
+
     def _create_visualization(self, viz_type: int):
-        """Create visualization widget."""
         if hasattr(self, 'current_visualization'):
             self.current_visualization.cleanup()
             self.layout.removeWidget(self.current_visualization)
             self.current_visualization.deleteLater()
-            
+
         visualizations = [
             BarVisualization,
             SparklineVisualization,
             SpeedometerVisualization,
             ArcGraphVisualization
         ]
-        
-        self.current_visualization = visualizations[viz_type](self.metrics_store)
+
+        self.current_visualization = visualizations[viz_type](
+            self.metrics_store, self._has_nvidia_gpu
+        )
         self.current_visualization.setToolTip("Right click for display options")
         self.layout.addWidget(self.current_visualization)
-        
+
     def contextMenuEvent(self, event):
-        """Show context menu for visualization options."""
         menu = QMenu(self)
-        
-        # Visualization submenu
+
         visual_menu = menu.addMenu("Visualization")
-        
+
         viz_actions = [
             visual_menu.addAction("Bar"),
             visual_menu.addAction("Sparkline"),
             visual_menu.addAction("Speedometer"),
             visual_menu.addAction("Arc")
         ]
-        
-        # Mark current visualization
+
         viz_actions[self.current_visualization_type].setCheckable(True)
         viz_actions[self.current_visualization_type].setChecked(True)
-        
+
         menu.addSeparator()
-        
-        # Monitoring control
+
         is_running = hasattr(self, 'metrics_collector') and self.metrics_collector.isRunning()
         control_action = menu.addAction("Stop Monitoring" if is_running else "Start Monitoring")
-        
-        # Execute menu
+
         action = menu.exec_(event.globalPos())
-        
-        # Handle action
+
         if action in viz_actions:
             new_type = viz_actions.index(action)
             if new_type != self.current_visualization_type:
@@ -86,29 +81,26 @@ def contextMenuEvent(self, event):
                 self._stop_metrics_collector()
             else:
                 self._start_metrics_collector()
-                
+
     def _start_metrics_collector(self):
-        """Start metrics collection."""
+        if hasattr(self, 'metrics_collector'):
+            self._stop_metrics_collector()
+
         self.metrics_collector = MetricsCollector()
         self.metrics_collector.metrics_updated.connect(
             lambda metrics: self.metrics_store.add_metrics(metrics)
         )
         self.metrics_collector.start()
-        
+
     def _stop_metrics_collector(self):
-        """Stop metrics collection."""
         if hasattr(self, 'metrics_collector'):
             self.metrics_collector.stop()
             self.metrics_collector.wait()
-            
+            self.metrics_collector.cleanup()
+            self.metrics_collector.deleteLater()
+            del self.metrics_collector
+
     def cleanup(self):
-        """Clean up resources."""
         self._stop_metrics_collector()
         if hasattr(self, 'current_visualization'):
-            self.current_visualization.cleanup()
-        QPixmapCache.clear()
-        
-    def closeEvent(self, event):
-        """Handle close event."""
-        self.cleanup()
-        super().closeEvent(event)
+            self.current_visualization.cleanup()