CHG: add remove testcases - minor changes

Author: Wsm2110

src/BlitzMap.cs

@@ -135,6 +135,16 @@ public BlitzMap(int length) : this(length, 0.8) { }
     /// <param name="loadFactor">The load factor to control resizing behavior.</param>
     public BlitzMap(int length, double loadFactor)
     {
+        if (loadFactor <= 0.0 || loadFactor >= 1.0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(loadFactor), "Load factor must be > 0.0 and < 1.0");
+        }
+
+        if (loadFactor > 0.9)
+        {
+            loadFactor = 0.9;
+        }
+
         _length = (int)BitOperations.RoundUpToPowerOf2((uint)length);
         _mask = (uint)_length - 1;
         _loadFactor = loadFactor;
@@ -596,77 +606,70 @@ public bool InsertOrUpdate(TKey key, TValue value)
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool Remove(TKey key)
     {
-        // Generate a hash code for the provided key
         var hashcode = _hasher.ComputeHash(key);
-
-        // Calculate the primary index using the bitwise AND with the mask
-        // This constrains the index within the array bounds (_mask is typically array length - 1)
-        var index = hashcode & _mask;
-
-        // Calculate the secondary signature for collision detection
-        // The signature is the remaining bits of the hash not used by the index
+        uint index = hashcode & _mask;
         var signature = hashcode & ~_mask;
 
-        // Obtain references to the start of the bucket and entry arrays
         ref var bucketBase = ref MemoryMarshal.GetArrayDataReference(_buckets);
         ref var entryBase = ref MemoryMarshal.GetArrayDataReference(_entries);
 
-        // Start with the initial bucket determined by the hash index
+        uint prevIndex = INACTIVE;
         ref Bucket bucket = ref Unsafe.Add(ref bucketBase, index);
 
-        // Traverse the linked list of buckets to find the matching key
         while (true)
         {
-            // Check if the signature matches the desired key's signature
-            if (signature == (bucket.Signature & ~_mask))
+            if (bucket.Signature != INACTIVE &&
+                signature == (bucket.Signature & ~_mask))
             {
-                // Retrieve the entry associated with the current bucket
-                var entryIndex = bucket.Signature & _mask;
+                uint entryIndex = bucket.Signature & _mask;
                 ref var entry = ref Unsafe.Add(ref entryBase, entryIndex);
 
-                // Verify that the key matches using the equality comparer
                 if (_eq.Equals(key, entry.Key))
                 {
-                    // Erase the bucket and get the index of the next bucket
-                    // Update the last slot by decrementing the total filled count
-                    var lastSlot = --_count;
-
-                    ref var swap = ref Unsafe.Add(ref entryBase, lastSlot);
+                    // --- unlink bucket from chain ---
+                    if (prevIndex == INACTIVE)
+                    {
+                        // removing head
+                        if (bucket.Next != INACTIVE)
+                        {
+                            bucket = Unsafe.Add(ref bucketBase, bucket.Next);
+                        }
+                        else
+                        {
+                            bucket.Signature = INACTIVE;
+                            bucket.Next = INACTIVE;
+                        }
+                    }
+                    else
+                    {
+                        ref var prev = ref Unsafe.Add(ref bucketBase, prevIndex);
+                        prev.Next = bucket.Next;
+                    }
 
-                    // If the current slot is not the last filled slot
+                    // --- compact entries ---
+                    uint lastSlot = --_count;
                     if (entryIndex != lastSlot)
                     {
-                        // Determine the last bucket to update
-                        var lastBucket = (_lastBucket == INACTIVE || index == _lastBucket)
-                            ? FindLastBucket(ref bucketBase, ref entryBase, lastSlot) : _lastBucket;
-
-                        // Move the last pair to the current slot
-                        entry = swap;
+                        ref var moved = ref Unsafe.Add(ref entryBase, lastSlot);
+                        entry = moved;
 
-                        // Update the index of the last bucket to point to the new slot
-                        Unsafe.Add(ref bucketBase, lastBucket).Signature = entryIndex | (Unsafe.Add(ref bucketBase, lastBucket).Signature & ~_mask);
+                        // fix bucket pointing to moved entry
+                        uint movedBucket = FindLastBucket(ref bucketBase, ref entryBase, lastSlot);
+                        Unsafe.Add(ref bucketBase, movedBucket).Signature =
+                            entryIndex | (Unsafe.Add(ref bucketBase, movedBucket).Signature & ~_mask);
                     }
 
-                    // Clear the last entry, as it has been moved
-                    swap = default;
-
-                    // Mark the end of the list as inactive
+                    Unsafe.Add(ref entryBase, lastSlot) = default;
                     _lastBucket = INACTIVE;
-
-                    // Set the erased bucket to inactive
-                    _buckets[index].Signature = INACTIVE;
-                    return true; // Key found, return success
+                    return true;
                 }
             }
 
-            // If the next bucket index is inactive, the search is exhausted
             if (bucket.Next == INACTIVE)
-            {
-                return false; // Key not found, return failure
-            }
+                return false;
 
+            prevIndex = index;
             index = bucket.Next;
-            // Move to the next bucket in the chain
             bucket = ref Unsafe.Add(ref bucketBase, index);
         }
     }
