HM_RehashIfRequired: Determine the optimum size

When the load factor is >> 1 it can be the case that just doubling the
size does not result in a hashmap with a load factor smaller than
HM_MAX_LOAD_FACTOR.

So let's calculate the optimum hashmap size instead. By factoring it out
into a function we can also properly test it.

Author: t-b

Packages/MIES/MIES_Hashmap.ipf

@@ -778,10 +778,20 @@ threadsafe static Function HM_CalculateLoadFactor(WAVE/WAVE hashmap)
 	return totalEntries[HM_TOTAL_ENTRIES_ROW] / HM_GetSize(hashmap)
 End
 
+/// @brief Calculate the optimum size for the hashmap so that the load factor is below #HM_MAX_LOAD_FACTOR
+///
+/// Complexity: O(1)
+threadsafe Function HM_CalculateOptimumSize(variable totalEntries)
+
+	totalEntries = max(1, totalEntries)
+
+	return 2^ceil(log(totalEntries / HM_MAX_LOAD_FACTOR) / log(2))
+End
+
 /// @brief Rehashes if required and returns a modified hashmap pass-by-reference
 ///
 /// The load factor (number of available entries vs filled entries) is determined.
-/// And if that is above #HM_MAX_LOAD_FACTOR we create a new hashmap with the doubled size and
+/// And if that is above #HM_MAX_LOAD_FACTOR we create a new hashmap with a large enough size and
 /// add all existing entries to it.
 ///
 /// Complexity: Usually amortized O(1) but in the worst case O(n)
@@ -801,8 +811,11 @@ threadsafe Function HM_RehashIfRequired(WAVE/WAVE &hashmap)
 	WAVE values = HM_FetchValues(hashmap, 0)
 	isStr = IsTextWave(values)
 
+	WAVE totalEntries = HM_FetchStats(hashmap)
+
 	srcNumEntries = HM_GetSize(hashmap)
-	newSize       = 2 * srcNumEntries
+	newSize       = HM_CalculateOptimumSize(totalEntries[HM_TOTAL_ENTRIES_ROW])
+	ASSERT_TS(newSize > srcNumEntries, "Invalid size calculation")
 	WAVE/WAVE hashmapLarger = HM_Create(size = newSize, valueType = WaveType(values))
 
 	WAVE usedRows = HM_FetchUsedRows(hashmap)

Packages/tests/Basic/UTF_Hashmap.ipf

@@ -451,12 +451,13 @@ End
 /// UTF_TD_GENERATOR DataGenerators#PermanentOrFree
 static Function RehashingWorks([variable var])
 
-	variable numEntries, i, size, found
+	variable numEntries, i, found, initialSize
 	string value
 
-	size = 8
+	initialSize = 1
+	numEntries  = 8
 
-	WAVE/WAVE hashmapFree = HM_Create(size = size)
+	WAVE/WAVE hashmapFree = HM_Create(size = initialSize)
 
 	if(var)
 		Duplicate/WAVE hashmapFree, hashmap
@@ -469,21 +470,21 @@ static Function RehashingWorks([variable var])
 	CHECK_EQUAL_VAR(HM_RehashIfRequired(hashmap), 0)
 	CHECK(WaveRefsEqual(hashmap, hashmap_old))
 
-	for(i = 0; i < size; i += 1)
+	for(i = 0; i < numEntries; i += 1)
 		HM_AddEntry(hashmap, num2str(i), str = "-" + num2str(i))
 	endfor
 
 	CHECK_EQUAL_VAR(HM_RehashIfRequired(hashmap), 1)
 	WAVE/WAVE hashmap_impl = hashmap[1]
-	CHECK_EQUAL_VAR(DimSize(hashmap_impl, ROWS), size * 2)
+	CHECK_EQUAL_VAR(DimSize(hashmap_impl, ROWS), numEntries * 2)
 	CHECK(!WaveRefsEqual(hashmap, hashmap_old))
 
 	WAVE/Z filledEntries = GetFilledEntries(hashmap)
 	CHECK_WAVE(filledEntries, NUMERIC_WAVE)
-	CHECK_EQUAL_VAR(DimSize(filledEntries, ROWS), size)
+	CHECK_EQUAL_VAR(DimSize(filledEntries, ROWS), numEntries)
 	CHECK_EQUAL_WAVES(filledEntries, {5, 6, 7, 8, 9, 10, 11, 12}, mode = WAVE_DATA)
 
-	for(i = 0; i < size; i += 1)
+	for(i = 0; i < numEntries; i += 1)
 		[value, found] = HM_GetEntryAsString(hashmap, num2str(i))
 		CHECK(found)
 		CHECK_EQUAL_STR(value, "-" + num2str(i))
@@ -590,3 +591,16 @@ static Function WorksWithNumericValues([variable var])
 		CHECK_NO_RTE()
 	endtry
 End
+
+Function CalcOptSizeWorks()
+
+	CHECK_EQUAL_VAR(HM_CalculateOptimumSize(0), 2)
+	CHECK_EQUAL_VAR(HM_CalculateOptimumSize(1), 2)
+	CHECK_EQUAL_VAR(HM_CalculateOptimumSize(2), 4)
+	CHECK_EQUAL_VAR(HM_CalculateOptimumSize(3), 8)
+	CHECK_EQUAL_VAR(HM_CalculateOptimumSize(4), 8)
+	CHECK_EQUAL_VAR(HM_CalculateOptimumSize(5), 8)
+	CHECK_EQUAL_VAR(HM_CalculateOptimumSize(6), 16)
+
+	CHECK_EQUAL_VAR(HM_CalculateOptimumSize(32), 64)
+End