Add HashMap enhancements and benchmarking updates

Added `Count` and `Capacity` properties to the `HashMap` class to expose its size and capacity. Introduced a `Clear` method to reset the hash map.

Simplified `Main` in `Program.cs` by removing `Utils.QSort` usage. Added a `HashMap<int, int>` instance to `UnsafeDictionaryBenchmark` for performance testing.

Updated `Setup` in `UnsafeDictionaryBenchmark` to clear the `HashMap` during initialization. Added a new `AddHashMap` benchmark method to measure `HashMap` performance, including automatic clearing when size exceeds 100,000.

Author: JunaMeinhold

Hexa.NET.Utilities/HashMap.cs

@@ -223,6 +223,10 @@ public static int Find(int hash, Tag tag, TKey key, in Columns cols, int capacit
         private int size;
         private nint equals;
 
+        public int Count => size;
+
+        public int Capacity => capacity;
+
         private static void RehashMoveRow(in Columns src, in Columns dst, int newCapacity)
         {
             var tag = *src.tags;
@@ -360,6 +364,17 @@ public void Release()
             capacity = 0;
             size = 0;
         }
+
+        public void Clear()
+        {
+            if (tags == null)
+            {
+                return;
+            }
+            var tagsInBytes = (nuint)(capacity * sizeof(Tag));
+            NativeMemory.Clear(tags, tagsInBytes);
+            size = 0;
+        }
     }
 
 

TestApp/Program.cs

@@ -8,15 +8,7 @@ public class Program
     {
         private static unsafe void Main(string[] args)
         {
-            int[] array = { 10, 7, 8, 9, 1, 5 };
-            int length = array.Length;
-
-            fixed (int* ptr = array)
-            {
-                Utils.QSort(ptr, length, (a, b) => a.CompareTo(b)); // Default integer comparison
-            }
-
-            //var summary = BenchmarkRunner.Run<UnsafeDictionaryBenchmark>();
+            var summary = BenchmarkRunner.Run<UnsafeDictionaryBenchmark>();
             //var summary = BenchmarkRunner.Run<UnsafeListBenchmark>();
             /*
              UnsafeDictionaryBenchmark benchmark = new();
@@ -89,6 +81,7 @@ public unsafe class UnsafeDictionaryBenchmark
             // worst case scenario benchmark using linear keys where the hash code of int is always the value of itself.
 
             private UnsafeDictionary<int, int> _unsafeDict;   // about 29% faster and saves 7 bytes per entry and has a way lower Std-dev.
+            private HashMap<int, int> _hashMap;
             private Dictionary<int, int> _managedDict = new();
             private int iterationIndex = 0;
 
@@ -97,6 +90,7 @@ public void Setup()
             {
                 iterationIndex = 0;
                 _unsafeDict.Clear();
+                _hashMap.Clear();
                 _managedDict.Clear();
             }
 
@@ -110,6 +104,16 @@ public void AddUnsafeDictionary()
                 }
             }
 
+            [Benchmark]
+            public void AddHashMap()
+            {
+                _hashMap.Add(iterationIndex++, 2); // Add elements to the managed list
+                if (_hashMap.Count > 100000)
+                {
+                    _hashMap.Clear();
+                }
+            }
+
             [Benchmark(Baseline = true)]
             public void AddManagedDictionary()
             {