UPM package version 3.4.6

web-flow · web-flow · commit a618e7d7a8b0 · 2023-05-01T13:15:21.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,10 +1,10 @@
 # Svelto.ECS Changelog
 All notable changes to this project will be documented in this file. Changes are listed in random order of importance.
 
-## [3.4.5] - 04-2023
-* improved code after internal data refactoring and fixed some bugs
-* Added static DynamicEntityDescriptor method to create a new DynamicEntityDescriptor without passing an array of components
-* factory method to build entities without entity descriptor is now internal
+## [3.4.6] - 05-2023
+
+* SveltoOnDOTS bug fixes/improvements
+* Comments and code cleanup
 
 ## [3.4.4] - 04-2023
 
diff --git a/Core/ComponentTypeID.cs b/Core/ComponentTypeID.cs
@@ -20,6 +20,11 @@ public static ComponentID id
             get => _id.Data;
         }
 
+        /// <summary>
+        /// c# Static constructors are guaranteed to be thread safe
+        /// The runtime guarantees that a static constructor is only called once. So even if a type is called by multiple threads at the same time,
+        /// the static constructor is always executed one time. To get a better understanding how this works, it helps to know what purpose it serves.
+        /// </summary>
         static ComponentTypeID()
         {
             Init();
diff --git a/Core/ComponentTypeMap.cs b/Core/ComponentTypeMap.cs
@@ -1,18 +1,19 @@
 using System;
+using System.Collections.Concurrent;
 using System.Runtime.CompilerServices;
 using Svelto.DataStructures;
 
 namespace Svelto.ECS
 {
-    public static class ComponentTypeMap
+    static class ComponentTypeMap
     {
-        static readonly FasterDictionary<RefWrapper<Type>, ComponentID> _componentTypeMap = new FasterDictionary<RefWrapper<Type>, ComponentID>();
-        static readonly FasterDictionary<ComponentID, Type> _reverseComponentTypeMap = new FasterDictionary<ComponentID, Type>();
+        static readonly ConcurrentDictionary<Type, ComponentID> _componentTypeMap = new ConcurrentDictionary<Type, ComponentID>();
+        static readonly ConcurrentDictionary<ComponentID, Type> _reverseComponentTypeMap = new ConcurrentDictionary<ComponentID, Type>();
 
         public static void Add(Type type, ComponentID idData)
         {
-            _componentTypeMap.Add(type, idData);
-            _reverseComponentTypeMap.Add(idData, type);
+            _componentTypeMap.TryAdd(type, idData);
+            _reverseComponentTypeMap.TryAdd(idData, type);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
diff --git a/Core/EnginesRoot.Engines.cs b/Core/EnginesRoot.Engines.cs
@@ -16,8 +16,8 @@ public partial class EnginesRoot
     {
         static EnginesRoot()
         {
-            EntityDescriptorsWarmup.Init();
-            GroupHashMap.Init();
+            EntityDescriptorsWarmup.WarmUp();
+            GroupHashMap.WarmUp();
             //SharedDictonary.Init();
             SerializationDescriptorMap.Init();
 
diff --git a/Core/EntityDescriptor/DynamicEntityDescriptor.cs b/Core/EntityDescriptor/DynamicEntityDescriptor.cs
@@ -45,7 +45,7 @@ public static DynamicEntityDescriptor<TType> CreateDynamicEntityDescriptor()
 
         public DynamicEntityDescriptor(IComponentBuilder[] extraEntityBuilders)
         {
-            this = CreateDynamicEntityDescriptor();
+            this = DynamicEntityDescriptor<TType>.CreateDynamicEntityDescriptor();
             
             var extraEntitiesLength = extraEntityBuilders.Length;
 
@@ -54,7 +54,7 @@ public DynamicEntityDescriptor(IComponentBuilder[] extraEntityBuilders)
 
         public DynamicEntityDescriptor(FasterList<IComponentBuilder> extraEntityBuilders) 
         {
-            this = CreateDynamicEntityDescriptor();
+            this = DynamicEntityDescriptor<TType>.CreateDynamicEntityDescriptor();
             
             var extraEntities       = extraEntityBuilders.ToArrayFast(out _);
             var extraEntitiesLength = extraEntityBuilders.count;
diff --git a/Core/EntityReference/EnginesRoot.LocatorMap.cs b/Core/EntityReference/EnginesRoot.LocatorMap.cs
@@ -173,10 +173,10 @@ public SharedSveltoDictionaryNative<uint, EntityReference> GetEntityReferenceMap
             public bool TryGetEGID(EntityReference reference, out EGID egid)
             {
                 egid = default;
-#if DEBUG && !PROFILE_SVELTO                
+     
                 if (reference == EntityReference.Invalid)
                     return false;
-#endif
+
                 // Make sure we are querying for the current version of the locator.
                 // Otherwise the locator is pointing to a removed entity.
                 ref var entityReferenceMapElement = ref _entityReferenceMap[reference.index];
diff --git a/Core/Groups/EntityDescriptorsWarmup.cs b/Core/Groups/EntityDescriptorsWarmup.cs
@@ -5,13 +5,13 @@
 
 namespace Svelto.ECS
 {
-    public static class EntityDescriptorsWarmup
+    static class EntityDescriptorsWarmup
     {
         /// <summary>
         /// c# Static constructors are guaranteed to be thread safe
         /// Warmup all EntityDescriptors and ComponentTypeID classes to avoid huge overheads when they are first used
         /// </summary>
-        internal static void Init()
+        internal static void WarmUp()
         {
             List<Assembly> assemblies = AssemblyUtility.GetCompatibleAssemblies();
             foreach (Assembly assembly in assemblies)
@@ -30,10 +30,7 @@ internal static void Init()
 
                             System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(warmup.TypeHandle);
                         }
-                        catch (Exception e)
-                        {
-                            continue;
-                        }
+                        catch { }
                     }
                 }
                 
@@ -51,10 +48,7 @@ internal static void Init()
                             //this warms up the component builder. There could be different implementation of components builders for the same component type in theory
                             System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(componentType.TypeHandle);
                         }
-                        catch (Exception e)
-                        {
-                            continue;
-                        }
+                        catch { }
                     }
                 }
             }
diff --git a/Core/Groups/GroupCompound.cs b/Core/Groups/GroupCompound.cs
@@ -27,7 +27,10 @@ public abstract class GroupCompound<G1, G2, G3, G4>: ITouchedByReflection
     {
         static GroupCompound()
         {
-            //avoid race conditions if compounds are using on multiple thread
+            //avoid race conditions if compounds are using on multiple thread. This shouldn't be necessary though since c# static constructors are guaranteed to be thread safe!
+            /// c# Static constructors are guaranteed to be thread safe
+            /// The runtime guarantees that a static constructor is only called once. So even if a type is called by multiple threads at the same time,
+            /// the static constructor is always executed one time. To get a better understanding how this works, it helps to know what purpose it serves.
             if (Interlocked.CompareExchange(ref isInitializing, 1, 0) == 0 &&
                 GroupCompoundInitializer.skipStaticCompoundConstructorsWith4Tags.Value == false)
             {
diff --git a/Core/Groups/GroupHashMap.cs b/Core/Groups/GroupHashMap.cs
@@ -10,8 +10,12 @@ public static class GroupHashMap
     {
         /// <summary>
         /// c# Static constructors are guaranteed to be thread safe
+        /// The runtime guarantees that a static constructor is only called once. So even if a type is called by multiple threads at the same time,
+        /// the static constructor is always executed one time. To get a better understanding how this works, it helps to know what purpose it serves.
+        ///
+        /// Warmup the group hash map. This will call all the static constructors of the group types
         /// </summary>
-        internal static void Init()
+        internal static void WarmUp()
         {
             List<Assembly> assemblies = AssemblyUtility.GetCompatibleAssemblies();
             foreach (Assembly assembly in assemblies)
@@ -26,8 +30,8 @@ internal static void Init()
                     {
                         CheckForGroupCompounds(type);
 
-                        if (type != null && type.IsClass && type.IsSealed &&
-                            type.IsAbstract) //IsClass and IsSealed and IsAbstract means only static classes
+                        //Search inside static types
+                        if (type != null && type.IsClass && type.IsSealed && type.IsAbstract) //IsClass and IsSealed and IsAbstract means only static classes
                         {
                             var subClasses = type.GetNestedTypes();
 
@@ -40,8 +44,8 @@ internal static void Init()
 
                             foreach (var field in fields)
                             {
-                                if (field.IsStatic
-                                 && (typeOfExclusiveGroup.IsAssignableFrom(field.FieldType)
+                                if (field.IsStatic 
+                                     && (typeOfExclusiveGroup.IsAssignableFrom(field.FieldType)
                                      || typeOfExclusiveGroupStruct.IsAssignableFrom(field.FieldType)
                                      || typeOfExclusiveBuildGroup.IsAssignableFrom(field.FieldType)))
                                 {
@@ -52,7 +56,8 @@ internal static void Init()
                                         var group = (ExclusiveGroup)field.GetValue(null);
                                         groupIDAndBitMask = ((ExclusiveGroupStruct)@group).ToIDAndBitmask();
                                     }
-                                    else if (typeOfExclusiveGroupStruct.IsAssignableFrom(field.FieldType))
+                                    else 
+                                    if (typeOfExclusiveGroupStruct.IsAssignableFrom(field.FieldType))
                                     {
                                         var group = (ExclusiveGroupStruct)field.GetValue(null);
                                         groupIDAndBitMask = @group.ToIDAndBitmask();
@@ -94,7 +99,7 @@ static void CheckForGroupCompounds(Type type)
         {
             if (typeof(ITouchedByReflection).IsAssignableFrom(type))
             {
-                //this wil call the static constructor, but only once. Static constructors won't be called
+                //this calls the static constructor, but only once. Static constructors won't be called
                 //more than once with this
                 System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(type.BaseType.TypeHandle);
             }
@@ -107,7 +112,7 @@ static void CheckForGroupCompounds(Type type)
         /// <param name="exclusiveGroupStruct"></param>
         /// <param name="name"></param>
         /// <exception cref="ECSException"></exception>
-        public static void RegisterGroup(ExclusiveGroupStruct exclusiveGroupStruct, string name)
+        internal static void RegisterGroup(ExclusiveGroupStruct exclusiveGroupStruct, string name)
         {
             //Group already registered by another field referencing the same group, can happen because
             //the group poked is a group compound which static constructor is already been called at this point
@@ -125,7 +130,7 @@ public static void RegisterGroup(ExclusiveGroupStruct exclusiveGroupStruct, stri
             _hashByGroups.Add(exclusiveGroupStruct, nameHash);
         }
 
-        internal static uint GetHashFromGroup(ExclusiveGroupStruct groupStruct)
+        public static uint GetHashFromGroup(ExclusiveGroupStruct groupStruct)
         {
 #if DEBUG && !PROFILE_SVELTO
             if (_hashByGroups.ContainsKey(groupStruct) == false)
@@ -135,7 +140,7 @@ internal static uint GetHashFromGroup(ExclusiveGroupStruct groupStruct)
             return _hashByGroups[groupStruct];
         }
 
-        internal static ExclusiveGroupStruct GetGroupFromHash(uint groupHash)
+        public static ExclusiveGroupStruct GetGroupFromHash(uint groupHash)
         {
 #if DEBUG && !PROFILE_SVELTO
             if (_groupsByHash.ContainsKey(groupHash) == false)
diff --git a/Extensions/Unity/DOTS/UECS/DOTSOperationsForSvelto.cs b/Extensions/Unity/DOTS/UECS/DOTSOperationsForSvelto.cs
diff --git a/Extensions/Unity/DOTS/UECS/SveltoOnDOTSEntitiesSubmissionGroup.cs b/Extensions/Unity/DOTS/UECS/SveltoOnDOTSEntitiesSubmissionGroup.cs
diff --git a/README.md b/README.md
diff --git a/package.json b/package.json

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,11 @@ public static ComponentID id`
`20`	`20`	`get => _id.Data;`
`21`	`21`	`}`
`22`	`22`
	`23`	`+ /// <summary>`
	`24`	`+ /// c# Static constructors are guaranteed to be thread safe`
	`25`	`+ /// The runtime guarantees that a static constructor is only called once. So even if a type is called by multiple threads at the same time,`
	`26`	`+ /// the static constructor is always executed one time. To get a better understanding how this works, it helps to know what purpose it serves.`
	`27`	`+ /// </summary>`
`23`	`28`	`static ComponentTypeID()`
`24`	`29`	`{`
`25`	`30`	`Init();`
Original file line number	Diff line number	Diff line change
`@@ -1,18 +1,19 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Collections.Concurrent;`
`2`	`3`	`using System.Runtime.CompilerServices;`
`3`	`4`	`using Svelto.DataStructures;`
`4`	`5`
`5`	`6`	`namespace Svelto.ECS`
`6`	`7`	`{`
`7`		`- public static class ComponentTypeMap`
	`8`	`+ static class ComponentTypeMap`
`8`	`9`	`{`
`9`		`- static readonly FasterDictionary<RefWrapper<Type>, ComponentID> _componentTypeMap = new FasterDictionary<RefWrapper<Type>, ComponentID>();`
`10`		`- static readonly FasterDictionary<ComponentID, Type> _reverseComponentTypeMap = new FasterDictionary<ComponentID, Type>();`
	`10`	`+ static readonly ConcurrentDictionary<Type, ComponentID> _componentTypeMap = new ConcurrentDictionary<Type, ComponentID>();`
	`11`	`+ static readonly ConcurrentDictionary<ComponentID, Type> _reverseComponentTypeMap = new ConcurrentDictionary<ComponentID, Type>();`
`11`	`12`
`12`	`13`	`public static void Add(Type type, ComponentID idData)`
`13`	`14`	`{`
`14`		`- _componentTypeMap.Add(type, idData);`
`15`		`- _reverseComponentTypeMap.Add(idData, type);`
	`15`	`+ _componentTypeMap.TryAdd(type, idData);`
	`16`	`+ _reverseComponentTypeMap.TryAdd(idData, type);`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,8 @@ public partial class EnginesRoot`
`16`	`16`	`{`
`17`	`17`	`static EnginesRoot()`
`18`	`18`	`{`
`19`		`- EntityDescriptorsWarmup.Init();`
`20`		`- GroupHashMap.Init();`
	`19`	`+ EntityDescriptorsWarmup.WarmUp();`
	`20`	`+ GroupHashMap.WarmUp();`
`21`	`21`	`//SharedDictonary.Init();`
`22`	`22`	`SerializationDescriptorMap.Init();`
`23`	`23`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ public static DynamicEntityDescriptor<TType> CreateDynamicEntityDescriptor()`
`45`	`45`
`46`	`46`	`public DynamicEntityDescriptor(IComponentBuilder[] extraEntityBuilders)`
`47`	`47`	`{`
`48`		`- this = CreateDynamicEntityDescriptor();`
	`48`	`+ this = DynamicEntityDescriptor<TType>.CreateDynamicEntityDescriptor();`
`49`	`49`
`50`	`50`	`var extraEntitiesLength = extraEntityBuilders.Length;`
`51`	`51`
`@@ -54,7 +54,7 @@ public DynamicEntityDescriptor(IComponentBuilder[] extraEntityBuilders)`
`54`	`54`
`55`	`55`	`public DynamicEntityDescriptor(FasterList<IComponentBuilder> extraEntityBuilders)`
`56`	`56`	`{`
`57`		`- this = CreateDynamicEntityDescriptor();`
	`57`	`+ this = DynamicEntityDescriptor<TType>.CreateDynamicEntityDescriptor();`
`58`	`58`
`59`	`59`	`var extraEntities = extraEntityBuilders.ToArrayFast(out _);`
`60`	`60`	`var extraEntitiesLength = extraEntityBuilders.count;`
Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,13 @@`
`5`	`5`
`6`	`6`	`namespace Svelto.ECS`
`7`	`7`	`{`
`8`		`- public static class EntityDescriptorsWarmup`
	`8`	`+ static class EntityDescriptorsWarmup`
`9`	`9`	`{`
`10`	`10`	`/// <summary>`
`11`	`11`	`/// c# Static constructors are guaranteed to be thread safe`
`12`	`12`	`/// Warmup all EntityDescriptors and ComponentTypeID classes to avoid huge overheads when they are first used`
`13`	`13`	`/// </summary>`
`14`		`- internal static void Init()`
	`14`	`+ internal static void WarmUp()`
`15`	`15`	`{`
`16`	`16`	`List<Assembly> assemblies = AssemblyUtility.GetCompatibleAssemblies();`
`17`	`17`	`foreach (Assembly assembly in assemblies)`
`@@ -30,10 +30,7 @@ internal static void Init()`
`30`	`30`
`31`	`31`	`System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(warmup.TypeHandle);`
`32`	`32`	`}`
`33`		`- catch (Exception e)`
`34`		`- {`
`35`		`- continue;`
`36`		`- }`
	`33`	`+ catch { }`
`37`	`34`	`}`
`38`	`35`	`}`
`39`	`36`
`@@ -51,10 +48,7 @@ internal static void Init()`
`51`	`48`	`//this warms up the component builder. There could be different implementation of components builders for the same component type in theory`
`52`	`49`	`System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(componentType.TypeHandle);`
`53`	`50`	`}`
`54`		`- catch (Exception e)`
`55`		`- {`
`56`		`- continue;`
`57`		`- }`
	`51`	`+ catch { }`
`58`	`52`	`}`
`59`	`53`	`}`
`60`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,10 @@ public abstract class GroupCompound<G1, G2, G3, G4>: ITouchedByReflection`
`27`	`27`	`{`
`28`	`28`	`static GroupCompound()`
`29`	`29`	`{`
`30`		`- //avoid race conditions if compounds are using on multiple thread`
	`30`	`+ //avoid race conditions if compounds are using on multiple thread. This shouldn't be necessary though since c# static constructors are guaranteed to be thread safe!`
	`31`	`+ /// c# Static constructors are guaranteed to be thread safe`
	`32`	`+ /// The runtime guarantees that a static constructor is only called once. So even if a type is called by multiple threads at the same time,`
	`33`	`+ /// the static constructor is always executed one time. To get a better understanding how this works, it helps to know what purpose it serves.`
`31`	`34`	`if (Interlocked.CompareExchange(ref isInitializing, 1, 0) == 0 &&`
`32`	`35`	`GroupCompoundInitializer.skipStaticCompoundConstructorsWith4Tags.Value == false)`
`33`	`36`	`{`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,12 @@ public static class GroupHashMap`
`10`	`10`	`{`
`11`	`11`	`/// <summary>`
`12`	`12`	`/// c# Static constructors are guaranteed to be thread safe`
	`13`	`+ /// The runtime guarantees that a static constructor is only called once. So even if a type is called by multiple threads at the same time,`
	`14`	`+ /// the static constructor is always executed one time. To get a better understanding how this works, it helps to know what purpose it serves.`
	`15`	`+ ///`
	`16`	`+ /// Warmup the group hash map. This will call all the static constructors of the group types`
`13`	`17`	`/// </summary>`
`14`		`- internal static void Init()`
	`18`	`+ internal static void WarmUp()`
`15`	`19`	`{`
`16`	`20`	`List<Assembly> assemblies = AssemblyUtility.GetCompatibleAssemblies();`
`17`	`21`	`foreach (Assembly assembly in assemblies)`
`@@ -26,8 +30,8 @@ internal static void Init()`
`26`	`30`	`{`
`27`	`31`	`CheckForGroupCompounds(type);`
`28`	`32`
`29`		`- if (type != null && type.IsClass && type.IsSealed &&`
`30`		`- type.IsAbstract) //IsClass and IsSealed and IsAbstract means only static classes`
	`33`	`+ //Search inside static types`
	`34`	`+ if (type != null && type.IsClass && type.IsSealed && type.IsAbstract) //IsClass and IsSealed and IsAbstract means only static classes`
`31`	`35`	`{`
`32`	`36`	`var subClasses = type.GetNestedTypes();`
`33`	`37`
`@@ -40,8 +44,8 @@ internal static void Init()`
`40`	`44`
`41`	`45`	`foreach (var field in fields)`
`42`	`46`	`{`
`43`		`- if (field.IsStatic`
`44`		`- && (typeOfExclusiveGroup.IsAssignableFrom(field.FieldType)`
	`47`	`+ if (field.IsStatic`
	`48`	`+ && (typeOfExclusiveGroup.IsAssignableFrom(field.FieldType)`
`45`	`49`	`\|\| typeOfExclusiveGroupStruct.IsAssignableFrom(field.FieldType)`
`46`	`50`	`\|\| typeOfExclusiveBuildGroup.IsAssignableFrom(field.FieldType)))`
`47`	`51`	`{`
`@@ -52,7 +56,8 @@ internal static void Init()`
`52`	`56`	`var group = (ExclusiveGroup)field.GetValue(null);`
`53`	`57`	`groupIDAndBitMask = ((ExclusiveGroupStruct)@group).ToIDAndBitmask();`
`54`	`58`	`}`
`55`		`- else if (typeOfExclusiveGroupStruct.IsAssignableFrom(field.FieldType))`
	`59`	`+ else`
	`60`	`+ if (typeOfExclusiveGroupStruct.IsAssignableFrom(field.FieldType))`
`56`	`61`	`{`
`57`	`62`	`var group = (ExclusiveGroupStruct)field.GetValue(null);`
`58`	`63`	`groupIDAndBitMask = @group.ToIDAndBitmask();`
`@@ -94,7 +99,7 @@ static void CheckForGroupCompounds(Type type)`
`94`	`99`	`{`
`95`	`100`	`if (typeof(ITouchedByReflection).IsAssignableFrom(type))`
`96`	`101`	`{`
`97`		`- //this wil call the static constructor, but only once. Static constructors won't be called`
	`102`	`+ //this calls the static constructor, but only once. Static constructors won't be called`
`98`	`103`	`//more than once with this`
`99`	`104`	`System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(type.BaseType.TypeHandle);`
`100`	`105`	`}`
`@@ -107,7 +112,7 @@ static void CheckForGroupCompounds(Type type)`
`107`	`112`	`/// <param name="exclusiveGroupStruct"></param>`
`108`	`113`	`/// <param name="name"></param>`
`109`	`114`	`/// <exception cref="ECSException"></exception>`
`110`		`- public static void RegisterGroup(ExclusiveGroupStruct exclusiveGroupStruct, string name)`
	`115`	`+ internal static void RegisterGroup(ExclusiveGroupStruct exclusiveGroupStruct, string name)`
`111`	`116`	`{`
`112`	`117`	`//Group already registered by another field referencing the same group, can happen because`
`113`	`118`	`//the group poked is a group compound which static constructor is already been called at this point`
`@@ -125,7 +130,7 @@ public static void RegisterGroup(ExclusiveGroupStruct exclusiveGroupStruct, stri`
`125`	`130`	`_hashByGroups.Add(exclusiveGroupStruct, nameHash);`
`126`	`131`	`}`
`127`	`132`
`128`		`- internal static uint GetHashFromGroup(ExclusiveGroupStruct groupStruct)`
	`133`	`+ public static uint GetHashFromGroup(ExclusiveGroupStruct groupStruct)`
`129`	`134`	`{`
`130`	`135`	`#if DEBUG && !PROFILE_SVELTO`
`131`	`136`	`if (_hashByGroups.ContainsKey(groupStruct) == false)`
`@@ -135,7 +140,7 @@ internal static uint GetHashFromGroup(ExclusiveGroupStruct groupStruct)`
`135`	`140`	`return _hashByGroups[groupStruct];`
`136`	`141`	`}`
`137`	`142`
`138`		`- internal static ExclusiveGroupStruct GetGroupFromHash(uint groupHash)`
	`143`	`+ public static ExclusiveGroupStruct GetGroupFromHash(uint groupHash)`
`139`	`144`	`{`
`140`	`145`	`#if DEBUG && !PROFILE_SVELTO`
`141`	`146`	`if (_groupsByHash.ContainsKey(groupHash) == false)`