Effciently find sentinel candidates and fill perfect hash table with it when there are empty slots

Author: Genbox

Src/FastData/Internal/Misc/HashData.cs

@@ -3,7 +3,7 @@
 namespace Genbox.FastData.Internal.Misc;
 
 /// <summary>Used internally in FastData to store hash codes and their properties.</summary>
-internal record HashData(ulong[] HashCodes, int CapacityFactor, bool HashCodesUnique, bool HashCodesPerfect)
+internal record HashData(ulong[] HashCodes, int CapacityFactor, bool HashCodesUnique, bool HashCodesPerfect, ulong MinHashCode, ulong MaxHashCode)
 {
     internal static HashData Create<T>(T[] data, int capacityFactor, HashFunc<T> func)
     {
@@ -21,19 +21,24 @@ internal static HashData Create<T>(T[] data, int capacityFactor, HashFunc<T> fun
 
         bool uniq = true;
         bool perfect = true;
+        ulong minHashCode = ulong.MaxValue;
+        ulong maxHashCode = ulong.MinValue;
 
         for (int i = 0; i < data.Length; i++)
         {
             ulong hash = func(data[i]);
             hashCodes[i] = hash;
 
+            minHashCode = hash < minHashCode ? hash : minHashCode;
+            maxHashCode = hash > maxHashCode ? hash : maxHashCode;
+
             if (uniq && !uniqSet.Add(hash)) //The unique check is first so that when it is false, we don't try the other conditions
                 uniq = false;
 
             if (perfect && !perfectSet.Add(hash % size))
                 perfect = false;
         }
 
-        return new HashData(hashCodes, capacityFactor, uniq, perfect);
+        return new HashData(hashCodes, capacityFactor, uniq, perfect, minHashCode, maxHashCode);
     }
 }

Src/FastData/Internal/Structures/HashTablePerfectStructure.cs

@@ -14,11 +14,20 @@ public HashTablePerfectContext<TKey, TValue> Create(TKey[] keys, TValue[]? value
             throw new InvalidOperationException("HashSetPerfectStructure can only be created with a perfect hash function.");
 
         ulong size = (ulong)(keys.Length * hashData.CapacityFactor);
-
+        bool hasEmptySlots = size != (ulong)keys.Length;
+        bool storeHashCode = !keyType.IsIdentityHash() || hasEmptySlots;
         ulong[] hashCodes = hashData.HashCodes;
         KeyValuePair<TKey, ulong>[] pairs = new KeyValuePair<TKey, ulong>[size];
         TValue[]? denseValues = values == null ? null : new TValue[size];
 
+        if (storeHashCode && hasEmptySlots)
+        {
+            ulong sentinel = GetSentinel(hashData, hashCodes, keys.Length);
+
+            for (ulong i = 0; i < size; i++)
+                pairs[i] = new KeyValuePair<TKey, ulong>(default!, sentinel);
+        }
+
         //We need to reorder the data to match hashes
         for (int i = 0; i < keys.Length; i++)
         {
@@ -29,6 +38,38 @@ public HashTablePerfectContext<TKey, TValue> Create(TKey[] keys, TValue[]? value
                 denseValues[index] = values![i];
         }
 
-        return new HashTablePerfectContext<TKey, TValue>(pairs, !keyType.IsIdentityHash(), denseValues);
+        return new HashTablePerfectContext<TKey, TValue>(pairs, storeHashCode, denseValues);
+    }
+
+    private static ulong GetSentinel(HashData hashData, ulong[] hashCodes, int count)
+    {
+        if (hashData.MaxHashCode != ulong.MaxValue)
+            return hashData.MaxHashCode + 1;
+
+        if (hashData.MinHashCode != 0)
+            return hashData.MinHashCode - 1;
+
+        ulong candidate = 1;
+        while (true)
+        {
+            bool found = false;
+
+            for (int i = 0; i < count; i++)
+            {
+                if (hashCodes[i] == candidate)
+                {
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found)
+                return candidate;
+
+            candidate++;
+
+            if (candidate == 0)
+                throw new InvalidOperationException("Unable to find a sentinel hash value.");
+        }
     }
 }