Replaced chunk internal dictionary with a lookup table. Its purpose is to map the component id to the chunk array index for quickly receiving the underlying arrays.

genaray · genaray · commit 87f66d2dfec7 · 2022-11-23T20:36:26.000+01:00
Since the dictionary is no longer involved, it actually increased the speed... #18
diff --git a/Arch.Benchmark/Benchmark.cs b/Arch.Benchmark/Benchmark.cs
@@ -15,28 +15,8 @@ private static void Main(string[] args)
             .AddValidator(JitOptimizationsValidator.DontFailOnError)
             .AddLogger(ConsoleLogger.Default)
             .AddColumnProvider(DefaultColumnProviders.Instance);
-
-        /*
-        var it = new QueryBenchmark { amount = 10000 };
-        it.Setup();
-        for (var index = 0; index < 10000; index++) {
-            it.StructEntityQuery();
-            Console.WriteLine(index);
-        }
-        it.Cleanup();*/
-
+        
         // Use : dotnet run -c Release --framework net7.0 -- --job short --filter *IterationBenchmark*
         BenchmarkSwitcher.FromAssembly(typeof(Benchmark).Assembly).Run(args, config);
-
-        /*
-        var it = new ArchetypeIterationBenchmark { amount = 100000 };
-        it.Setup();
-        for (var index = 0; index < 100000; index++) {
-            it.IterationJobSchedulerUnsafeAdd();
-            Console.WriteLine(index);
-        }
-        Console.WriteLine("Cleanup");
-        it.Cleanup();
-        Console.WriteLine("YES");*/
     }
 }
diff --git a/Arch/Core/Archetype.cs b/Arch/Core/Archetype.cs
@@ -22,24 +22,32 @@ internal Archetype(params Type[] types)
 
         // The bitmask/set 
         BitSet = types.ToBitSet();
+        ComponentIdToArrayIndex = types.ToLookupArray();
+        
         EntityIdToChunkIndex = new PooledDictionary<int, int>(EntitiesPerChunk);
         Chunks = Array.Empty<Chunk>();
     }
 
     /// <summary>
     ///     The types with which the <see cref="BitSet" /> was created.
     /// </summary>
-    public Type[] Types { get; set; }
+    public Type[] Types { get; }
 
     /// <summary>
     ///     The bitmask for querying, contains the component flags set for this archetype.
     /// </summary>
-    public BitSet BitSet { get; set; }
+    public BitSet BitSet { get; }
+
+    /// <summary>
+    /// A lookup table which maps a component-id to its array index in the <see cref="Chunk"/>.
+    /// Stored here since it reduces the amount of memory, better than every chunk having one of these. 
+    /// </summary>
+    public int[] ComponentIdToArrayIndex { get; }
 
     /// <summary>
     ///     For mapping the entity id to the chunk it is in.
     /// </summary>
-    public PooledDictionary<int, int> EntityIdToChunkIndex { get; set; }
+    public PooledDictionary<int, int> EntityIdToChunkIndex { get; }
 
     /// <summary>
     ///     A array of active chunks within this archetype.
