Speedup TryGet

src/Arch.Benchmarks/Benchmark.cs

@@ -9,7 +9,6 @@ public class Benchmark
 {
     private static void Main(string[] args)
     {
-        /*
         // NOTE: Can this be replaced with ManualConfig.CreateEmpty()?
 #pragma warning disable HAA0101 // Array allocation for params parameter
         var config = new ManualConfig()
@@ -18,28 +17,9 @@ private static void Main(string[] args)
             .AddLogger(ConsoleLogger.Default)
             .AddColumnProvider(DefaultColumnProviders.Instance);
 #pragma warning restore HAA0101 // Array allocation for params parameter
-        */
-
-
-
-        var world = World.Create();
-        for (var index = 0; index <= 100; index++)
-        {
-            world.Create<int>();
-        }
-
-        var desc = new QueryDescription().WithAll<int>();
-        for (var index = 0; index <= 100000; index++)
-        {
-            world.Query(in desc, (ref int i) =>
-            {
-            });
-        }
-
-
 
         // NOTE: Is `-- --job` a typo?
         // Use: dotnet run -c Release --framework net7.0 -- --job short --filter *IterationBenchmark*
-        //BenchmarkSwitcher.FromAssembly(typeof(Benchmark).Assembly).Run(args, config);
+        BenchmarkSwitcher.FromAssembly(typeof(Benchmark).Assembly).Run(args, config);
     }
 }

src/Arch.Benchmarks/TryGetBenchmark.cs

@@ -0,0 +1,70 @@
+using Arch.Core;
+using Arch.Core.Utils;
+
+namespace Arch.Benchmarks;
+
+[HtmlExporter]
+[MemoryDiagnoser]
+[HardwareCounters(HardwareCounter.CacheMisses)]
+public class TryGetBenchmark
+{
+    private static World _world;
+    private static List<Entity> _entities;
+
+    private Consumer _consumer = new();
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _world = World.Create();
+
+        _entities = new List<Entity>(1_000_000);
+        for (var index = 0; index < 1_000_000; index++)
+        {
+            _entities.Add(_world.Create(new Transform(), new Velocity()));
+        }
+    }
+
+    [Benchmark]
+    public void TryGetGenericRef()
+    {
+        for (var index = 0; index < _entities.Count; index++)
+        {
+            var entity = _entities[index];
+            var xform = _world.TryGetRef<Transform>(entity, out var exists);
+
+            if (exists)
+            {
+                _consumer.Consume(xform);
+            }
+        }
+    }
+
+    [Benchmark]
+    public void TryGetGeneric()
+    {
+        for (var index = 0; index < _entities.Count; index++)
+        {
+            var entity = _entities[index];
+
+            if (_world.TryGet<Transform>(entity, out var xform))
+            {
+                _consumer.Consume(xform);
+            }
+        }
+    }
+
+    [Benchmark]
+    public void TryGet()
+    {
+        for (var index = 0; index < _entities.Count; index++)
+        {
+            var entity = _entities[index];
+
+            if (_world.TryGet(entity, Component.GetComponentType(typeof(Transform)), out var xform))
+            {
+                _consumer.Consume(xform);
+            }
+        }
+    }
+}

src/Arch.Tests/WorldTest.cs

@@ -604,6 +604,18 @@ public void Add()
         That(_world.GetArchetype(entity2), Is.EqualTo(_world.GetArchetype(entity)));
         That(arch, Is.EqualTo(_world.GetArchetype(entity)));
     }
+
+    /// <summary>
+    ///     Checks if generic TryGet works on entities.
+    /// </summary>
+    [Test]
+    public void TryGet()
+    {
+        var entity = _world.Create(new Transform());
+
+        That(_world.TryGet(entity, out Transform xform), Is.EqualTo(true));
+        That(_world.TryGet(entity, out Rotation rot), Is.EqualTo(false));
+    }
 }
 
 
