FIx: use hasher instead of object.GetHashCode()

Author: Wsm2110

README.md

@@ -105,11 +105,13 @@ Faster.Map allows for **custom hashing algorithms** to optimize performance base
 To specify a custom hash function, you can use **BlitzMap** or **DenseMap** with an explicitly defined hash:
 
 ```csharp
-var map = new BlitzMap<int, string, XXHash3>();
+var map = new BlitzMap<int, string, XxHash3StringHasher>();
 map.Insert(1, "Value One");
 map.Insert(2, "Value Two");
 ```
 
+Different Hasher implementations can be found in Faster.Map.Hasher
+
 Using **custom hashing** can significantly reduce collisions and improve lookup times, especially for large datasets.
 
  ## Tested on platforms:

benchmarks/Faster.Map.Benchmark/GetBenchmark.cs

@@ -29,7 +29,7 @@ public class GetBenchmark
 
         #region Properties
 
-        [Params(/*0.1, 0.2, 0.3, 0.4, 0.5,*/ 0.6 /*, 0.7, 0.8*/)]
+        [Params(/*0.1, 0.2, 0.3, 0.4, 0.5,*/ 0.6/*, 0.7, 0.8*/)]
         public static double LoadFactor { get; set; }
 
         [Params(134_217_728)]
@@ -43,7 +43,7 @@ public class GetBenchmark
         [GlobalSetup]
         public void Setup()
         {
-            var rnd = new FastRandom(6);
+            var rnd = new FastRandom(3);
             var uni = new HashSet<uint>((int)Length * 2);
             while (uni.Count < (uint)(Length * LoadFactor))
             {
@@ -64,8 +64,8 @@ public void Setup()
 
             foreach (var key in keys)
             {
-                //_dictionary.Add(key, key);
-                //_denseMap.Emplace(key, key);
+                _dictionary.Add(key, key);
+                _denseMap.Emplace(key, key);
                 _blitz.Insert(key, key);           
                 _robinHoodMap.Emplace(key, key);
             }
@@ -81,34 +81,34 @@ public void BlitzMap()
             }
         }
 
-        //[Benchmark]
-        //public void DenseMap()
-        //{
-        //    for (int i = 0; i < keys.Length; i++)
-        //    {
-        //        var key = keys[i];
-        //        _denseMap.Get(key, out var _);
-        //    }
-        //}
-
-        //[Benchmark]
-        //public void Dictionary()
-        //{
-        //    for (int i = 0; i < keys.Length; i++)
-        //    {
-        //        var key = keys[i];
-        //        _dictionary.TryGetValue(key, out var _);
-        //    }
-        //}
-
-        //[Benchmark]
-        //public void RobinhoodMap()
-        //{
-        //    for (int i = 0; i < keys.Length; i++)
-        //    {
-        //        var key = keys[i];
-        //        _robinHoodMap.Get(key, out var _);
-        //    }
-        //}
+        [Benchmark]
+        public void DenseMap()
+        {
+            for (int i = 0; i < keys.Length; i++)
+            {
+                var key = keys[i];
+                _denseMap.Get(key, out var _);
+            }
+        }
+
+        [Benchmark]
+        public void Dictionary()
+        {
+            for (int i = 0; i < keys.Length; i++)
+            {
+                var key = keys[i];
+                _dictionary.TryGetValue(key, out var _);
+            }
+        }
+
+        [Benchmark]
+        public void RobinhoodMap()
+        {
+            for (int i = 0; i < keys.Length; i++)
+            {
+                var key = keys[i];
+                _robinHoodMap.Get(key, out var _);
+            }
+        }
     }
 }

benchmarks/Faster.Map.Benchmark/Program.cs

@@ -10,7 +10,7 @@ static void Main(string[] args)
             //BenchmarkRunner.Run<AddBenchmark>();
            // BenchmarkRunner.Run<EnumerableBenchmark>();
             //BenchmarkRunner.Run<UpdateBenchmark>();
-            BenchmarkRunner.Run<LargeStringCustomHasherBenchmark>(/*new DebugInProcessConfig()*/);
+            BenchmarkRunner.Run<GetBenchmark>(/*new DebugInProcessConfig()*/);
         }
     }
 }

src/BlitzMap.cs

