implement deferred update + sparse

itsBuggingMe · itsBuggingMe · commit 1adfabcae683 · 2026-05-29T11:35:44.000-04:00
diff --git a/Frent/Updating/AttributeUpdateFilter.cs b/Frent/Updating/AttributeUpdateFilter.cs
@@ -148,6 +148,9 @@ private void MultiThreadedUpdate()
     {
         const int LargeArchetypeThreshold = 16;
 
+        _updateCount!.Value = 0;
+        _mulithreadedExceptions!.Clear();
+
         var archetypes = _matchedArchetypes.AsSpan();
 
         int largeCount = 0;
@@ -171,7 +174,7 @@ private void MultiThreadedUpdate()
         }
 
         FrentMultithread.MultipleArchetypeWorkItem.UnsafeQueueWork(
-            _world, _smallArchetypeUpdateRecords!, _methods, _updateCount!);
+            _world, _smallArchetypeUpdateRecords!, _methods, _updateCount, _mulithreadedExceptions);
 
         int maxChunkSize = Math.Max(largeCount / Environment.ProcessorCount, 256);
 
@@ -181,19 +184,22 @@ private void MultiThreadedUpdate()
             for (int i = 0; i < entityCount; i += maxChunkSize)
             {
                 FrentMultithread.SingleArchetypeWorkItem.UnsafeQueueWork(
-                    _world, archetypeRecord, _methods, _updateCount!,
+                    _world, archetypeRecord, _methods, _updateCount, _mulithreadedExceptions,
                     start: i,
                     count: Math.Min(maxChunkSize, entityCount - i));
             }
         }
 
         Span<SparseUpdateMethod> sparseMethods = _sparseMethods.AsSpan(0, _sparseMethodsCount);
 
-        for (int i = 0; i < sparseMethods.Length; i++)
+        for (int i = 0; i < sparseMethods.Length;)
         {
             ComponentSparseSetBase set = sparseMethods[i].SparseSet;
             if (set.Count == 0)
+            {
+                i++;
                 continue;
+            }
 
             int start = i;
             do
@@ -202,7 +208,18 @@ private void MultiThreadedUpdate()
             } while (i < sparseMethods.Length && set == sparseMethods[i].SparseSet);
 
             ArraySegment<SparseUpdateMethod> methods = new(_sparseMethods, start, i - start);
-            FrentMultithread.SparseSetWorkItem.UnsafeQueueWork(_world, methods, _updateCount!);
+            FrentMultithread.SparseSetWorkItem.UnsafeQueueWork(_world, methods, _updateCount, _mulithreadedExceptions);
+        }
+
+        SpinWait spinWait = new();
+        while (Volatile.Read(ref _updateCount.Value) != 0)
+        {
+            spinWait.SpinOnce();
+        }
+
+        if (_mulithreadedExceptions.Count != 0)
+        {
+            throw new AggregateException(_mulithreadedExceptions);
         }
     }
 
@@ -477,4 +494,4 @@ public void GetOneOrOther(
             metadataIndex = (int)_metadataIndexRoot;
         }
     }
-}
+}
diff --git a/Frent/Updating/SingleComponentUpdateFilter.cs b/Frent/Updating/SingleComponentUpdateFilter.cs
@@ -46,8 +46,16 @@ public SingleComponentUpdateFilter(World world, ComponentID component)
         _sparseSet = world.WorldSparseSetTable[component.SparseIndex];
 
         _allRunners = new IRunner[methods.Length];
-        _normalRunners = new IRunner[methods.Length - filters.Length];
-        _filteredRunners = filters.Length == 0 ? [] : new (IDTypeFilter Filter, IRunner Runner)[filters.Length];
+
+        int filteredRunnerCount = 0;
+        for (int i = 0; i < methods.Length; i++)
+        {
+            if ((uint)i < (uint)filters.Length && filters[i] is { } f && f != IDTypeFilter.None)
+                filteredRunnerCount++;
+        }
+
+        _normalRunners = new IRunner[methods.Length - filteredRunnerCount];
+        _filteredRunners = filteredRunnerCount == 0 ? [] : new (IDTypeFilter Filter, IRunner Runner)[filteredRunnerCount];
 
         int nIndex = 0;
         int fIndex = 0;
