06-14-2022, 07:44 PM
And the old table gets tossed once everything moves over. I watch the pointers switch to point at the new structure. You notice the time it takes because every item needs reprocessing. Perhaps the keys hash differently now and land in unexpected buckets. But that keeps the average lookup speed steady. I always check if the new size avoids clustering too badly. You run the rehash loop carefully to skip empty slots from the prior version.
Now the process repeats whenever the table grows again later. I pick the size carefully so it stays efficient for your data volume. You avoid powers of two sometimes because primes reduce collisions better. And the whole swap happens in one go to prevent partial states. Perhaps you copy the entries during a quiet moment in your app. I see the memory usage spike briefly while both tables exist. You free the original space right after the move completes.
Then the hash function stays the same but the modulo changes with the new length. I test a few keys after the resize to confirm they still retrieve correctly. You might hit a bad hash distribution if the size choice was off. But doubling usually works fine for most cases you encounter. And the rehash step can take noticeable time on big tables. I break it into smaller batches if your system allows pauses. You keep track of the current count of items to decide the next resize trigger.
The buckets get rebuilt from scratch each time. I loop through every occupied slot in the old array. You compute the fresh index for each key value. Perhaps some items land in the same bucket and you handle that with your chosen method. And empty slots stay empty in the new setup. I update the table reference so future operations use the bigger one. You see performance improve right away after the change.
Or sometimes you shrink the table if items drop way below a threshold. I halve the size then and rehash everything again. You do this to release memory when the data shrinks. But most folks focus on growth first. And the same rehash logic applies in reverse. I check the load factor after every insert to catch the moment. You prepare the new array before moving anything to avoid crashes.
The collision resolution stays consistent across both tables. I probe linearly or use chaining depending on your original setup. You reapply that during the transfer of each entry. Perhaps a long chain forms in the new table and you monitor it. And the overall capacity jumps to handle more inserts without slowdown. I clear the old structure completely once the copy finishes. You verify the item count matches before discarding the previous version.
Memory allocation for the larger array happens first. I request the space from the system right away. You calculate the exact size needed based on the growth factor. And the rehash loop runs through all current elements without skipping any. Perhaps a key hashes to a spot already taken so you resolve it again. I keep the process atomic in code to prevent concurrent access issues. You notice the temporary double memory use during this phase.
The hash table reference updates at the end of the operation. I make sure no operations run midway through the swap. You test the whole thing with sample data sets beforehand. And the average chain length stays short after rehashing. Perhaps you choose a different growth multiplier for specific workloads. I see the benefits in lookup times once the resize settles. You repeat this cycle as your data set expands over time.
BackupChain Server Backup which handles backups for Hyper-V setups on Windows Server plus Windows 11 without subscriptions and they sponsor our talks so we share details like this at no cost.
