Merge branch 'master' into 2024-09-03-try-index

Author: genaray

src/Arch.Benchmarks/AddRemoveBenchmark.cs

@@ -0,0 +1,45 @@
+using Arch.Core;
+
+namespace Arch.Benchmarks;
+
+[HtmlExporter]
+[MemoryDiagnoser]
+public class AddRemoveBenchmark
+{
+    [Params(10000, 100000, 1000000)] public int Amount;
+
+    private static World _world;
+    private static List<Entity> _entities;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _world = World.Create();
+
+        _entities = new List<Entity>(Amount);
+        for (var index = 0; index < Amount; index++)
+        {
+            _entities.Add(_world.Create(new Transform(), new Velocity()));
+        }
+    }
+
+    [Benchmark]
+    public void Add()
+    {
+        for (var index = 0; index < _entities.Count; index++)
+        {
+            var entity = _entities[index];
+            _world.Add<Position2D>(entity);
+        }
+    }
+
+    [Benchmark]
+    public void Remove()
+    {
+        for (var index = 0; index < _entities.Count; index++)
+        {
+            var entity = _entities[index];
+            _world.Remove<Transform>(entity);
+        }
+    }
+}

src/Arch.Tests/WorldTest.cs

@@ -55,6 +55,25 @@ public void WorldRecycle()
         That(secondWorld.Id, Is.EqualTo(firstWorld.Id));
     }
 
+    /// <summary>
+    ///     Check the dispose pattern.
+    /// </summary>
+    [Test]
+    public void WorldDestroyTwice()
+    {
+        using var worldA = World.Create(); // World A has ID 0 and size 0
+        worldA.Create(); // worldA is now size 1
+        World.Destroy(worldA); // world A is size 0
+
+        using var worldB = World.Create(); // World B has ID 0 and size 0
+        var e0 = worldB.Create(0); // world B now has size 1
+        World.Destroy(worldA); // World B still appears to have size 1
+        var e1 = worldB.Create(0); // World B has size 2
+
+        e0.Get<int>(); // This causes a null reference exception
+        e1.Get<int>(); // This also causes a null reference exception
+    }
+
     /// <summary>
     ///     Checks if the <see cref="World"/> creates <see cref="Entity"/> correctly.
     /// </summary>

src/Arch/Buffer/CommandBuffer.cs

@@ -436,15 +436,16 @@ public void Dispose()
 public sealed partial class CommandBuffer
 {
     /// <summary>
-    ///     Adds an list of new components to the <see cref="Entity"/> and moves it to the new <see cref="Archetype"/>.
+    ///     Adds a list of new components to the <see cref="Entity"/> and moves it to the new <see cref="Archetype"/>.
     /// </summary>
     /// <param name="world">The world to operate on.</param>
     /// <param name="entity">The <see cref="Entity"/>.</param>
     /// <param name="components">A <see cref="IList{T}"/> of <see cref="ComponentType"/>'s, those are added to the <see cref="Entity"/>.</param>
     [SkipLocalsInit]
     internal static void AddRange(World world, Entity entity, Span<ComponentType> components)
     {
-        var oldArchetype = world.EntityInfo.GetArchetype(entity.Id);
+        ref var data = ref world.EntityInfo.EntityData[entity.Id];
+        var oldArchetype = data.Archetype;
 
         // BitSet to stack/span bitset, size big enough to contain ALL registered components.
         Span<uint> stack = stackalloc uint[BitSet.RequiredLength(ComponentRegistry.Size)];
@@ -465,6 +466,6 @@ internal static void AddRange(World world, Entity entity, Span<ComponentType> co
             newArchetype = world.GetOrCreate(newSignature);
         }
 
-        world.Move(entity, oldArchetype, newArchetype, out _);
+        world.Move(entity, ref data, oldArchetype, newArchetype, out _);
     }
 }

src/Arch/Core/Archetype.cs