@@ -97,6 +105,7 @@ internal int NextChunkIndex()
     public bool Add(in Entity entity)
     {
 
+        // Get next available chunk which has free space... 
         var nextChunkIndex = NextChunkIndex();
         if (nextChunkIndex != -1)
         {
@@ -114,7 +123,7 @@ public bool Add(in Entity entity)
         }
 
         // Create new chunk
-        var newChunk = new Chunk(EntitiesPerChunk, Types);
+        var newChunk = new Chunk(EntitiesPerChunk, ComponentIdToArrayIndex, Types);
         newChunk.Add(in entity);
 
         // Resize chunks
@@ -295,7 +304,7 @@ public void Reserve(in int amount)
 
             for (var index = 0; index < neededChunks; index++)
             {
-                var newChunk = new Chunk(EntitiesPerChunk, Types);
+                var newChunk = new Chunk(EntitiesPerChunk, ComponentIdToArrayIndex, Types);
                 Chunks[Capacity + index] = newChunk;
             }
 
@@ -309,7 +318,7 @@ public void Reserve(in int amount)
 
             for (var index = 0; index < neededChunks; index++)
             {
-                var newChunk = new Chunk(EntitiesPerChunk, Types);
+                var newChunk = new Chunk(EntitiesPerChunk, ComponentIdToArrayIndex, Types);
                 Chunks[Capacity + index] = newChunk;
             }
 
diff --git a/Arch/Core/Chunk.cs b/Arch/Core/Chunk.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.Contracts;
 using System.Runtime.CompilerServices;
+using Arch.Core.Extensions;
 using Arch.Core.Utils;
 using CommunityToolkit.HighPerformance;
 
@@ -22,6 +23,7 @@ namespace Arch.Core;
 /// </summary>
 public partial struct Chunk
 {
+    
     /// <summary>
     ///     Allocates enough space for the passed amount of entities with all its components.
     /// </summary>
@@ -37,16 +39,39 @@ internal Chunk(int capacity, params Type[] types)
         Components = new Array[types.Length];
 
         // Init mapping
-        ComponentIdToArrayIndex = new Dictionary<int, int>(types.Length);
+        ComponentIdToArrayIndex = types.ToLookupArray();
         EntityIdToIndex = new Dictionary<int, int>(Capacity);
 
         // Allocate arrays and map 
         for (var index = 0; index < types.Length; index++)
         {
             var type = types[index];
-            var componentId = ComponentMeta.Id(type);
+            Components[index] = Array.CreateInstance(type, Capacity);
+        }
+    }
+    
+    /// <summary>
+    ///     Allocates enough space for the passed amount of entities with all its components.
+    /// </summary>
+    /// <param name="capacity"></param>
+    /// <param name="types"></param>
+    internal Chunk(int capacity, int[] componentIdToArrayIndex, params Type[] types)
+    {
+        // Calculate capacity & init arrays
+        Size = 0;
+        Capacity = capacity;
+
+        Entities = new Entity[Capacity];
+        Components = new Array[types.Length];
+
+        // Init mapping
+        ComponentIdToArrayIndex = componentIdToArrayIndex;
+        EntityIdToIndex = new Dictionary<int, int>(Capacity);
 
-            ComponentIdToArrayIndex[componentId] = index;
+        // Allocate arrays and map 
+        for (var index = 0; index < types.Length; index++)
+        {
+            var type = types[index];
             Components[index] = Array.CreateInstance(type, Capacity);
         }
     }
@@ -104,7 +129,8 @@ public void Set<T>(in Entity entity, in T cmp)
     public bool Has<T>()
     {
         var id = ComponentMeta<T>.Id;
-        return ComponentIdToArrayIndex.ContainsKey(id);
+        if (id >= ComponentIdToArrayIndex.Length) return false;
+        return ComponentIdToArrayIndex[id] != 1;
     }
 
     /// <summary>
@@ -192,7 +218,7 @@ public void Remove(in Entity entity)
     /// <summary>
     ///     A map to get the index of a component array inside <see cref="Components" />.
     /// </summary>
-    public readonly Dictionary<int, int> ComponentIdToArrayIndex { [Pure] get; }
+    public readonly int[] ComponentIdToArrayIndex { [Pure] get; }
 
     /// <summary>
     ///     A map used to get the array indexes of a certain <see cref="Entity" />.
@@ -226,10 +252,8 @@ public partial struct Chunk
     private int Index<T>()
     {
         var id = ComponentMeta<T>.Id;
-        if (ComponentIdToArrayIndex.TryGetValue(id, out var index))
-            return index;
-
-        return -1;
+        if (id >= ComponentIdToArrayIndex.Length) return -1;
+        return ComponentIdToArrayIndex[id];
     }
 
     /// <summary>
@@ -326,7 +350,8 @@ public partial struct Chunk
     public bool Has(Type t)
     {
         var id = ComponentMeta.Id(t);
-        return ComponentIdToArrayIndex.ContainsKey(id);
+        if (id >= ComponentIdToArrayIndex.Length) return false;
+        return ComponentIdToArrayIndex[id] != -1;
     }
 
     /// <summary>
@@ -339,10 +364,8 @@ public bool Has(Type t)
     private int Index(Type type)
     {
         var id = ComponentMeta.Id(type);
-        if (ComponentIdToArrayIndex.TryGetValue(id, out var index))
-            return index;
-
-        return -1;
+        if (id >= ComponentIdToArrayIndex.Length) return -1;
+        return ComponentIdToArrayIndex[id];
     }
     
     /// <summary>
diff --git a/Arch/Core/Extensions/TypeExtensions.cs b/Arch/Core/Extensions/TypeExtensions.cs
@@ -34,10 +34,9 @@ public static void WriteComponentIds(this Type[] types, Span<int> ids)
     /// <returns></returns>
     /// <exception cref="ArgumentException">Throws an exception if one type is not a value type</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static int ToByteSize(this IEnumerable<Type> types)
+    public static int ToByteSize(this Type[] types)
     {
         var size = 0;
-
         foreach (var type in types)
         {
             if (!type.IsValueType)
@@ -48,58 +47,34 @@ public static int ToByteSize(this IEnumerable<Type> types)
 
         return size;
     }
-
+    
     /// <summary>
     ///     Calculates the byte sum of the types.
     /// </summary>
     /// <param name="types">The types array</param>
     /// <returns></returns>
     /// <exception cref="ArgumentException">Throws an exception if one type is not a value type</exception>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static int OffsetTo(this IEnumerable<Type> types, Type type, int capacity)
+    public static int[] ToLookupArray(this Type[] types)
     {
-        var offset = 0;
-
-        foreach (var currentType in types)
+        
+        // Get max component id
+        var max = 0;
+        foreach (var type in types)
         {
-            if (!currentType.IsValueType)
-                throw new ArgumentException("Cant determine size of non value type.");
-
-            if (currentType == type) return offset;
-            offset += Marshal.SizeOf(currentType) * capacity;
+            var componentId = ComponentMeta.Id(type);
+            if (componentId >= max) max = componentId;
         }
 
-        return offset;
-    }
-
-    /// <summary>
-    ///     Checks wether a passed type is managed or not using a cached type version of <see cref="RuntimeHelpers.IsReferenceOrContainsReferences{T}" />
-    /// </summary>
-    /// <param name="type">The type, must be struct.</param>
-    /// <returns></returns>
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static bool IsManaged(Type type)
-    {
-        // Use cache
-        if (IsReferenceOrContainsReferenceCache.TryGetValue(type, out var func))
-            return func();
-
-        // Cache for type
-        var methodInfo = typeof(RuntimeHelpers).GetMethod("IsReferenceOrContainsReferences");
-        var genericMethod = methodInfo.MakeGenericMethod(type);
-        var funcDelegate = (Func<bool>)genericMethod.CreateDelegate(typeof(Func<bool>));
-        IsReferenceOrContainsReferenceCache[type] = funcDelegate;
-
-        return funcDelegate();
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static void Categorize(this Type[] types, out List<Type> managed, out List<Type> unmanaged)
-    {
-        managed = new List<Type>(types.Length);
-        unmanaged = new List<Type>(types.Length);
-        foreach (var type in types)
-            if (!IsManaged(type)) unmanaged.Add(type);
-            else managed.Add(type);
+        // Create lookup table where the component-id points to the component index. 
+        var array = new int[max+1];
+        Array.Fill(array, -1);  // -1 Since that indicates no component is in that index since components start at zero we can not use zero here. 
+        for(var index = 0; index < types.Length; index++)
+        {
+            var type = types[index];
+            var componentId = ComponentMeta.Id(type);
+            array[componentId] = index;
+        }
+        return array;
     }
 }
diff --git a/Arch/Core/Utils/ComponentRegistry.cs b/Arch/Core/Utils/ComponentRegistry.cs
@@ -6,6 +6,8 @@ namespace Arch.Core.Utils;
 
 /// <summary>
 ///     A class which tracks all used components in this project.
+///     Component-Ids start at 0 and each new used component will get an increased id.
+///     TODO : Probably components should start at 1 instead, since the hash and chunk.Has would work way smoother with it. 
 /// </summary>
 public static class ComponentRegistry
 {

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@ namespace Arch.Core.Utils;`
`6`	`6`
`7`	`7`	`/// <summary>`
`8`	`8`	`/// A class which tracks all used components in this project.`
	`9`	`+/// Component-Ids start at 0 and each new used component will get an increased id.`
	`10`	`+/// TODO : Probably components should start at 1 instead, since the hash and chunk.Has would work way smoother with it.`
`9`	`11`	`/// </summary>`
`10`	`12`	`public static class ComponentRegistry`
`11`	`13`	`{`