From c821681d0a64b51b3f2b44ce000a04e622c3091f Mon Sep 17 00:00:00 2001 From: Max Claude Date: Sun, 15 Nov 2026 11:49:45 +0100 Subject: [PATCH] Run scenarios on the thread pool, queue System Log entries A scenario ran entirely on the WPF UI thread: RunOnceAsync called the engine on the dispatcher, and the engine awaits without ConfigureAwait(false). The time between two nodes depended on the UI's load, and a blocking node froze the window. Every log call also waited for the UI thread (Dispatcher.Invoke). - Services/ScenarioRun.RunAsync takes a snapshot of the graph on the UI thread and starts the engine with Task.Run. RunOnceAsync continues on the UI thread after the await. - The snapshot is a copy nothing else refers to: opening a scenario during a run clears TransactionJson of the stored nodes. A node from an older file that only names its transaction gets a copy of the library transaction, so the engine does not read or write the UI-bound library for it. The copy is written with the invariant culture; the SecsGemBase converter otherwise turns 1,5 into 15 on a decimal-comma system. - ObservableLogger queues entries with Dispatcher.InvokeAsync, like SecsMessageLogger, takes an optional dispatcher provider and drops the entry when there is no dispatcher. ScenariosViewModel writes its own lines through the logger, so they keep their place between the engine's lines. - Runs enter the engine one at a time (it keeps the run's cancellation source in a field while it starts), and an And node's late "1/2 branches" report no longer replaces its Succeeded state. Both were harmless on a single thread. - specification/features.md: new section. New tests: ScenarioRunTests and ObservableLoggerTests. Internal board: secsgem/evencoolerfastsim issue 26. Co-Authored-By: Claude Fable 5.2 --- .../ObservableLoggerTests.cs | 81 ++++ EvenBetterFastSim.Tests/ScenarioRunTests.cs | 378 ++++++++++++++++++ EvenBetterFastSim.Tests/TestSupport.cs | 40 ++ EvenBetterFastSim/Logging/ObservableLogger.cs | 16 +- EvenBetterFastSim/Services/ScenarioRun.cs | 152 +++++++ .../WPF/ViewModels/ScenariosViewModel.cs | 21 +- specification/features.md | 23 ++ 7 files changed, 695 insertions(+), 16 deletions(-) create mode 100644 EvenBetterFastSim.Tests/ObservableLoggerTests.cs create mode 100644 EvenBetterFastSim.Tests/ScenarioRunTests.cs create mode 100644 EvenBetterFastSim/Services/ScenarioRun.cs diff --git a/EvenBetterFastSim.Tests/ObservableLoggerTests.cs b/EvenBetterFastSim.Tests/ObservableLoggerTests.cs new file mode 100644 index 0000000..80fa434 --- /dev/null +++ b/EvenBetterFastSim.Tests/ObservableLoggerTests.cs @@ -0,0 +1,81 @@ +using System; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using EvenBetterFastSim.Logging; +using Microsoft.Extensions.Logging; +using Xunit; + +namespace EvenBetterFastSim.Tests; + +/// +/// The System Log logger queues its entries for the UI thread instead of waiting for it +/// (GitLab secsgem/evencoolerfastsim#26). With Dispatcher.Invoke every log call from the scenario engine or the receive +/// loop took as long as the UI was busy, and a caller the UI thread itself was waiting for blocked for seconds. +/// +public class ObservableLoggerTests +{ + [Fact] + public async Task Log_does_not_wait_for_a_busy_UI_thread() + { + using var ui = new UiThread(); + var log = new LogService(); + var logger = new ObservableLogger(log, "test", () => ui.Dispatcher); + using var busy = new ManualResetEventSlim(); + using var release = new ManualResetEventSlim(); + _ = ui.Dispatcher.InvokeAsync(() => + { + busy.Set(); + release.Wait(TimeSpan.FromSeconds(30)); + }); + var cancellation = TestContext.Current.CancellationToken; + Assert.True(busy.Wait(TimeSpan.FromSeconds(10), cancellation), "the UI thread did not start"); + try + { + var logging = Task.Run(() => logger.LogWarning("while the UI thread is busy"), cancellation); + var finished = await Task.WhenAny(logging, Task.Delay(TimeSpan.FromSeconds(5), cancellation)); + + Assert.True(finished == logging, "the log call waited for the UI thread"); + await logging; + // The UI thread is still busy, so nothing has reached the collection yet. + Assert.Empty(log.LogMessages); + } + finally + { + release.Set(); + } + + var entry = Assert.Single(ui.AfterQueuedWork(() => log.LogMessages.ToList())); + Assert.Equal("while the UI thread is busy", entry.Message); + Assert.Equal(LogLevel.Warning, entry.Level); + } + + [Fact] + public void Entries_arrive_on_the_UI_thread_in_the_order_of_the_calls() + { + using var ui = new UiThread(); + var log = new LogService(); + var addedOn = new System.Collections.Generic.HashSet(); + log.LogMessages.CollectionChanged += (_, _) => addedOn.Add(Environment.CurrentManagedThreadId); + var logger = new ObservableLogger(log, "test", () => ui.Dispatcher); + + for (var i = 0; i < 300; i++) + logger.LogInformation("entry {Number}", i); + + var messages = ui.AfterQueuedWork(() => log.LogMessages.Select(m => m.Message).ToList()); + Assert.Equal(Enumerable.Range(0, 300).Select(i => $"entry {i}"), messages); + Assert.Equal([ui.ThreadId], addedOn); + } + + /// No Application (unit tests, shutdown): the entry is dropped; until #26 the log call threw. + [Fact] + public void Without_a_dispatcher_the_entry_is_dropped() + { + var log = new LogService(); + + new ObservableLogger(log, "test", () => null).LogError("nobody shows this"); + new ObservableLogger(log, "test").LogError("no Application in the test process"); + + Assert.Empty(log.LogMessages); + } +} diff --git a/EvenBetterFastSim.Tests/ScenarioRunTests.cs b/EvenBetterFastSim.Tests/ScenarioRunTests.cs new file mode 100644 index 0000000..08ea18d --- /dev/null +++ b/EvenBetterFastSim.Tests/ScenarioRunTests.cs @@ -0,0 +1,378 @@ +using System; +using System.Collections; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using System.Windows.Threading; +using EvenBetterFastSim.Services; +using Logging.Interfaces; +using SecsGemBaseItems.Data_Containers; +using SecsGemBaseItems.Data_Containers.Serialization; +using SecsGemScenarioEngine.Models; +using SecsGemScenarioEngine.Services; +using Xunit; + +namespace EvenBetterFastSim.Tests; + +/// +/// Scenarios run on the thread pool instead of the WPF UI thread, with a copy of the graph that nothing on the UI +/// thread can change under the engine (GitLab secsgem/evencoolerfastsim#26). +/// +public class ScenarioRunTests +{ + /// + /// The caller is a thread with a running Dispatcher, like the UI thread. The graph is copied on that thread, where + /// the library may be read. The engine then runs on the thread pool and must not see the caller's context: not when + /// it starts and not after its first await, or its continuations would go back to that thread. + /// + /// + /// A plain SynchronizationContext would not do as the caller's context: await treats the base type like no context, + /// so an implementation that awaits before it calls the engine would end up on the thread pool in the test and on + /// the UI thread in the app. + /// + [Fact] + public async Task Graph_is_copied_on_the_callers_thread_and_the_engine_runs_on_the_thread_pool() + { + using var ui = new UiThread(); + var engine = new RecordingEngine(); + var transaction = Transaction(6, 11); + var library = new RecordingLibrary(transaction); + var graph = new ScenarioGraph + { + Nodes = [new ScenarioNode { Type = NodeType.Send, TransactionName = transaction.PrimaryMessage.Name }] + }; + using var cancellation = new CancellationTokenSource(); + var consumed = new ConcurrentDictionary(); + var deadline = TimeSpan.FromSeconds(7); + var progress = new Progress(); + SynchronizationContext? callerContext = null; + + var run = ui.Dispatcher.Invoke(() => + { + callerContext = SynchronizationContext.Current; + return ScenarioRun.RunAsync(engine, graph, library, cancellation.Token, consumed, deadline, progress); + }); + var result = await run.WaitAsync(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken); + + Assert.IsType(callerContext); + Assert.Same(engine.Result, result); + Assert.Equal(ui.ThreadId, library.EnumeratedOnThread); + Assert.True(engine.OnThreadPool); + Assert.NotEqual(ui.ThreadId, engine.ThreadId); + Assert.Null(engine.ContextAtStart); + Assert.Null(engine.ContextAfterAwait); + // The engine got the copy, with the transaction the node only named. + Assert.NotSame(graph, engine.Graph); + Assert.NotNull(engine.Graph!.Nodes.Single().TransactionJson); + Assert.Null(graph.Nodes.Single().TransactionJson); + Assert.Equal(cancellation.Token, engine.Token); + Assert.Same(consumed, engine.Consumed); + Assert.Equal(deadline, engine.Deadline); + Assert.Same(progress, engine.Progress); + } + + /// + /// The engine keeps a run's cancellation source in a field while the run starts. Runs that start at the same time + /// enter the engine one after the other. + /// + [Fact] + public async Task Runs_enter_the_engine_one_at_a_time() + { + var engine = new SlowStartEngine(); + var graph = new ScenarioGraph(); + + var runs = Enumerable.Range(0, 4) + .Select(_ => ScenarioRun.RunAsync(engine, graph, [], CancellationToken.None, null, null, null)) + .ToArray(); + await Task.WhenAll(runs).WaitAsync(TimeSpan.FromSeconds(30), TestContext.Current.CancellationToken); + + Assert.Equal(4, engine.Starts); + Assert.Equal(1, engine.MostAtOnce); + } + + /// + /// Opening a scenario while it runs clears TransactionJson of the stored graph's nodes (LoadGraphToCanvas). The + /// engine reads a node only when it reaches it, so it must have nodes of its own. + /// + [Fact] + public void Snapshot_does_not_change_when_the_stored_graph_changes() + { + var json = SecsGemTransactionJsonConverter.Serialize(Transaction(1, 13)); + var start = new ScenarioNode { Type = NodeType.Start }; + var send = new ScenarioNode { Type = NodeType.Send, TransactionName = "S1F13", TransactionJson = json }; + var edge = new ScenarioEdge { SourceNodeId = start.Id, TargetNodeId = send.Id, IsFailurePath = true }; + var graph = new ScenarioGraph { Name = "n", Description = "d", Nodes = [start, send], Edges = [edge] }; + + var run = ScenarioRun.Snapshot(graph, []); + + Assert.NotSame(graph, run); + Assert.Equal(("n", "d"), (run.Name, run.Description)); + Assert.Equal([start.Id, send.Id], run.Nodes.Select(n => n.Id)); + Assert.All(run.Nodes, node => Assert.DoesNotContain(node, graph.Nodes)); + var runEdge = Assert.Single(run.Edges); + Assert.NotSame(edge, runEdge); + Assert.Equal((start.Id, send.Id, true), (runEdge.SourceNodeId, runEdge.TargetNodeId, runEdge.IsFailurePath)); + + send.TransactionJson = null; + send.TransactionName = "changed"; + edge.TargetNodeId = "changed"; + graph.Nodes.Clear(); + graph.Edges.Clear(); + + Assert.Equal(json, run.Nodes[1].TransactionJson); + Assert.Equal("S1F13", run.Nodes[1].TransactionName); + Assert.Equal(send.Id, run.Edges.Single().TargetNodeId); + Assert.Equal(2, run.Nodes.Count); + } + + [Theory] + [InlineData(NodeType.Send)] + [InlineData(NodeType.SendAndWait)] + [InlineData(NodeType.Receive)] + public void Node_that_only_names_its_transaction_gets_its_own_copy(NodeType type) + { + var transaction = Transaction(6, 11); + // Found like in the engine's own lookup: by the primary message's name, whatever its case. + var name = transaction.PrimaryMessage.Name.ToLowerInvariant(); + Assert.NotEqual(transaction.PrimaryMessage.Name, name); + var named = new ScenarioNode { Type = type, TransactionName = name }; + + var run = ScenarioRun.Snapshot(new ScenarioGraph { Nodes = [named] }, [Transaction(1, 1), transaction]); + + // The graph that gets saved keeps the name-only node. + Assert.Null(named.TransactionJson); + var copy = SecsGemTransactionJsonConverter.Deserialize(run.Nodes.Single().TransactionJson!); + Assert.NotNull(copy); + Assert.NotSame(transaction, copy); + Assert.Equal((6, 11), (copy.PrimaryMessage.Stream, copy.PrimaryMessage.Function)); + Assert.Equal((6, 12), (copy.ReplyMessage.Stream, copy.ReplyMessage.Function)); + } + + /// + /// The converter writes values with the current culture and reads F4/F8 invariant: with a decimal comma the copy of + /// 1,5 would hold 15 (GitLab secsgem/secsgembase#68). + /// + [Fact] + public void Copy_holds_the_same_float_values_with_a_decimal_comma_culture() + { + var transaction = new SecsGemTransaction + { + PrimaryMessage = new MessageFactory(2, 41, true, "primary", new ItemFactory() + .AddList(list => list.AddFloat(1.5f).AddDouble(-2.25).AddI4(-7).AddU4(1000))).Build(), + ReplyMessage = new MessageFactory(2, 42, false, "reply").Build() + }; + var named = new ScenarioNode { Type = NodeType.Send, TransactionName = transaction.PrimaryMessage.Name }; + var culture = CultureInfo.CurrentCulture; + CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("de-DE"); + ScenarioGraph run; + try + { + Assert.Equal("1,5", 1.5f.ToString()); + run = ScenarioRun.Snapshot(new ScenarioGraph { Nodes = [named] }, [transaction]); + Assert.Equal(CultureInfo.GetCultureInfo("de-DE"), CultureInfo.CurrentCulture); + } + finally + { + CultureInfo.CurrentCulture = culture; + } + + var copy = SecsGemTransactionJsonConverter.Deserialize(run.Nodes.Single().TransactionJson!); + var values = ((SecsGemItem)copy!.PrimaryMessage.Children.Single()).Children.Cast() + .Select(item => item.GetBoxedValues().Single()).ToList(); + Assert.Equal([1.5f, -2.25, -7, 1000u], values); + } + + /// The copied node differs from the original at most in TransactionJson, whatever ScenarioNode holds. + [Fact] + public void Copy_keeps_every_other_property_of_the_node() + { + var transaction = Transaction(6, 11); + var node = new ScenarioNode(); + FillWithDistinctValues(node); + node.Type = NodeType.Send; + node.TransactionJson = null; + node.TransactionName = transaction.PrimaryMessage.Name; + + var copy = ScenarioRun.Snapshot(new ScenarioGraph { Nodes = [node] }, [transaction]).Nodes.Single(); + + Assert.NotSame(node, copy); + Assert.NotNull(copy.TransactionJson); + foreach (var property in typeof(ScenarioNode).GetProperties().Where(p => p.Name != nameof(ScenarioNode.TransactionJson))) + Assert.Equal(property.GetValue(node), property.GetValue(copy)); + } + + /// + /// Snapshot copies exactly these. A property that a later engine package adds to ScenarioGraph would be dropped + /// without notice, so it has to show up here first. + /// + [Fact] + public void Snapshot_knows_every_property_of_a_graph() => + Assert.Equal(["Description", "Edges", "Name", "Nodes"], + typeof(ScenarioGraph).GetProperties().Select(property => property.Name).Order()); + + [Fact] + public void Copy_keeps_every_property_of_an_edge() + { + var edge = new ScenarioEdge(); + FillWithDistinctValues(edge); + + var copy = ScenarioRun.Snapshot(new ScenarioGraph { Edges = [edge] }, []).Edges.Single(); + + Assert.NotSame(edge, copy); + foreach (var property in typeof(ScenarioEdge).GetProperties()) + Assert.Equal(property.GetValue(edge), property.GetValue(copy)); + } + + /// + /// No library transaction is copied into nodes that carry their own, nodes whose TransactionName is a parameter + /// (Wait: ms), and nodes with a name the library does not know (the engine reports those). + /// + [Fact] + public void Other_nodes_keep_what_they_have() + { + var transaction = Transaction(6, 11); + var own = SecsGemTransactionJsonConverter.Serialize(Transaction(1, 13)); + var graph = new ScenarioGraph + { + Nodes = + [ + new ScenarioNode { Type = NodeType.Send, TransactionName = transaction.PrimaryMessage.Name, TransactionJson = own }, + new ScenarioNode { Type = NodeType.Wait, TransactionName = transaction.PrimaryMessage.Name }, + new ScenarioNode { Type = NodeType.Receive, TransactionName = "not in the library" }, + new ScenarioNode { Type = NodeType.Send, TransactionName = " " } + ] + }; + + var run = ScenarioRun.Snapshot(graph, [transaction]); + + Assert.Equal(own, run.Nodes[0].TransactionJson); + Assert.All(run.Nodes.Skip(1), node => Assert.Null(node.TransactionJson)); + Assert.Equal(graph.Nodes.Select(n => (n.Id, n.Type, n.TransactionName)), + run.Nodes.Select(n => (n.Id, n.Type, n.TransactionName))); + } + + /// + /// With branches running in parallel, an And node's "1/2 branches" report can arrive after its Succeeded report. + /// Only that case is dropped; every other report is shown. + /// + [Theory] + [InlineData(ScenarioNodeRunState.Succeeded, ScenarioNodeRunState.Waiting, true)] + [InlineData(ScenarioNodeRunState.Succeeded, ScenarioNodeRunState.Succeeded, false)] + [InlineData(ScenarioNodeRunState.Succeeded, ScenarioNodeRunState.Failed, false)] + [InlineData(ScenarioNodeRunState.Succeeded, ScenarioNodeRunState.Running, false)] + [InlineData(ScenarioNodeRunState.Waiting, ScenarioNodeRunState.Waiting, false)] + [InlineData(ScenarioNodeRunState.Running, ScenarioNodeRunState.Waiting, false)] + [InlineData(ScenarioNodeRunState.Idle, ScenarioNodeRunState.Waiting, false)] + [InlineData(ScenarioNodeRunState.Waiting, ScenarioNodeRunState.Succeeded, false)] + public void Only_a_waiting_report_after_success_is_stale(ScenarioNodeRunState shown, ScenarioNodeRunState reported, + bool stale) => + Assert.Equal(stale, ScenarioRun.IsStale(shown, new ScenarioNodeProgress("node", reported, "1/2 branches"))); + + /// + /// Sets every property to a value that differs from its default and from the other properties. A property type this + /// does not know fails the test: then the copy in ScenarioRun.Snapshot needs a look as well. + /// + private static void FillWithDistinctValues(object target) + { + var index = 0; + foreach (var property in target.GetType().GetProperties()) + { + index++; + Assert.True(property.CanWrite, $"{target.GetType().Name}.{property.Name} cannot be set: check how Snapshot copies it"); + object value = property.PropertyType switch + { + var t when t == typeof(string) => $"value {index} of {property.Name}", + var t when t == typeof(bool) => !(bool)property.GetValue(target)!, + var t when t == typeof(double) => 12.5 + index, + var t when t == typeof(NodeType) => NodeType.Receive, + var t => throw new InvalidOperationException( + $"{target.GetType().Name}.{property.Name} has the type {t}: extend this test and check Snapshot") + }; + property.SetValue(target, value); + } + } + + private static SecsGemTransaction Transaction(byte stream, byte function) => new() + { + PrimaryMessage = new MessageFactory(stream, function, true, "primary").Build(), + ReplyMessage = new MessageFactory(stream, (byte)(function + 1), false, "reply").Build() + }; + + /// A library that notes the thread it is read on. + private sealed class RecordingLibrary(params SecsGemTransaction[] transactions) : IEnumerable + { + public int EnumeratedOnThread { get; private set; } + + public IEnumerator GetEnumerator() + { + EnumeratedOnThread = Environment.CurrentManagedThreadId; + return ((IEnumerable)transactions).GetEnumerator(); + } + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } + + private sealed class RecordingEngine : IScenarioExecutionService + { + public ScenarioExecutionResult Result { get; } = new() { Success = true, CompletedSteps = 3 }; + public bool OnThreadPool { get; private set; } + public int ThreadId { get; private set; } + public SynchronizationContext? ContextAtStart { get; private set; } = new(); + public SynchronizationContext? ContextAfterAwait { get; private set; } = new(); + public ScenarioGraph? Graph { get; private set; } + public CancellationToken Token { get; private set; } + public ConcurrentDictionary? Consumed { get; private set; } + public TimeSpan? Deadline { get; private set; } + public IProgress? Progress { get; private set; } + + public async Task ExecuteAsync(ScenarioGraph scenario, + CancellationToken cancellation = default, + ConcurrentDictionary? consumedAcrossRuns = null, TimeSpan? deadline = null, + IProgress? progress = null) + { + OnThreadPool = Thread.CurrentThread.IsThreadPoolThread; + ThreadId = Environment.CurrentManagedThreadId; + ContextAtStart = SynchronizationContext.Current; + (Graph, Token, Consumed, Deadline, Progress) = (scenario, cancellation, consumedAcrossRuns, deadline, progress); + // Like the engine: no ConfigureAwait(false). + await Task.Delay(20, CancellationToken.None); + ContextAfterAwait = SynchronizationContext.Current; + return Result; + } + + public void Cancel() { } + } + + /// Its synchronous start takes a while and counts how many callers are in it at once. + private sealed class SlowStartEngine : IScenarioExecutionService + { + private int inside; + private int mostAtOnce; + private int starts; + + public int MostAtOnce => Volatile.Read(ref mostAtOnce); + public int Starts => Volatile.Read(ref starts); + + public Task ExecuteAsync(ScenarioGraph scenario, + CancellationToken cancellation = default, + ConcurrentDictionary? consumedAcrossRuns = null, TimeSpan? deadline = null, + IProgress? progress = null) + { + var now = Interlocked.Increment(ref inside); + Interlocked.Increment(ref starts); + int seen; + while ((seen = Volatile.Read(ref mostAtOnce)) < now && Interlocked.CompareExchange(ref mostAtOnce, now, seen) != seen) + { + } + + Thread.Sleep(150); + Interlocked.Decrement(ref inside); + return Task.FromResult(new ScenarioExecutionResult { Success = true }); + } + + public void Cancel() { } + } +} diff --git a/EvenBetterFastSim.Tests/TestSupport.cs b/EvenBetterFastSim.Tests/TestSupport.cs index 6093e32..0d68cda 100644 --- a/EvenBetterFastSim.Tests/TestSupport.cs +++ b/EvenBetterFastSim.Tests/TestSupport.cs @@ -4,6 +4,8 @@ using System.ComponentModel; using System.IO; using System.Runtime.CompilerServices; +using System.Threading; +using System.Windows.Threading; using EvenBetterFastSim.Services; using EvenBetterFastSim.WPF.ViewModels; using Microsoft.Extensions.Logging; @@ -99,3 +101,41 @@ private static string ResolveLibraryDir() @"Could not locate 'EvenBetterFastSim\Library' above " + AppContext.BaseDirectory); } } + +/// A thread with a running , like the WPF UI thread. +internal sealed class UiThread : IDisposable +{ + private readonly Thread thread; + + public UiThread() + { + using var started = new ManualResetEventSlim(); + Dispatcher? dispatcher = null; + thread = new Thread(() => + { + dispatcher = Dispatcher.CurrentDispatcher; + started.Set(); + Dispatcher.Run(); + }) { IsBackground = true, Name = "test UI thread" }; + thread.SetApartmentState(ApartmentState.STA); + thread.Start(); + if (!started.Wait(TimeSpan.FromSeconds(10))) throw new TimeoutException("The dispatcher thread did not start"); + Dispatcher = dispatcher!; + ThreadId = thread.ManagedThreadId; + } + + public Dispatcher Dispatcher { get; } + public int ThreadId { get; } + + /// + /// Runs on the UI thread once everything queued so far is done. A plain Invoke has the priority Send and + /// overtakes queued work such as log entries. + /// + public T AfterQueuedWork(Func read) => Dispatcher.Invoke(read, DispatcherPriority.ContextIdle); + + public void Dispose() + { + Dispatcher.InvokeShutdown(); + thread.Join(TimeSpan.FromSeconds(10)); + } +} diff --git a/EvenBetterFastSim/Logging/ObservableLogger.cs b/EvenBetterFastSim/Logging/ObservableLogger.cs index 114e0e5..7976e09 100644 --- a/EvenBetterFastSim/Logging/ObservableLogger.cs +++ b/EvenBetterFastSim/Logging/ObservableLogger.cs @@ -2,19 +2,23 @@ using Microsoft.Extensions.Logging; using System; using System.Windows; +using System.Windows.Threading; namespace EvenBetterFastSim.Logging; /// /// Logs messages to the UI /// -public class ObservableLogger(ILogService logService, string _) : ILogger +/// The UI thread's dispatcher at the time of a log call; by default the application's. +/// Without one (no : unit tests, shutdown) the entry is dropped. +public class ObservableLogger(ILogService logService, string _, Func? dispatcher = null) : ILogger { /// /// Gets the associated ObservableCollection of logged strings /// private readonly ILogService logService = logService; private readonly string _ = _; + private readonly Func dispatcher = dispatcher ?? (static () => Application.Current?.Dispatcher); public void Log(LogLevel logLevel, EventId eventId, @@ -43,10 +47,10 @@ public void Log(LogLevel logLevel, private void AddItemToCollection(LoggedString messageToLog) { - // Invoke the UI thread to add the message to the collection - Application.Current.Dispatcher.Invoke(() => - { - logService.LogMessages.Add(messageToLog); - }); + // Queued for the UI thread, like SecsMessageLogger; entries keep the order of their calls. With Invoke every + // caller waited for the UI thread: the scenario engine and the receive loop took as long as the UI was busy, + // and a caller that the UI thread itself was waiting for (a connection being closed) blocked for seconds + // (GitLab secsgem/evencoolerfastsim#26). + dispatcher()?.InvokeAsync(() => logService.LogMessages.Add(messageToLog)); } } \ No newline at end of file diff --git a/EvenBetterFastSim/Services/ScenarioRun.cs b/EvenBetterFastSim/Services/ScenarioRun.cs new file mode 100644 index 0000000..a1ce5bc --- /dev/null +++ b/EvenBetterFastSim/Services/ScenarioRun.cs @@ -0,0 +1,152 @@ +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Logging.Interfaces; +using SecsGemBaseItems.Data_Containers; +using SecsGemBaseItems.Data_Containers.Serialization; +using SecsGemScenarioEngine.Models; +using SecsGemScenarioEngine.Services; + +namespace EvenBetterFastSim.Services; + +/// +/// Hands a scenario to the engine so that it runs on the thread pool instead of the WPF UI thread +/// (GitLab secsgem/evencoolerfastsim#26). +/// +/// +/// The engine awaits without ConfigureAwait(false). Started on the UI thread, every node therefore ran there: the +/// time between two nodes depended on what the UI was busy with, and a node that blocks froze the window. +/// +public static class ScenarioRun +{ + /// + /// One run enters the engine at a time. While it starts, the engine keeps the run's cancellation source in a field + /// and reads it back; two runs that start at the same instant on two threads could end up with each other's source + /// and ignore their own Stop and deadline (GitLab secsgem/secsgembase#69). On the UI thread that could not happen. + /// Only the synchronous start is covered, not the run. + /// + private static readonly Lock EngineStart = new(); + + /// + /// Takes a of the graph on the calling thread (the UI thread), then runs the engine with it on + /// the thread pool, where the engine has no SynchronizationContext to return to. An awaiting caller continues on its + /// own context as usual, and a created on the UI thread still reports there. + /// + /// + /// The token is not passed to Task.Run on purpose: a run that is cancelled before it starts still goes through the + /// engine, which reports it as cancelled like any other cancelled run. + /// + public static Task RunAsync( + IScenarioExecutionService engine, + ScenarioGraph graph, + IEnumerable library, + CancellationToken token, + ConcurrentDictionary? consumed, + TimeSpan? deadline, + IProgress? progress) + { + var run = Snapshot(graph, library); + return Task.Run(() => + { + lock (EngineStart) + return engine.ExecuteAsync(run, token, consumed, deadline, progress); + }); + } + + /// + /// The graph for one run: a copy that nothing else refers to, in which a Send or Receive node that only names its + /// transaction has its own copy of that library transaction. Call it on the UI thread. + /// + /// + /// + /// The stored graph keeps changing on the UI thread while a run is in flight: opening a scenario clears + /// of its nodes. The engine reads a node when it reaches it, so it gets + /// nodes of its own. + /// Nodes made on the canvas carry their transaction as TransactionJson. A node from an older file has only + /// ; the engine then looks the transaction up in the library and writes + /// response bindings into it. The library is bound to the UI, where such a write from another thread throws. With + /// the copy the engine does not touch the library for that node, and the run no longer changes the library + /// transaction. + /// A name the library does not know stays unresolved: the engine reports it when it reaches the node. For + /// that it still searches the library, from its own thread. + /// + /// + public static ScenarioGraph Snapshot(ScenarioGraph graph, IEnumerable library) + { + List? transactions = null; + var run = new ScenarioGraph + { + Name = graph.Name, + Description = graph.Description, + Edges = graph.Edges.Select(edge => new ScenarioEdge + { + SourceNodeId = edge.SourceNodeId, + TargetNodeId = edge.TargetNodeId, + IsFailurePath = edge.IsFailurePath + }).ToList() + }; + + foreach (var node in graph.Nodes) + { + var copy = new ScenarioNode + { + Id = node.Id, + Type = node.Type, + TransactionName = node.TransactionName, + DisplayName = node.DisplayName, + TransactionJson = node.TransactionJson, + UseReplyMessage = node.UseReplyMessage, + MatchConditionsJson = node.MatchConditionsJson, + ResponseBindingsJson = node.ResponseBindingsJson, + X = node.X, + Y = node.Y + }; + run.Nodes.Add(copy); + + if (node.Type is not (NodeType.Send or NodeType.SendAndWait or NodeType.Receive) || + !string.IsNullOrWhiteSpace(node.TransactionJson) || + string.IsNullOrWhiteSpace(node.TransactionName)) + continue; + + transactions ??= library.ToList(); + // Same match as the engine's own lookup. + var transaction = transactions.FirstOrDefault(t => + string.Equals(t.PrimaryMessage?.Name, node.TransactionName, StringComparison.OrdinalIgnoreCase)); + if (transaction is not null) + copy.TransactionJson = Serialize(transaction); + } + + return run; + } + + /// + /// A node keeps "Succeeded" for the rest of the run. The engine's branches really run in parallel now, so the report + /// of a branch that reached an And node early ("1/2 branches", Waiting) can come in after the report that the And + /// has fired (GitLab secsgem/secsgembase#69); the node would end the run with the hourglass. + /// + public static bool IsStale(ScenarioNodeRunState shown, ScenarioNodeProgress report) => + shown is ScenarioNodeRunState.Succeeded && report.State is ScenarioNodeRunState.Waiting; + + /// + /// The converter writes item values with the current culture but reads F4/F8 values with the invariant culture: with + /// a decimal comma, 1,5 came back as 15 (GitLab secsgem/secsgembase#68). Written invariant, the copy holds what the + /// library transaction holds. + /// + private static string Serialize(SecsGemTransaction transaction) + { + var culture = CultureInfo.CurrentCulture; + CultureInfo.CurrentCulture = CultureInfo.InvariantCulture; + try + { + return SecsGemTransactionJsonConverter.Serialize(transaction); + } + finally + { + CultureInfo.CurrentCulture = culture; + } + } +} diff --git a/EvenBetterFastSim/WPF/ViewModels/ScenariosViewModel.cs b/EvenBetterFastSim/WPF/ViewModels/ScenariosViewModel.cs index b0fae40..77791e1 100644 --- a/EvenBetterFastSim/WPF/ViewModels/ScenariosViewModel.cs +++ b/EvenBetterFastSim/WPF/ViewModels/ScenariosViewModel.cs @@ -11,8 +11,6 @@ using System.Windows.Input; using CommunityToolkit.Mvvm.ComponentModel; using CommunityToolkit.Mvvm.Input; -using EvenBetterFastSim.Logging; -using EvenBetterFastSim.Logging.Interfaces; using EvenBetterFastSim.WPF.ViewModels.Graph; using Microsoft.Extensions.Logging; using Microsoft.Win32; @@ -50,7 +48,6 @@ public partial class ScenariosViewModel : ObservableObject private readonly ScenarioExecutionService scenarioExecutionService; private readonly ISecsGemLibraryManager libraryManager; private readonly DataMessageHandler dataMessageHandler; - private readonly ILogService logService; private readonly ILogger logger; [ObservableProperty] @@ -90,7 +87,6 @@ public ScenariosViewModel( ScenarioExecutionService scenarioExecutionService, ISecsGemLibraryManager libraryManager, DataMessageHandler dataMessageHandler, - ILogService logService, ILogger logger, Services.IWindowManager windowManager, Services.ViewModelLocator viewModelLocator) @@ -98,7 +94,6 @@ public ScenariosViewModel( this.scenarioExecutionService = scenarioExecutionService; this.libraryManager = libraryManager; this.dataMessageHandler = dataMessageHandler; - this.logService = logService; this.logger = logger; this.windowManager = windowManager; this.viewModelLocator = viewModelLocator; @@ -128,11 +123,12 @@ public ScenariosViewModel( LoadFromJson(); } - private void LogInfo(string message) => - logService.LogMessages.Add(new LoggedString { Level = LogLevel.Information, Message = message }); + // Through the logger, like every other System Log entry: the logger queues its entries for the UI thread, and a line + // added to the collection directly would overtake engine entries that are still queued (after a cancel the line + // "cancelled by the user" came before the engine's "was cancelled"; GitLab secsgem/evencoolerfastsim#26). + private void LogInfo(string message) => logger.LogInformation("{Message}", message); - private void LogError(string message) => - logService.LogMessages.Add(new LoggedString { Level = LogLevel.Error, Message = message }); + private void LogError(string message) => logger.LogError("{Message}", message); /// /// When a run is cancelled while a Receive/Wait step is still pending, the execution service @@ -324,12 +320,17 @@ private async Task RunOnceAsync( : new Progress(p => { if (canvasNodes.FirstOrDefault(n => n.Id == p.NodeId) is not { } vm) return; + if (Services.ScenarioRun.IsStale(vm.RunState, p)) return; vm.RunState = p.State; vm.RunDetail = p.Detail; }); TimeSpan? deadline = RunTimeoutSeconds > 0 ? TimeSpan.FromSeconds(RunTimeoutSeconds) : null; - var result = await scenarioExecutionService.ExecuteAsync(graph, token, consumed, deadline, progress); + // The engine runs on the thread pool, so node timing does not depend on the UI and a blocking node cannot + // freeze it (GitLab secsgem/evencoolerfastsim#26). It gets its own copy of the graph, taken here on the UI + // thread; this method continues on the UI thread after the await. + var result = await Services.ScenarioRun.RunAsync( + scenarioExecutionService, graph, libraryManager.Library, token, consumed, deadline, progress); if (result.Success) LogInfo($"Scenario '{scenario.Name}' completed ({result.CompletedSteps} steps)"); diff --git a/specification/features.md b/specification/features.md index 0d249a5..25759ed 100644 --- a/specification/features.md +++ b/specification/features.md @@ -2,6 +2,29 @@ Related docs: [project_overview.md](project_overview.md), [secsgembase_library.md](secsgembase_library.md), [dialog_pattern.md](dialog_pattern.md), [SESSION_REFACTORING_LOG.md](../SESSION_REFACTORING_LOG.md) +## Scenario runs leave the UI thread + +A scenario (Run or a loop) now executes on the thread pool. Until then every node ran on the WPF UI thread, because +the engine awaits without `ConfigureAwait(false)`: the time between two nodes depended on what the UI was busy with, +and a node that blocks froze the window (internal board, issue 26). + +**Files:** `Services/ScenarioRun.cs` (`RunAsync`, `Snapshot`, `IsStale`), `WPF/ViewModels/ScenariosViewModel.cs` +(`RunOnceAsync`, `LogInfo`/`LogError`), `Logging/ObservableLogger.cs`. + +- `ScenarioRun.RunAsync` takes a `Snapshot` of the graph on the UI thread and starts the engine with `Task.Run`. + `RunOnceAsync` continues on the UI thread after the await; the `Progress` for the canvas is created there. +- The snapshot is a copy nothing else refers to. The stored graph changes on the UI thread during a run (opening a + scenario clears `TransactionJson` of its nodes), and a node from an older file that only names its transaction gets + a copy of the library transaction, so the engine does not read or write the UI-bound library for it. That copy is + written with the invariant culture (the SecsGemBase converter otherwise turns 1,5 into 15 on a decimal-comma system). +- The System Log logger (`ObservableLogger`) queues its entries with `Dispatcher.InvokeAsync`, like + `SecsMessageLogger`, instead of waiting for the UI thread. `ScenariosViewModel` writes its own lines through the + logger too, so they keep their place between the engine's lines. Without a dispatcher (unit tests, shutdown) an + entry is dropped; pass a dispatcher provider as third constructor argument to observe entries in a test. +- Two things the engine did not need on a single thread: runs enter the engine one at a time (it keeps the run's + cancellation source in a field while it starts), and an And node's late "1/2 branches" report no longer replaces + its Succeeded state. + ## Responder panel — edit the message shape The node responder dialog (`NodeResponderView`, opened by double-click on a Send / Receive node) now has a