@@ -302,7 +302,6 @@ internal Archetype(Signature signature, int baseChunkSize, int baseChunkEntityCo
     /// Try get the index of a component within this archetype. Returns false if the archetype does not have this
     /// component.
     /// </summary>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [Pure]
     internal bool TryIndex<T>(out int i)
     {
@@ -319,7 +318,10 @@ internal bool TryIndex<T>(out int i)
         return i != -1;
     }
 
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    /// <summary>
+    /// Try get the index of a component within this archetype. Returns false if the archetype does not have this
+    /// component.
+    /// </summary>
     [Pure]
     internal bool TryIndex(ComponentType type, out int i)
     {
@@ -867,6 +869,7 @@ internal static void Copy(Archetype source, Archetype destination)
     {
         // Make sure other archetype can fit additional entities from this archetype.
         destination.EnsureEntityCapacity(destination.EntityCount + source.EntityCount);
+        var sourceSignature = source.Signature;
 
         // Iterate each source chunk to copy them
         for (var sourceChunkIndex = 0; sourceChunkIndex <= source.Count; sourceChunkIndex++)
@@ -884,7 +887,7 @@ internal static void Copy(Archetype source, Archetype destination)
                 var remainingCapacity = destinationChunk.Buffer;
                 var amountToCopy = Math.Min(sourceChunk.Count, remainingCapacity);
 
-                Chunk.Copy(ref sourceChunk, amountCopied, ref destinationChunk, destinationChunk.Count, amountToCopy);
+                Chunk.Copy(ref sourceChunk, amountCopied, ref sourceSignature, ref destinationChunk, destinationChunk.Count, amountToCopy);
 
                 // Apply copied amount to track the progress
                 sourceChunk.Count -= amountToCopy;
@@ -912,9 +915,11 @@ internal static void Copy(Archetype source, Archetype destination)
 
     internal static void CopyComponents(Archetype from, ref Slot fromSlot, Archetype to, ref Slot toSlot)
     {
+        var sourceSignature = from.Signature;
+
         // Copy items from old to new chunk
         ref var oldChunk = ref from.GetChunk(fromSlot.ChunkIndex);
         ref var newChunk = ref to.GetChunk(toSlot.ChunkIndex);
-        Chunk.CopyComponents(ref oldChunk, fromSlot.Index, ref newChunk, toSlot.Index, 1);
+        Chunk.CopyComponents(ref oldChunk, fromSlot.Index, ref sourceSignature, ref newChunk, toSlot.Index, 1);
     }
 }

src/Arch/Core/Chunk.cs

@@ -250,6 +250,35 @@ public void Copy<T>(int index, in T cmp)
         Unsafe.Add(ref item, index) = cmp;
     }
 
+    [Pure]
+    internal bool TryIndex<T>(out int i)
+    {
+        var id = Component<T>.ComponentType.Id;
+        return TryIndex(id, out i);
+    }
+
+    [Pure]
+    internal bool TryIndex(int id, out int i)
+    {
+        Debug.Assert(id != -1, $"Supplied component index is invalid");
+
+        if (id >= ComponentIdToArrayIndex.Length)
+        {
+            i = -1;
+            return false;
+        }
+
+        i = ComponentIdToArrayIndex.DangerousGetReferenceAt(id);
+        return i != -1;
+    }
+
+    [Pure]
+    public bool Has(int id)
+    {
+        var idToArrayIndex = ComponentIdToArrayIndex;
+        return id < idToArrayIndex.Length && idToArrayIndex.DangerousGetReferenceAt(id) != -1;
+    }
+
     /// <summary>
     ///     Checks if a component is included in this <see cref="Chunk"/>.
     /// </summary>
@@ -259,8 +288,7 @@ public void Copy<T>(int index, in T cmp)
     public bool Has<T>()
     {
         var id = Component<T>.ComponentType.Id;
-        var idToArrayIndex = ComponentIdToArrayIndex;
-        return id < idToArrayIndex.Length && idToArrayIndex.DangerousGetReferenceAt(id) != -1;
+        return Has(id);
     }
 
     /// <summary>
@@ -451,12 +479,7 @@ public void Copy(int index, object cmp)
     public bool Has(ComponentType t)
     {
         var id = t.Id;
-        if (id >= ComponentIdToArrayIndex.Length)
-        {
-            return false;
-        }
-
-        return ComponentIdToArrayIndex.DangerousGetReferenceAt(id) != -1;
+        return Has(id);
     }
 
     /// <summary>
@@ -550,45 +573,37 @@ internal static void Fill<T>(ref Chunk chunk, int destinationIndex, int length,
     /// </summary>
     /// <param name="source">The source <see cref="Chunk"/>.</param>
     /// <param name="index">The start index in the source <see cref="Chunk"/>.</param>
+    /// <param name="sourceSignature">The <see cref="Signature"/> from the source archetype.</param>
     /// <param name="destination">The destination <see cref="Chunk"/>.</param>
     /// <param name="destinationIndex">The start index in the destination <see cref="Chunk"/>.</param>
     /// <param name="length">The length indicating the amount of <see cref="Entity"/>s being copied.</param>
-    [Pure]
-    internal static void Copy(ref Chunk source, int index, ref Chunk destination, int destinationIndex, int length)
+    internal static void Copy(
+        ref Chunk source, int index, ref Signature sourceSignature,
+        ref Chunk destination, int destinationIndex,
+        int length)
     {
         // Arrays
         var entities = source.Entities;
-        var sourceComponents = source.Components;
 
         // Copy entities array
         Array.Copy(entities, index, destination.Entities, destinationIndex, length);
 
-        // Copy component arrays
-        for (var i = 0; i < sourceComponents.Length; i++)
-        {
-            var sourceArray = sourceComponents[i];
-            var sourceType = (ComponentType) sourceArray.GetType().GetElementType()!;
-
-            if (!destination.Has(sourceType))
-            {
-                continue;
-            }
-
-            var destinationArray = destination.GetArray(sourceType);
-            Array.Copy(sourceArray, index, destinationArray, destinationIndex, length);
-        }
+        CopyComponents(ref source, index, ref sourceSignature, ref destination, destinationIndex, length);
     }
 
     /// <summary>
     ///     Copies an <see cref="Arch.Core.Entity"/> components at one index to another <see cref="Chunk"/>-index.
     /// </summary>
     /// <param name="source">The source <see cref="Chunk"/>.</param>
     /// <param name="index">The start index in the source <see cref="Chunk"/>.</param>
+    /// <param name="sourceSignature">The <see cref="Signature"/> from the source archetype.</param>
     /// <param name="destination">The destination <see cref="Chunk"/>.</param>
     /// <param name="destinationIndex">The start index in the destination <see cref="Chunk"/>.</param>
     /// <param name="length">The length indicating the amount of <see cref="Entity"/>s being copied.</param>
-    [Pure]
-    internal static void CopyComponents(ref Chunk source, int index, ref Chunk destination, int destinationIndex, int length)
+    internal static void CopyComponents(
+        ref Chunk source, int index, ref Signature sourceSignature,
+        ref Chunk destination, int destinationIndex,
+        int length)
     {
         // Arrays
         var sourceComponents = source.Components;
@@ -597,15 +612,15 @@ internal static void CopyComponents(ref Chunk source, int index, ref Chunk desti
         for (var i = 0; i < sourceComponents.Length; i++)
         {
             var sourceArray = sourceComponents[i];
-            var sourceType = sourceArray.GetType().GetElementType();
-            var compType = (ComponentType) sourceType!;
+            var sourceType = sourceSignature.Components[i];
 
-            if (!destination.Has(compType))
+            // Doesn't have component in destination array.
+            if (!destination.TryIndex(sourceType.Id, out var arrayIndex))
             {
                 continue;
             }
 
-            var destinationArray = destination.GetArray(compType);
+            var destinationArray = destination.Components.DangerousGetReferenceAt(arrayIndex);
             Array.Copy(sourceArray, index, destinationArray, destinationIndex, length);
         }
     }