@@ -717,8 +717,8 @@ public void Copy(BlitzMap<TKey, TValue> other)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private uint FindLastBucket(ref Bucket bucketBase, ref Entry entryBase, uint target)
     {
-        // Directly calculate the hash code and index without intermediate variables
-        var index = (uint)Unsafe.Add(ref entryBase, target).Key.GetHashCode() & _mask;
+        var key = Unsafe.Add(ref entryBase, target).Key;
+        var index = _hasher.ComputeHash(key) & _mask;
 
         // Pointer to the initial bucket
         ref var bucket = ref Unsafe.Add(ref bucketBase, index);
@@ -856,7 +856,7 @@ private uint FindEmptyBucket(ref Bucket bucketBase, uint index, uint cint)
         var bucket = index;
 
         // Check if the bucket is empty
-        if (Unsafe.Add(ref bucketBase, bucket).Signature == INACTIVE ||
+        if (Unsafe.Add(ref bucketBase, ++bucket).Signature == INACTIVE ||
             Unsafe.Add(ref bucketBase, ++bucket).Signature == INACTIVE)
         {
             return bucket;

src/DenseMap.cs

@@ -12,7 +12,6 @@
 
 namespace Faster.Map;
 
-
 /// <summary>
 /// A specialized implementation of <see cref="DenseMap{TKey, TValue, THasher}"/> that
 /// defaults to using the <see cref="GoldenRatioHasher{TKey}"/> for efficient hashing.
@@ -197,7 +196,7 @@ public IEnumerable<TValue> Values
     #endregion
 
     #region Fields
-    private const uint ElementsInGroupMinusOne = 15;
+    
     private const sbyte _emptyBucket = -127;
     private const sbyte _tombstone = -126;
     private static readonly Vector128<sbyte> _emptyBucketVector = Vector128.Create(_emptyBucket);

src/Faster.Map.csproj

@@ -9,39 +9,21 @@
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <CopyRight>MIT</CopyRight>
     <PackageReleaseNotes>
-      ✨ What’s New?
-      🏎️ Incredible Hashing Speed with Faster.Hash
-
-      Optimized Performance: Harnesses hardware-accelerated AES instructions for lightning-fast hashing.
-      Deterministic and Reliable: Ensures consistent and collision-resistant hashes for uint, ulong, and arbitrary byte spans.
-      Highly Flexible: Hash support for various data types:
-      HashU64(uint source): Quickly hash 32-bit integers.
-      HashU64(ulong source): Hash 64-bit integers with efficiency.
-      HashU64(ReadOnlyspan): Process byte arrays with incredible speed.
-
-🗂️ Map Enhancements
-
-    Seamlessly integrates with Faster.Hash to deliver high-speed key lookups and optimized map operations.
-    Improved handling of large datasets with reduced memory overhead and faster hash-based operations.
-
-🛡️ Secure Hashing with HashU64Secure
-
-    Generate stronger hashes with additional randomness and encryption rounds for scenarios requiring enhanced data integrity.
-
+    Adding blitzmap a new highly optimized hashmap
     </PackageReleaseNotes>
     <PackageProjectUrl>https://github.com/Wsm2110/Faster.Map</PackageProjectUrl>
-    <AssemblyVersion>6.1.4</AssemblyVersion>
-    <FileVersion>6.1.4</FileVersion>
+    <AssemblyVersion>7.0.1</AssemblyVersion>
+    <FileVersion>7.0.1</FileVersion>
     <Title>Fastest .net hashmap</Title>
-    <Version>6.1.4</Version>
+    <Version>7.0.1</Version>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Description>
-      Incredibly fast (concurrent) hashmap
+      Incredibly fast hashmap
    </Description>
     <RepositoryUrl>https://github.com/Wsm2110/Faster.Map</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <PackageTags>Hashmap Hashtable Dictionary Faster.map performance, concurrency, simd, concurrenthashmap concurrentdictionary</PackageTags>
+    <PackageTags>Hashmap, Hashtable, Dictionary, Faster.map, performance, concurrency, simd, concurrenthashmap concurrentdictionary</PackageTags>
   </PropertyGroup>
 
   <PropertyGroup>

src/Hasher/DefaultHasher.cs

@@ -72,7 +72,7 @@ public uint ComputeHash(ulong x)
 /// Uses bit shifts and multiplications with high-entropy constants
 /// to produce a well-distributed hash.
 /// </summary>
-internal readonly struct DefaultUintHasher : IHasher<uint>
+public readonly struct DefaultUintHasher : IHasher<uint>
 {
     /// <summary>
     /// Computes a high-quality hash for a given <see cref="uint"/> value.
@@ -82,16 +82,25 @@ public uint ComputeHash(ulong x)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public uint ComputeHash(uint x)
     {
-        // Initial XOR shift to mix high and low bits
+        //For a comprehensive understanding of the XMX mixer and its applications, you can refer to Jon Maiga's detailed article: "The construct of a bit mixer."
         x ^= x >> 15;
-        // Multiply by a high-entropy constant for mixing
-        x *= 0x2C1B3C6D;
-        // Another XOR shift to spread the bits
+        x *= 0x85ebca6b;
         x ^= x >> 13;
-        // Another multiplication with a different high-entropy constant
-        x *= 0x297A2D39;
-        // Final XOR shift for additional diffusion
-        x ^= x >> 15;
+        x *= 0xc2b2ae35;
+        x ^= x >> 16;
         return x;
+
+
+        //// Initial XOR shift to mix high and low bits
+        //x ^= x >> 15;
+        //// Multiply by a high-entropy constant for mixing
+        //x *= 0x2C1B3C6D;
+        //// Another XOR shift to spread the bits
+        //x ^= x >> 13;
+        //// Another multiplication with a different high-entropy constant
+        //x *= 0x297A2D39;
+        //// Final XOR shift for additional diffusion
+        //x ^= x >> 15;
+        //return x;
     }
 }