@@ -269,13 +277,19 @@ public void UpdateSubset(ReadOnlySpan<ArchetypeDeferredUpdateRecord> archetypes,
         {
             foreach ((Archetype archetype, Archetype _, int initalEntityCount) in archetypes)
             {
-                Array buffer = archetype.Components.UnsafeArrayIndex(archetype.GetComponentIndex(componentID)).Buffer;
-                int entityCount = archetype.EntityCount;
+                int componentIndex = archetype.GetComponentIndex(componentID);
+                if (componentIndex == 0)
+                    continue;
+
+                Array buffer = archetype.Components.UnsafeArrayIndex(componentIndex).Buffer;
+                int entitiesToUpdate = archetype.EntityCount - initalEntityCount;
+                if (entitiesToUpdate == 0)
+                    continue;
 
                 // average joe methods
                 foreach (var runner in _normalRunners)
                 {
-                    runner.RunArchetypical(buffer, archetype, world, 0, entityCount);
+                    runner.RunArchetypical(buffer, archetype, world, initalEntityCount, entitiesToUpdate);
                 }
 
                 foreach ((IDTypeFilter filter, IRunner runner) in _filteredRunners)
@@ -285,15 +299,17 @@ public void UpdateSubset(ReadOnlySpan<ArchetypeDeferredUpdateRecord> archetypes,
                     if (!filter.FilterArchetype(archetype))
                         continue;
 
-                    runner.RunArchetypical(buffer, archetype, world, 0, entityCount);
+                    runner.RunArchetypical(buffer, archetype, world, initalEntityCount, entitiesToUpdate);
                 }
             }
         }
         else
         {
-            throw new NotImplementedException();
+            int entityId = 0;
+            foreach (var runner in _allRunners)
+                runner.RunSparseSubset(_sparseSet, world, ids, ref entityId);
         }
     }
 
     record struct ArchetypeRecord(Archetype Archetype, int StorageIndex, int Length /*number of runners in the _filteredRunnersPerArchetype to update*/);
-}
+}
diff --git a/Frent/Updating/Threading/FrentMultithreadWorkItem.cs b/Frent/Updating/Threading/FrentMultithreadWorkItem.cs
@@ -24,8 +24,9 @@ private static readonly
         private World? _world;
         private ArraySegment<SparseUpdateMethod> _update;
         private StrongBox<int>? _counter;
+        private Stack<Exception>? _exceptions;
 