@@ -903,8 +906,17 @@ private uint FindEmptyBucket(ref Bucket bucketBase, uint index, uint cint)
     public void Clear()
     {
         Array.Clear(_entries);
-        _buckets.AsSpan().Fill(new Bucket { Signature = INACTIVE, Next = INACTIVE });
+
+        _buckets.AsSpan().Fill(new Bucket
+        {
+            Signature = INACTIVE,
+            Next = INACTIVE
+        });
+
         _count = 0;
+        _last = 0;
+        _lastBucket = INACTIVE;
+        _numBuckets = (uint)_length >> 1;
     }
 
     /// <summary>

src/Faster.Map.csproj

@@ -9,11 +9,11 @@
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <CopyRight>MIT</CopyRight>
     <PackageReleaseNotes>
-    Adding blitzmap a new highly optimized hashmap
+      minor changes and fixes
     </PackageReleaseNotes>
     <PackageProjectUrl>https://github.com/Wsm2110/Faster.Map</PackageProjectUrl>
-    <AssemblyVersion>7.0.1</AssemblyVersion>
-    <FileVersion>7.0.1</FileVersion>
+    <AssemblyVersion>7.0.2</AssemblyVersion>
+    <FileVersion>7.0.2</FileVersion>
     <Title>Fastest .net hashmap</Title>
     <Version>7.0.1</Version>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>

unittests/Faster.Map.BlitzMap.Tests/RemoveTests.cs

@@ -857,7 +857,91 @@ public void RemoveLargeDateset()
             var key = keys[i];
             map.Remove(key);
         }
+    }
+
+    [Fact]
+    public void Remove_MiddleOfChain_PreservesLookup()
+    {
+        var map = new BlitzMap<int, string>(4);
+
+        // Force collisions
+        map.Insert(1, "A");
+        map.Insert(5, "B"); // same bucket as 1 if mask=3
+        map.Insert(9, "C");
+
+        Assert.True(map.Remove(5));
 
+        Assert.True(map.Contains(1));
+        Assert.False(map.Contains(5));
+        Assert.True(map.Contains(9));
+
+        Assert.Equal("A", map[1]);
+        Assert.Equal("C", map[9]);
     }
 
+    [Fact]
+    public void Remove_HeadOfChain_Works()
+    {
+        var map = new BlitzMap<int, int>(4);
+
+        map.Insert(1, 10);
+        map.Insert(5, 20);
+
+        Assert.True(map.Remove(1));
+        Assert.False(map.Contains(1));
+        Assert.True(map.Contains(5));
+        Assert.Equal(20, map[5]);
+    }
+
+
+    [Fact]
+    public void Remove_TailOfChain_Works()
+    {
+        var map = new BlitzMap<int, int>(4);
+
+        map.Insert(1, 10);
+        map.Insert(5, 20);
+        map.Insert(9, 30);
+
+        Assert.True(map.Remove(9));
+
+        Assert.True(map.Contains(1));
+        Assert.True(map.Contains(5));
+        Assert.False(map.Contains(9));
+    }
+
+    [Fact]
+    public void Remove_ThenInsert_ReusesSlotCorrectly()
+    {
+        var map = new BlitzMap<int, int>(4);
+
+        map.Insert(1, 1);
+        map.Insert(5, 2);
+
+        map.Remove(1);
+        map.Insert(9, 3);
+
+        Assert.False(map.Contains(1));
+        Assert.True(map.Contains(5));
+        Assert.True(map.Contains(9));
+    }
+
+    [Fact]
+    public void Stress_CollisionsAndRemovals()
+    {
+        var map = new BlitzMap<int, int>(8);
+
+        for (int i = 0; i < 1000; i++)
+            map.Insert(i * 4, i);
+
+        for (int i = 0; i < 500; i++)
+            Assert.True(map.Remove(i * 4));
+
+        for (int i = 500; i < 1000; i++)
+            Assert.Equal(i, map[i * 4]);
+    }
+
+
+
+
 }