@@ -658,6 +670,18 @@ public void Add_NonGeneric()
         That(_world.GetArchetype(entity2), Is.EqualTo(_world.GetArchetype(entity)));
         That(arch, Is.EqualTo(_world.GetArchetype(entity)));
     }
+
+    /// <summary>
+    ///     Checks if generic TryGet works on entities.
+    /// </summary>
+    [Test]
+    public void TryGet_NonGeneric()
+    {
+        var entity = _world.Create(new Transform());
+
+        That(_world.TryGet(entity, Component<Transform>.ComponentType, out var xform), Is.EqualTo(true));
+        That(_world.TryGet(entity, Component<Rotation>.ComponentType, out var rot), Is.EqualTo(false));
+    }
 }
 
 /// <summary>

src/Arch/Core/Archetype.cs

@@ -1,4 +1,5 @@
 using System.Buffers;
+using System.Diagnostics.Contracts;
 using Arch.Core.Extensions;
 using Arch.Core.Extensions.Internal;
 using Arch.Core.Utils;
@@ -299,6 +300,27 @@ internal Archetype(Signature signature)
         _removeEdges = new SparseJaggedArray<Archetype>(BucketSize);
     }
 
+    /// <summary>
+    /// 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)
+    {
+        var id = Component<T>.ComponentType.Id;
+        Debug.Assert(id != -1, $"Index is out of bounds, component {typeof(T)} with id {id} does not exist in this chunk.");
+
+        if (id >= _componentIdToArrayIndex.Length)
+        {
+            i = -1;
+            return false;
+        }
+
+        i = _componentIdToArrayIndex.DangerousGetReferenceAt(id);
+        return i != -1;
+    }
+
     /// <summary>
     ///     The component types that the <see cref="Arch.Core.Entity"/>'s stored here have.
     /// </summary>

src/Arch/Core/World.cs

@@ -4,6 +4,7 @@
 using Arch.Core.Extensions.Internal;
 using Arch.Core.Utils;
 using Collections.Pooled;
+using CommunityToolkit.HighPerformance;
 using Schedulers;
 using Component = Arch.Core.Utils.Component;
 
@@ -983,18 +984,18 @@ public ref T Get<T>(Entity entity)
     [Pure]
     public bool TryGet<T>(Entity entity, out T? component)
     {
-        component = default;
-
-        var entitySlot = EntityInfo.GetEntitySlot(entity.Id);
-        var slot = entitySlot.Slot;
-        var archetype = entitySlot.Archetype;
+        ref var slot = ref EntityInfo.EntitySlots[entity.Id];
 
-        if (!archetype.Has<T>())
+        if (!slot.Archetype.TryIndex<T>(out int compIndex))
         {
+            component = default;
             return false;
         }
 
-        component = archetype.Get<T>(ref slot);
+        ref var chunk = ref slot.Archetype.GetChunk(slot.Slot.ChunkIndex);
+        Debug.Assert(compIndex != -1 && compIndex < chunk.Components.Length, $"Index is out of bounds, component {typeof(T)} with id {compIndex} does not exist in this chunk.");
+        var array = Unsafe.As<T[]>(chunk.Components.DangerousGetReferenceAt(compIndex));
+        component = array[slot.Slot.Index];
         return true;
     }
 
@@ -1009,16 +1010,14 @@ public bool TryGet<T>(Entity entity, out T? component)
     [Pure]
     public ref T TryGetRef<T>(Entity entity, out bool exists)
     {
-        var entitySlot = EntityInfo.GetEntitySlot(entity.Id);
-        var slot = entitySlot.Slot;
-        var archetype = entitySlot.Archetype;
+        ref var slot = ref EntityInfo.EntitySlots[entity.Id];
 
-        if (!(exists = archetype.Has<T>()))
+        if (!(exists = slot.Archetype.Has<T>()))
         {
             return ref Unsafe.NullRef<T>();
         }
 
-        return ref archetype.Get<T>(ref slot);
+        return ref slot.Archetype.Get<T>(ref slot.Slot);
     }
 
     /// <summary>