-        public static void UnsafeQueueWork(World world, ArraySegment<SparseUpdateMethod> method, StrongBox<int> counter)
+        public static void UnsafeQueueWork(World world, ArraySegment<SparseUpdateMethod> method, StrongBox<int> counter, Stack<Exception> exceptions)
         {
             if (method.Count == 0)
                 return;
@@ -42,25 +43,39 @@ public static void UnsafeQueueWork(World world, ArraySegment<SparseUpdateMethod>
             workItem._world = world;
             workItem._update = method;
             workItem._counter = counter;
+            workItem._exceptions = exceptions;
 
             ThreadPool.UnsafeQueueUserWorkItem(static o =>
             {
                 SparseSetWorkItem workItem = UnsafeExtensions.UnsafeCast<SparseSetWorkItem>(o!);
 
-                Span<SparseUpdateMethod> methods = workItem._update.AsSpan();
-                ComponentSparseSetBase set = methods[0].SparseSet;
+                try
+                {
+                    Span<SparseUpdateMethod> methods = workItem._update.AsSpan();
+                    ComponentSparseSetBase set = methods[0].SparseSet;
 
-                foreach (SparseUpdateMethod method in methods)
+                    foreach (SparseUpdateMethod method in methods)
+                    {
+                        int entityId = 0;
+                        method.Runner.RunSparse(set, workItem._world!, ref entityId);
+                    }
+                }
+                catch (Exception e)
                 {
-                    int entityId = 0;
-                    method.Runner.RunSparse(set, workItem._world!, ref entityId);
+                    lock (workItem._exceptions!)
+                    {
+                        workItem._exceptions.Push(e);
+                    }
+                }
+                finally
+                {
+                    Interlocked.Decrement(ref workItem._counter!.Value);
                 }
-
-                Interlocked.Decrement(ref workItem._counter!.Value);
 
                 workItem._world = default;
                 workItem._update = default;
                 workItem._counter = default;
+                workItem._exceptions = default;
 
                 lock (s_poolLock)
                 {
@@ -85,8 +100,9 @@ private static readonly
         private Stack<ArchetypeUpdateSpan>? _archetypes;
         private ArchetypeUpdateMethod[]? _componentStorageBases;
         private StrongBox<int>? _counter;
+        private Stack<Exception>? _exceptions;
 
-        public static void UnsafeQueueWork(World world, Stack<ArchetypeUpdateSpan> archetypes, ArchetypeUpdateMethod[] componentStorageBases, StrongBox<int> counter)
+        public static void UnsafeQueueWork(World world, Stack<ArchetypeUpdateSpan> archetypes, ArchetypeUpdateMethod[] componentStorageBases, StrongBox<int> counter, Stack<Exception> exceptions)
         {
             Interlocked.Increment(ref counter.Value);
 
@@ -101,34 +117,48 @@ public static void UnsafeQueueWork(World world, Stack<ArchetypeUpdateSpan> arche
             workItem._componentStorageBases = componentStorageBases;
             workItem._world = world;
             workItem._counter = counter;
+            workItem._exceptions = exceptions;
 
             ThreadPool.UnsafeQueueUserWorkItem(static o =>
             {
                 MultipleArchetypeWorkItem workItem = UnsafeExtensions.UnsafeCast<MultipleArchetypeWorkItem>(o!);
 
-                World world = workItem._world!;
-
-                while (workItem._archetypes!.TryPop(out var record))
+                try
                 {
-                    (Archetype archetype, int start, int count) = record;
-
-                    Span<ArchetypeUpdateMethod> methods = workItem._componentStorageBases.AsSpan(start, count);
-                    ref ComponentStorageRecord storageStart = ref MemoryMarshal.GetArrayDataReference(archetype.Components);
+                    World world = workItem._world!;
 
-                    foreach (var method in methods)
+                    while (workItem._archetypes!.TryPop(out var record))
                     {
-                        Debug.Assert(method.Index < archetype.Components.Length);
+                        (Archetype archetype, int start, int count) = record;
 
-                        method.Runner.RunArchetypical(Unsafe.Add(ref storageStart, method.Index).Buffer, archetype, world, 0, archetype.EntityCount);
+                        Span<ArchetypeUpdateMethod> methods = workItem._componentStorageBases.AsSpan(start, count);
+                        ref ComponentStorageRecord storageStart = ref MemoryMarshal.GetArrayDataReference(archetype.Components);
+
+                        foreach (var method in methods)
+                        {
+                            Debug.Assert(method.Index < archetype.Components.Length);
+
+                            method.Runner.RunArchetypical(Unsafe.Add(ref storageStart, method.Index).Buffer, archetype, world, 0, archetype.EntityCount);
+                        }
                     }
                 }
-
-                Interlocked.Decrement(ref workItem._counter!.Value);
+                catch (Exception e)
+                {
+                    lock (workItem._exceptions!)
+                    {
+                        workItem._exceptions.Push(e);
+                    }
+                }
+                finally
+                {
+                    Interlocked.Decrement(ref workItem._counter!.Value);
+                }
 
                 workItem._archetypes = default;
                 workItem._componentStorageBases = default;
                 workItem._world = default;
                 workItem._counter = default;
+                workItem._exceptions = default;
 
                 lock (s_poolLock)
                 {
@@ -153,6 +183,7 @@ private static readonly
         private ArchetypeUpdateSpan _archetypeRecord;
         private ArchetypeUpdateMethod[]? _components;
         private StrongBox<int>? _counter;
+        private Stack<Exception>? _exceptions;
         private int _start;
         private int _count;
 
@@ -161,6 +192,7 @@ public static void UnsafeQueueWork(
             ArchetypeUpdateSpan archetypeUpdateRecord,
             ArchetypeUpdateMethod[] componentStorageBases,
             StrongBox<int> counter,
+            Stack<Exception> exceptions,
             int start,
             int count)
         {
@@ -177,40 +209,54 @@ public static void UnsafeQueueWork(
             workItem._components = componentStorageBases;
             workItem._world = world;
             workItem._counter = counter;
+            workItem._exceptions = exceptions;
             workItem._start = start;
             workItem._count = count;
 
             ThreadPool.UnsafeQueueUserWorkItem(static o =>
             {
                 SingleArchetypeWorkItem frentMultithreadWorkItem = UnsafeExtensions.UnsafeCast<SingleArchetypeWorkItem>(o!);
 
-                World world = frentMultithreadWorkItem._world!;
-                (Archetype archetype, int start, int count) = frentMultithreadWorkItem._archetypeRecord;
-                Span<ArchetypeUpdateMethod> methods = frentMultithreadWorkItem._components.AsSpan(start, count);
+                try
+                {
+                    World world = frentMultithreadWorkItem._world!;
+                    (Archetype archetype, int start, int count) = frentMultithreadWorkItem._archetypeRecord;
+                    Span<ArchetypeUpdateMethod> methods = frentMultithreadWorkItem._components.AsSpan(start, count);
+
+                    int archetypeStart = frentMultithreadWorkItem._start;
+                    int archetypeCount = frentMultithreadWorkItem._count;
 
-                int archetypeStart = frentMultithreadWorkItem._start;
-                int archetypeCount = frentMultithreadWorkItem._count;
+                    ref ComponentStorageRecord storageStart = ref MemoryMarshal.GetArrayDataReference(archetype.Components);
 
-                ref ComponentStorageRecord storageStart = ref MemoryMarshal.GetArrayDataReference(archetype.Components);
+                    foreach (var method in methods)
+                    {
+                        Debug.Assert(method.Index < archetype.Components.Length);
 
-                foreach (var method in methods)
+                        method.Runner.RunArchetypical(
+                            Unsafe.Add(ref storageStart, method.Index).Buffer,
+                            archetype,
+                            world,
+                            archetypeStart,
+                            archetypeCount);
+                    }
+                }
+                catch (Exception e)
                 {
-                    Debug.Assert(method.Index < archetype.Components.Length);
-
-                    method.Runner.RunArchetypical(
-                        Unsafe.Add(ref storageStart, method.Index).Buffer,
-                        archetype,
-                        world,
-                        archetypeStart,
-                        archetypeCount);
+                    lock (frentMultithreadWorkItem._exceptions!)
+                    {
+                        frentMultithreadWorkItem._exceptions.Push(e);
+                    }
+                }
+                finally
+                {
+                    Interlocked.Decrement(ref frentMultithreadWorkItem._counter!.Value);
                 }
-
-                Interlocked.Decrement(ref frentMultithreadWorkItem._counter!.Value);
 
                 frentMultithreadWorkItem._archetypeRecord = default;
                 frentMultithreadWorkItem._components = default;
                 frentMultithreadWorkItem._world = default;
                 frentMultithreadWorkItem._counter = default;
+                frentMultithreadWorkItem._exceptions = default;
 
                 lock (s_poolLock)
                 {
@@ -221,4 +267,4 @@ public static void UnsafeQueueWork(
     }
 
 
-}
+}
