Fixed NAN issue in memory reporting.

Fixed Active Simulations not clear when sim completes

Author: rhamlett_microsoft

src/PerfProblemSimulator/Services/MetricsBroadcastService.cs

@@ -29,6 +29,7 @@ namespace PerfProblemSimulator.Services;
 public class MetricsBroadcastService : IHostedService
 {
     private readonly IMetricsCollector _metricsCollector;
+    private readonly ISimulationTracker _simulationTracker;
     private readonly IHubContext<MetricsHub, IMetricsClient> _hubContext;
     private readonly ILogger<MetricsBroadcastService> _logger;
 
@@ -37,10 +38,12 @@ public class MetricsBroadcastService : IHostedService
     /// </summary>
     public MetricsBroadcastService(
         IMetricsCollector metricsCollector,
+        ISimulationTracker simulationTracker,
         IHubContext<MetricsHub, IMetricsClient> hubContext,
         ILogger<MetricsBroadcastService> logger)
     {
         _metricsCollector = metricsCollector ?? throw new ArgumentNullException(nameof(metricsCollector));
+        _simulationTracker = simulationTracker ?? throw new ArgumentNullException(nameof(simulationTracker));
         _hubContext = hubContext ?? throw new ArgumentNullException(nameof(hubContext));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
     }
@@ -49,6 +52,8 @@ public MetricsBroadcastService(
     public Task StartAsync(CancellationToken cancellationToken)
     {
         _metricsCollector.MetricsCollected += OnMetricsCollected;
+        _simulationTracker.SimulationStarted += OnSimulationStarted;
+        _simulationTracker.SimulationCompleted += OnSimulationCompleted;
         _metricsCollector.Start();
 
         _logger.LogInformation("Metrics broadcast service started");
@@ -59,6 +64,8 @@ public Task StartAsync(CancellationToken cancellationToken)
     public Task StopAsync(CancellationToken cancellationToken)
     {
         _metricsCollector.MetricsCollected -= OnMetricsCollected;
+        _simulationTracker.SimulationStarted -= OnSimulationStarted;
+        _simulationTracker.SimulationCompleted -= OnSimulationCompleted;
         _metricsCollector.Stop();
 
         _logger.LogInformation("Metrics broadcast service stopped");
@@ -76,4 +83,30 @@ private async void OnMetricsCollected(object? sender, MetricsSnapshot snapshot)
             _logger.LogError(ex, "Error broadcasting metrics to clients");
         }
     }
+
+    private async void OnSimulationStarted(object? sender, SimulationEventArgs e)
+    {
+        try
+        {
+            await _hubContext.Clients.All.SimulationStarted(e.Type.ToString(), e.SimulationId);
+            _logger.LogDebug("Broadcast SimulationStarted: {Type} {Id}", e.Type, e.SimulationId);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error broadcasting simulation started event");
+        }
+    }
+
+    private async void OnSimulationCompleted(object? sender, SimulationEventArgs e)
+    {
+        try
+        {
+            await _hubContext.Clients.All.SimulationCompleted(e.Type.ToString(), e.SimulationId);
+            _logger.LogDebug("Broadcast SimulationCompleted: {Type} {Id}", e.Type, e.SimulationId);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error broadcasting simulation completed event");
+        }
+    }
 }

src/PerfProblemSimulator/Services/SimulationTracker.cs

@@ -8,6 +8,16 @@ namespace PerfProblemSimulator.Services;
 /// </summary>
 public interface ISimulationTracker
 {
+    /// <summary>
+    /// Event fired when a simulation is registered.
+    /// </summary>
+    event EventHandler<SimulationEventArgs>? SimulationStarted;
+
+    /// <summary>
+    /// Event fired when a simulation is unregistered (completed or cancelled).
+    /// </summary>
+    event EventHandler<SimulationEventArgs>? SimulationCompleted;
+
     /// <summary>
     /// Registers a new active simulation.
     /// </summary>
@@ -61,6 +71,31 @@ void RegisterSimulation(
     bool TryGetSimulation(Guid simulationId, out ActiveSimulationInfo? info);
 }
 
+/// <summary>
+/// Event arguments for simulation lifecycle events.
+/// </summary>
+public class SimulationEventArgs : EventArgs
+{
+    /// <summary>
+    /// Gets the simulation ID.
+    /// </summary>
+    public Guid SimulationId { get; }
+
+    /// <summary>
+    /// Gets the simulation type.
+    /// </summary>
+    public SimulationType Type { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SimulationEventArgs"/> class.
+    /// </summary>
+    public SimulationEventArgs(Guid simulationId, SimulationType type)
+    {
+        SimulationId = simulationId;
+        Type = type;
+    }
+}
+
 /// <summary>
 /// Information about an active simulation.
 /// </summary>
@@ -112,6 +147,12 @@ public class SimulationTracker : ISimulationTracker
     private readonly ConcurrentDictionary<Guid, TrackedSimulation> _simulations = new();
     private readonly ILogger<SimulationTracker> _logger;
 
+    /// <inheritdoc />
+    public event EventHandler<SimulationEventArgs>? SimulationStarted;
+
+    /// <inheritdoc />
+    public event EventHandler<SimulationEventArgs>? SimulationCompleted;
+
     /// <summary>
     /// Internal tracking record that includes the cancellation source.
     /// </summary>
@@ -155,6 +196,9 @@ public void RegisterSimulation(
                 type,
                 simulationId,
                 parameters);
+
+            // Fire the SimulationStarted event
+            SimulationStarted?.Invoke(this, new SimulationEventArgs(simulationId, type));
         }
         else
         {
@@ -174,6 +218,10 @@ public bool UnregisterSimulation(Guid simulationId)
                 tracked.Info.Type,
                 simulationId,
                 DateTimeOffset.UtcNow - tracked.Info.StartedAt);
+
+            // Fire the SimulationCompleted event
+            SimulationCompleted?.Invoke(this, new SimulationEventArgs(simulationId, tracked.Info.Type));
+
             return true;
         }
 

src/PerfProblemSimulator/wwwroot/js/dashboard.js

@@ -360,8 +360,9 @@ async function allocateMemory() {
 
         if (response.ok) {
             const result = await response.json();
-            addActiveSimulation(result.blockId, 'memory', `Memory ${sizeMb}MB`);
-            logEvent('success', `Memory allocated: ${result.blockId} (${result.actualSizeBytes / 1024 / 1024} MB)`);
+            const actualSizeMb = result.actualParameters?.sizeMegabytes ?? sizeMb;
+            addActiveSimulation(result.simulationId, 'memory', `Memory ${actualSizeMb}MB`);
+            logEvent('success', `Memory allocated: ${result.simulationId} (${actualSizeMb} MB)`);
         } else {
             const error = await response.json();
             logEvent('error', `Failed: ${error.detail || 'Unknown error'}`);
@@ -387,7 +388,8 @@ async function releaseMemory() {
                 }
             });
             updateActiveSimulationsUI();
-            logEvent('success', `Released ${result.blocksReleased} blocks (${result.bytesReleased / 1024 / 1024} MB)`);
+            const releasedMb = result.releasedMegabytes ?? (result.releasedBytes / 1024 / 1024);
+            logEvent('success', `Released ${result.releasedBlockCount ?? 0} blocks (${releasedMb.toFixed(1)} MB)`);
         } else {
             const error = await response.json();
             logEvent('error', `Failed: ${error.detail || 'Unknown error'}`);