Add new cycle and event based simulator for better performance and associated unit tests

2026-09-06 07:55:57 +02:00 · 2026-03-26 01:16:24 +01:00
parent b1b71a2392
commit aa6d13a46c
17 changed files with 1386 additions and 793 deletions
@@ -0,0 +1,137 @@
+using System.Linq.Expressions;
+
+namespace StoneRed.LogicSimulator.Simulation;
+
+public sealed class CycleCircuitSimulator : SimulatorBase
+{
+    private int[] nextInputMasks = [];
+    private Action<int[], int[], int[]> computeOutputs = (_, _, _) => { };
+
+    protected override void EnsureStorage()
+    {
+        base.EnsureStorage();
+        if (nextInputMasks.Length != gateKinds.Count)
+        {
+            nextInputMasks = new int[gateKinds.Count];
+        }
+    }
+
+    public override void Reset()
+    {
+        base.Reset();
+        Array.Clear(nextInputMasks);
+    }
+
+    protected override void OnSourceChanged(int gateId) { }
+
+    public override void Step()
+    {
+        EnsureCompiled();
+        if (!initialized)
+        {
+            Reset();
+        }
+
+        computeOutputs(inputMasks, outputMasks, sourceStates);
+        PropagateAndSwap();
+        NotifyAllWatchers();
+    }
+
+    private void PropagateAndSwap()
+    {
+        Array.Clear(nextInputMasks);
+        for (int fromGate = 0; fromGate < gateKinds.Count; fromGate++)
+        {
+            if ((outputMasks[fromGate] & 1) == 0)
+            {
+                continue;
+            }
+
+            int start = edgeStart[fromGate];
+            int end = edgeStart[fromGate + 1];
+            for (int e = start; e < end; e++)
+            {
+                nextInputMasks[edgeToGate[e]] |= 1 << edgeToInputBit[e];
+            }
+        }
+        (inputMasks, nextInputMasks) = (nextInputMasks, inputMasks);
+    }
+
+    private bool PropagateAndSwapDetectChange()
+    {
+        Array.Clear(nextInputMasks);
+        for (int fromGate = 0; fromGate < gateKinds.Count; fromGate++)
+        {
+            if ((outputMasks[fromGate] & 1) == 0)
+            {
+                continue;
+            }
+
+            int start = edgeStart[fromGate];
+            int end = edgeStart[fromGate + 1];
+            for (int e = start; e < end; e++)
+            {
+                nextInputMasks[edgeToGate[e]] |= 1 << edgeToInputBit[e];
+            }
+        }
+
+        bool changed = false;
+        for (int i = 0; i < inputMasks.Length; i++)
+        {
+            if (inputMasks[i] != nextInputMasks[i]) { changed = true; break; }
+        }
+
+        (inputMasks, nextInputMasks) = (nextInputMasks, inputMasks);
+        return changed;
+    }
+
+    public override bool TryRunUntilStable(int maxSteps, out int steps)
+    {
+        steps = 0;
+        if (maxSteps <= 0)
+        {
+            return false;
+        }
+
+        EnsureCompiled();
+        if (!initialized)
+        {
+            Reset();
+        }
+
+        bool changed = true;
+        while (changed && steps < maxSteps)
+        {
+            steps++;
+            computeOutputs(inputMasks, outputMasks, sourceStates);
+            changed = PropagateAndSwapDetectChange();
+            NotifyAllWatchers();
+        }
+        return !changed;
+    }
+
+    protected override void CompileEngine()
+    {
+        ParameterExpression inputsParam = Expression.Parameter(typeof(int[]), "inputs");
+        ParameterExpression outputsParam = Expression.Parameter(typeof(int[]), "outputs");
+        ParameterExpression sourcesParam = Expression.Parameter(typeof(int[]), "sources");
+        ConstantExpression lutDataConst = Expression.Constant(lutData);
+
+        List<Expression> body = [];
+        for (int i = 0; i < gateKinds.Count; i++)
+        {
+            ConstantExpression indexExpr = Expression.Constant(i);
+            BinaryExpression inMask = Expression.ArrayIndex(inputsParam, indexExpr);
+            Expression logicExpr = GenerateGateLogic(i, inMask, sourcesParam, indexExpr, lutDataConst);
+
+            body.Add(Expression.Assign(Expression.ArrayAccess(outputsParam, indexExpr), logicExpr));
+        }
+
+        computeOutputs = Expression.Lambda<Action<int[], int[], int[]>>(Expression.Block(body), inputsParam, outputsParam, sourcesParam).Compile();
+    }
+
+    protected override SimulatorBase CreateInternalSimulator()
+    {
+        return new CycleCircuitSimulator();
+    }
+}